difftreelog
doc(refungible-pallet): add documentation for ERC-721 implementation
in: master
1 file changed
pallets/refungible/src/erc.rsdiffbeforeafterboth1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617extern crate alloc;1819use alloc::string::ToString;20use core::{21 char::{REPLACEMENT_CHARACTER, decode_utf16},22 convert::TryInto,23};24use evm_coder::{ToLog, execution::*, generate_stubgen, solidity, solidity_interface, types::*, weight};25use frame_support::{BoundedBTreeMap, BoundedVec};26use pallet_common::{27 CollectionHandle, CollectionPropertyPermissions,28 erc::{29 CommonEvmHandler, CollectionCall,30 static_property::{key, value as property_value},31 },32};33use pallet_evm::{account::CrossAccountId, PrecompileHandle};34use pallet_evm_coder_substrate::{call, dispatch_to_evm};35use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};36use sp_core::H160;37use sp_std::{collections::btree_map::BTreeMap, vec::Vec, vec};38use up_data_structs::{39 CollectionId, CollectionPropertiesVec, Property, PropertyKey, PropertyKeyPermission,40 PropertyPermission, TokenId,41};4243use crate::{44 AccountBalance, Config, CreateItemData, Pallet, RefungibleHandle, SelfWeightOf,45 TokenProperties, TokensMinted, weights::WeightInfo,46};4748#[solidity_interface(name = "TokenProperties")]49impl<T: Config> RefungibleHandle<T> {50 fn set_token_property_permission(51 &mut self,52 caller: caller,53 key: string,54 is_mutable: bool,55 collection_admin: bool,56 token_owner: bool,57 ) -> Result<()> {58 let caller = T::CrossAccountId::from_eth(caller);59 <Pallet<T>>::set_token_property_permissions(60 self,61 &caller,62 vec![PropertyKeyPermission {63 key: <Vec<u8>>::from(key)64 .try_into()65 .map_err(|_| "too long key")?,66 permission: PropertyPermission {67 mutable: is_mutable,68 collection_admin,69 token_owner,70 },71 }],72 )73 .map_err(dispatch_to_evm::<T>)74 }7576 fn set_property(77 &mut self,78 caller: caller,79 token_id: uint256,80 key: string,81 value: bytes,82 ) -> Result<()> {83 let caller = T::CrossAccountId::from_eth(caller);84 let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;85 let key = <Vec<u8>>::from(key)86 .try_into()87 .map_err(|_| "key too long")?;88 let value = value.try_into().map_err(|_| "value too long")?;8990 let nesting_budget = self91 .recorder92 .weight_calls_budget(<StructureWeight<T>>::find_parent());9394 <Pallet<T>>::set_token_property(95 self,96 &caller,97 TokenId(token_id),98 Property { key, value },99 &nesting_budget,100 )101 .map_err(dispatch_to_evm::<T>)102 }103104 fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {105 let caller = T::CrossAccountId::from_eth(caller);106 let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;107 let key = <Vec<u8>>::from(key)108 .try_into()109 .map_err(|_| "key too long")?;110111 let nesting_budget = self112 .recorder113 .weight_calls_budget(<StructureWeight<T>>::find_parent());114115 <Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget)116 .map_err(dispatch_to_evm::<T>)117 }118119 /// Throws error if key not found120 fn property(&self, token_id: uint256, key: string) -> Result<bytes> {121 let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;122 let key = <Vec<u8>>::from(key)123 .try_into()124 .map_err(|_| "key too long")?;125126 let props = <TokenProperties<T>>::get((self.id, token_id));127 let prop = props.get(&key).ok_or("key not found")?;128129 Ok(prop.to_vec())130 }131}132133#[derive(ToLog)]134pub enum ERC721Events {135 Transfer {136 #[indexed]137 from: address,138 #[indexed]139 to: address,140 #[indexed]141 token_id: uint256,142 },143 /// @dev Not supported144 Approval {145 #[indexed]146 owner: address,147 #[indexed]148 approved: address,149 #[indexed]150 token_id: uint256,151 },152 /// @dev Not supported153 #[allow(dead_code)]154 ApprovalForAll {155 #[indexed]156 owner: address,157 #[indexed]158 operator: address,159 approved: bool,160 },161}162163#[derive(ToLog)]164pub enum ERC721MintableEvents {165 /// @dev Not supported166 #[allow(dead_code)]167 MintingFinished {},168}169170#[solidity_interface(name = "ERC721Metadata")]171impl<T: Config> RefungibleHandle<T> {172 fn name(&self) -> Result<string> {173 Ok(decode_utf16(self.name.iter().copied())174 .map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))175 .collect::<string>())176 }177178 fn symbol(&self) -> Result<string> {179 Ok(string::from_utf8_lossy(&self.token_prefix).into())180 }181182 /// @notice A distinct Uniform Resource Identifier (URI) for a given asset.183 ///184 /// @dev If the token has a `url` property and it is not empty, it is returned.185 /// Else If the collection does not have a property with key `schemaName` or its value is not equal to `ERC721Metadata`, it return an error `tokenURI not set`.186 /// If the collection property `baseURI` is empty or absent, return "" (empty string)187 /// otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix188 /// otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).189 ///190 /// @return token's const_metadata191 #[solidity(rename_selector = "tokenURI")]192 fn token_uri(&self, token_id: uint256) -> Result<string> {193 let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;194195 if let Ok(url) = get_token_property(self, token_id_u32, &key::url()) {196 if !url.is_empty() {197 return Ok(url);198 }199 } else if !is_erc721_metadata_compatible::<T>(self.id) {200 return Err("tokenURI not set".into());201 }202203 if let Some(base_uri) =204 pallet_common::Pallet::<T>::get_collection_property(self.id, &key::base_uri())205 {206 if !base_uri.is_empty() {207 let base_uri = string::from_utf8(base_uri.into_inner()).map_err(|e| {208 Error::Revert(alloc::format!(209 "Can not convert value \"baseURI\" to string with error \"{}\"",210 e211 ))212 })?;213 if let Ok(suffix) = get_token_property(self, token_id_u32, &key::suffix()) {214 if !suffix.is_empty() {215 return Ok(base_uri + suffix.as_str());216 }217 }218219 return Ok(base_uri + token_id.to_string().as_str());220 }221 }222223 Ok("".into())224 }225}226227#[solidity_interface(name = "ERC721Enumerable")]228impl<T: Config> RefungibleHandle<T> {229 fn token_by_index(&self, index: uint256) -> Result<uint256> {230 Ok(index)231 }232233 /// Not implemented234 fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {235 // TODO: Not implemetable236 Err("not implemented".into())237 }238239 fn total_supply(&self) -> Result<uint256> {240 self.consume_store_reads(1)?;241 Ok(<Pallet<T>>::total_supply(self).into())242 }243}244245#[solidity_interface(name = "ERC721", events(ERC721Events))]246impl<T: Config> RefungibleHandle<T> {247 fn balance_of(&self, owner: address) -> Result<uint256> {248 self.consume_store_reads(1)?;249 let owner = T::CrossAccountId::from_eth(owner);250 let balance = <AccountBalance<T>>::get((self.id, owner));251 Ok(balance.into())252 }253254 fn owner_of(&self, token_id: uint256) -> Result<address> {255 self.consume_store_reads(2)?;256 let token = token_id.try_into()?;257 let owner = <Pallet<T>>::token_owner(self.id, token);258 Ok(owner259 .map(|address| *address.as_eth())260 .unwrap_or_else(|| H160::default()))261 }262263 /// @dev Not implemented264 fn safe_transfer_from_with_data(265 &mut self,266 _from: address,267 _to: address,268 _token_id: uint256,269 _data: bytes,270 _value: value,271 ) -> Result<void> {272 // TODO: Not implemetable273 Err("not implemented".into())274 }275276 /// @dev Not implemented277 fn safe_transfer_from(278 &mut self,279 _from: address,280 _to: address,281 _token_id: uint256,282 _value: value,283 ) -> Result<void> {284 // TODO: Not implemetable285 Err("not implemented".into())286 }287288 /// @dev Not implemented289 fn transfer_from(290 &mut self,291 _caller: caller,292 _from: address,293 _to: address,294 _token_id: uint256,295 _value: value,296 ) -> Result<void> {297 Err("not implemented".into())298 }299300 /// @dev Not implemented301 fn approve(302 &mut self,303 _caller: caller,304 _approved: address,305 _token_id: uint256,306 _value: value,307 ) -> Result<void> {308 Err("not implemented".into())309 }310311 /// @dev Not implemented312 fn set_approval_for_all(313 &mut self,314 _caller: caller,315 _operator: address,316 _approved: bool,317 ) -> Result<void> {318 // TODO: Not implemetable319 Err("not implemented".into())320 }321322 /// @dev Not implemented323 fn get_approved(&self, _token_id: uint256) -> Result<address> {324 // TODO: Not implemetable325 Err("not implemented".into())326 }327328 /// @dev Not implemented329 fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {330 // TODO: Not implemetable331 Err("not implemented".into())332 }333}334335#[solidity_interface(name = "ERC721Burnable")]336impl<T: Config> RefungibleHandle<T> {337 /// @dev Not implemented338 fn burn(&mut self, _caller: caller, _token_id: uint256, _value: value) -> Result<void> {339 Err("not implemented".into())340 }341}342343#[solidity_interface(name = "ERC721Mintable", events(ERC721MintableEvents))]344impl<T: Config> RefungibleHandle<T> {345 fn minting_finished(&self) -> Result<bool> {346 Ok(false)347 }348349 /// `token_id` should be obtained with `next_token_id` method,350 /// unlike standard, you can't specify it manually351 #[weight(<SelfWeightOf<T>>::create_item())]352 fn mint(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {353 let caller = T::CrossAccountId::from_eth(caller);354 let to = T::CrossAccountId::from_eth(to);355 let token_id: u32 = token_id.try_into()?;356 let budget = self357 .recorder358 .weight_calls_budget(<StructureWeight<T>>::find_parent());359360 if <TokensMinted<T>>::get(self.id)361 .checked_add(1)362 .ok_or("item id overflow")?363 != token_id364 {365 return Err("item id should be next".into());366 }367368 let const_data = BoundedVec::default();369 let users = [(to.clone(), 1)]370 .into_iter()371 .collect::<BTreeMap<_, _>>()372 .try_into()373 .unwrap();374 <Pallet<T>>::create_item(375 self,376 &caller,377 CreateItemData::<T> {378 const_data,379 users,380 properties: CollectionPropertiesVec::default(),381 },382 &budget,383 )384 .map_err(dispatch_to_evm::<T>)?;385386 Ok(true)387 }388389 /// `token_id` should be obtained with `next_token_id` method,390 /// unlike standard, you can't specify it manually391 #[solidity(rename_selector = "mintWithTokenURI")]392 #[weight(<SelfWeightOf<T>>::create_item())]393 fn mint_with_token_uri(394 &mut self,395 caller: caller,396 to: address,397 token_id: uint256,398 token_uri: string,399 ) -> Result<bool> {400 let key = key::url();401 let permission = get_token_permission::<T>(self.id, &key)?;402 if !permission.collection_admin {403 return Err("Operation is not allowed".into());404 }405406 let caller = T::CrossAccountId::from_eth(caller);407 let to = T::CrossAccountId::from_eth(to);408 let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;409 let budget = self410 .recorder411 .weight_calls_budget(<StructureWeight<T>>::find_parent());412413 if <TokensMinted<T>>::get(self.id)414 .checked_add(1)415 .ok_or("item id overflow")?416 != token_id417 {418 return Err("item id should be next".into());419 }420421 let mut properties = CollectionPropertiesVec::default();422 properties423 .try_push(Property {424 key,425 value: token_uri426 .into_bytes()427 .try_into()428 .map_err(|_| "token uri is too long")?,429 })430 .map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;431432 let const_data = BoundedVec::default();433 let users = [(to.clone(), 1)]434 .into_iter()435 .collect::<BTreeMap<_, _>>()436 .try_into()437 .unwrap();438 <Pallet<T>>::create_item(439 self,440 &caller,441 CreateItemData::<T> {442 const_data,443 users,444 properties,445 },446 &budget,447 )448 .map_err(dispatch_to_evm::<T>)?;449 Ok(true)450 }451452 /// @dev Not implemented453 fn finish_minting(&mut self, _caller: caller) -> Result<bool> {454 Err("not implementable".into())455 }456}457458fn get_token_property<T: Config>(459 collection: &CollectionHandle<T>,460 token_id: u32,461 key: &up_data_structs::PropertyKey,462) -> Result<string> {463 collection.consume_store_reads(1)?;464 let properties = <TokenProperties<T>>::try_get((collection.id, token_id))465 .map_err(|_| Error::Revert("Token properties not found".into()))?;466 if let Some(property) = properties.get(key) {467 return Ok(string::from_utf8_lossy(property).into());468 }469470 Err("Property tokenURI not found".into())471}472473fn is_erc721_metadata_compatible<T: Config>(collection_id: CollectionId) -> bool {474 if let Some(shema_name) =475 pallet_common::Pallet::<T>::get_collection_property(collection_id, &key::schema_name())476 {477 let shema_name = shema_name.into_inner();478 shema_name == property_value::ERC721_METADATA479 } else {480 false481 }482}483484fn get_token_permission<T: Config>(485 collection_id: CollectionId,486 key: &PropertyKey,487) -> Result<PropertyPermission> {488 let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)489 .map_err(|_| Error::Revert("No permissions for collection".into()))?;490 let a = token_property_permissions491 .get(key)492 .map(Clone::clone)493 .ok_or_else(|| {494 let key = string::from_utf8(key.clone().into_inner()).unwrap_or_default();495 Error::Revert(alloc::format!("No permission for key {}", key))496 })?;497 Ok(a)498}499500#[solidity_interface(name = "ERC721UniqueExtensions")]501impl<T: Config> RefungibleHandle<T> {502 /// @notice Returns next free RFT ID.503 fn next_token_id(&self) -> Result<uint256> {504 self.consume_store_reads(1)?;505 Ok(<TokensMinted<T>>::get(self.id)506 .checked_add(1)507 .ok_or("item id overflow")?508 .into())509 }510511 #[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]512 fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {513 let caller = T::CrossAccountId::from_eth(caller);514 let to = T::CrossAccountId::from_eth(to);515 let mut expected_index = <TokensMinted<T>>::get(self.id)516 .checked_add(1)517 .ok_or("item id overflow")?;518 let budget = self519 .recorder520 .weight_calls_budget(<StructureWeight<T>>::find_parent());521522 let total_tokens = token_ids.len();523 for id in token_ids.into_iter() {524 let id: u32 = id.try_into().map_err(|_| "token id overflow")?;525 if id != expected_index {526 return Err("item id should be next".into());527 }528 expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;529 }530 let const_data = BoundedVec::default();531 let users = [(to.clone(), 1)]532 .into_iter()533 .collect::<BTreeMap<_, _>>()534 .try_into()535 .unwrap();536 let create_item_data = CreateItemData::<T> {537 const_data,538 users,539 properties: CollectionPropertiesVec::default(),540 };541 let data = (0..total_tokens)542 .map(|_| create_item_data.clone())543 .collect();544545 <Pallet<T>>::create_multiple_items(self, &caller, data, &budget)546 .map_err(dispatch_to_evm::<T>)?;547 Ok(true)548 }549550 #[solidity(rename_selector = "mintBulkWithTokenURI")]551 #[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]552 fn mint_bulk_with_token_uri(553 &mut self,554 caller: caller,555 to: address,556 tokens: Vec<(uint256, string)>,557 ) -> Result<bool> {558 let key = key::url();559 let caller = T::CrossAccountId::from_eth(caller);560 let to = T::CrossAccountId::from_eth(to);561 let mut expected_index = <TokensMinted<T>>::get(self.id)562 .checked_add(1)563 .ok_or("item id overflow")?;564 let budget = self565 .recorder566 .weight_calls_budget(<StructureWeight<T>>::find_parent());567568 let mut data = Vec::with_capacity(tokens.len());569 let const_data = BoundedVec::default();570 let users: BoundedBTreeMap<_, _, _> = [(to.clone(), 1)]571 .into_iter()572 .collect::<BTreeMap<_, _>>()573 .try_into()574 .unwrap();575 for (id, token_uri) in tokens {576 let id: u32 = id.try_into().map_err(|_| "token id overflow")?;577 if id != expected_index {578 return Err("item id should be next".into());579 }580 expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;581582 let mut properties = CollectionPropertiesVec::default();583 properties584 .try_push(Property {585 key: key.clone(),586 value: token_uri587 .into_bytes()588 .try_into()589 .map_err(|_| "token uri is too long")?,590 })591 .map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;592593 let create_item_data = CreateItemData::<T> {594 const_data: const_data.clone(),595 users: users.clone(),596 properties,597 };598 data.push(create_item_data);599 }600601 <Pallet<T>>::create_multiple_items(self, &caller, data, &budget)602 .map_err(dispatch_to_evm::<T>)?;603 Ok(true)604 }605}606607#[solidity_interface(608 name = "UniqueRefungible",609 is(610 ERC721,611 ERC721Metadata,612 ERC721Enumerable,613 ERC721UniqueExtensions,614 ERC721Mintable,615 ERC721Burnable,616 via("CollectionHandle<T>", common_mut, Collection),617 TokenProperties,618 )619)]620impl<T: Config> RefungibleHandle<T> where T::AccountId: From<[u8; 32]> {}621622// Not a tests, but code generators623generate_stubgen!(gen_impl, UniqueRefungibleCall<()>, true);624generate_stubgen!(gen_iface, UniqueRefungibleCall<()>, false);625626impl<T: Config> CommonEvmHandler for RefungibleHandle<T>627where628 T::AccountId: From<[u8; 32]>,629{630 const CODE: &'static [u8] = include_bytes!("./stubs/UniqueRefungible.raw");631 fn call(632 self,633 handle: &mut impl PrecompileHandle,634 ) -> Option<pallet_common::erc::PrecompileResult> {635 call::<T, UniqueRefungibleCall<T>, _, _>(handle, self)636 }637}1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617//! # Refungible Pallet EVM API for tokens18//!19//! Provides ERC-721 standart support implementation and EVM API for unique extensions for Refungible Pallet.20//! Method implementations are mostly doing parameter conversion and calling Refungible Pallet methods.2122extern crate alloc;2324use alloc::string::ToString;25use core::{26 char::{REPLACEMENT_CHARACTER, decode_utf16},27 convert::TryInto,28};29use evm_coder::{ToLog, execution::*, generate_stubgen, solidity, solidity_interface, types::*, weight};30use frame_support::{BoundedBTreeMap, BoundedVec};31use pallet_common::{32 CollectionHandle, CollectionPropertyPermissions,33 erc::{34 CommonEvmHandler, CollectionCall,35 static_property::{key, value as property_value},36 },37};38use pallet_evm::{account::CrossAccountId, PrecompileHandle};39use pallet_evm_coder_substrate::{call, dispatch_to_evm};40use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};41use sp_core::H160;42use sp_std::{collections::btree_map::BTreeMap, vec::Vec, vec};43use up_data_structs::{44 CollectionId, CollectionPropertiesVec, Property, PropertyKey, PropertyKeyPermission,45 PropertyPermission, TokenId,46};4748use crate::{49 AccountBalance, Config, CreateItemData, Pallet, RefungibleHandle, SelfWeightOf,50 TokenProperties, TokensMinted, weights::WeightInfo,51};5253/// @title A contract that allows to set and delete token properties and change token property permissions.54#[solidity_interface(name = "TokenProperties")]55impl<T: Config> RefungibleHandle<T> {56 /// @notice Set permissions for token property.57 /// @dev Throws error if `msg.sender` is not admin or owner of the collection.58 /// @param key Property key.59 /// @param is_mutable Permission to mutate property.60 /// @param collection_admin Permission to mutate property by collection admin if property is mutable.61 /// @param token_owner Permission to mutate property by token owner if property is mutable.62 fn set_token_property_permission(63 &mut self,64 caller: caller,65 key: string,66 is_mutable: bool,67 collection_admin: bool,68 token_owner: bool,69 ) -> Result<()> {70 let caller = T::CrossAccountId::from_eth(caller);71 <Pallet<T>>::set_token_property_permissions(72 self,73 &caller,74 vec![PropertyKeyPermission {75 key: <Vec<u8>>::from(key)76 .try_into()77 .map_err(|_| "too long key")?,78 permission: PropertyPermission {79 mutable: is_mutable,80 collection_admin,81 token_owner,82 },83 }],84 )85 .map_err(dispatch_to_evm::<T>)86 }8788 /// @notice Set token property value.89 /// @dev Throws error if `msg.sender` has no permission to edit the property.90 /// @param tokenId ID of the token.91 /// @param key Property key.92 /// @param value Property value.93 fn set_property(94 &mut self,95 caller: caller,96 token_id: uint256,97 key: string,98 value: bytes,99 ) -> Result<()> {100 let caller = T::CrossAccountId::from_eth(caller);101 let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;102 let key = <Vec<u8>>::from(key)103 .try_into()104 .map_err(|_| "key too long")?;105 let value = value.try_into().map_err(|_| "value too long")?;106107 let nesting_budget = self108 .recorder109 .weight_calls_budget(<StructureWeight<T>>::find_parent());110111 <Pallet<T>>::set_token_property(112 self,113 &caller,114 TokenId(token_id),115 Property { key, value },116 &nesting_budget,117 )118 .map_err(dispatch_to_evm::<T>)119 }120121 /// @notice Delete token property value.122 /// @dev Throws error if `msg.sender` has no permission to edit the property.123 /// @param tokenId ID of the token.124 /// @param key Property key.125 fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {126 let caller = T::CrossAccountId::from_eth(caller);127 let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;128 let key = <Vec<u8>>::from(key)129 .try_into()130 .map_err(|_| "key too long")?;131132 let nesting_budget = self133 .recorder134 .weight_calls_budget(<StructureWeight<T>>::find_parent());135136 <Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget)137 .map_err(dispatch_to_evm::<T>)138 }139140 /// @notice Get token property value.141 /// @dev Throws error if key not found142 /// @param tokenId ID of the token.143 /// @param key Property key.144 /// @return Property value bytes145 fn property(&self, token_id: uint256, key: string) -> Result<bytes> {146 let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;147 let key = <Vec<u8>>::from(key)148 .try_into()149 .map_err(|_| "key too long")?;150151 let props = <TokenProperties<T>>::get((self.id, token_id));152 let prop = props.get(&key).ok_or("key not found")?;153154 Ok(prop.to_vec())155 }156}157158#[derive(ToLog)]159pub enum ERC721Events {160 /// @dev This event emits when NFTs are created (`from` == 0) and destroyed161 /// (`to` == 0). Exception: during contract creation, any number of RFTs162 /// may be created and assigned without emitting Transfer.163 Transfer {164 #[indexed]165 from: address,166 #[indexed]167 to: address,168 #[indexed]169 token_id: uint256,170 },171 /// @dev Not supported172 Approval {173 #[indexed]174 owner: address,175 #[indexed]176 approved: address,177 #[indexed]178 token_id: uint256,179 },180 /// @dev Not supported181 #[allow(dead_code)]182 ApprovalForAll {183 #[indexed]184 owner: address,185 #[indexed]186 operator: address,187 approved: bool,188 },189}190191#[derive(ToLog)]192pub enum ERC721MintableEvents {193 /// @dev Not supported194 #[allow(dead_code)]195 MintingFinished {},196}197198#[solidity_interface(name = "ERC721Metadata")]199impl<T: Config> RefungibleHandle<T> {200 /// @notice A descriptive name for a collection of RFTs in this contract201 fn name(&self) -> Result<string> {202 Ok(decode_utf16(self.name.iter().copied())203 .map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))204 .collect::<string>())205 }206207 /// @notice An abbreviated name for RFTs in this contract208 fn symbol(&self) -> Result<string> {209 Ok(string::from_utf8_lossy(&self.token_prefix).into())210 }211212 /// @notice A distinct Uniform Resource Identifier (URI) for a given asset.213 ///214 /// @dev If the token has a `url` property and it is not empty, it is returned.215 /// Else If the collection does not have a property with key `schemaName` or its value is not equal to `ERC721Metadata`, it return an error `tokenURI not set`.216 /// If the collection property `baseURI` is empty or absent, return "" (empty string)217 /// otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix218 /// otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).219 ///220 /// @return token's const_metadata221 #[solidity(rename_selector = "tokenURI")]222 fn token_uri(&self, token_id: uint256) -> Result<string> {223 let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;224225 if let Ok(url) = get_token_property(self, token_id_u32, &key::url()) {226 if !url.is_empty() {227 return Ok(url);228 }229 } else if !is_erc721_metadata_compatible::<T>(self.id) {230 return Err("tokenURI not set".into());231 }232233 if let Some(base_uri) =234 pallet_common::Pallet::<T>::get_collection_property(self.id, &key::base_uri())235 {236 if !base_uri.is_empty() {237 let base_uri = string::from_utf8(base_uri.into_inner()).map_err(|e| {238 Error::Revert(alloc::format!(239 "Can not convert value \"baseURI\" to string with error \"{}\"",240 e241 ))242 })?;243 if let Ok(suffix) = get_token_property(self, token_id_u32, &key::suffix()) {244 if !suffix.is_empty() {245 return Ok(base_uri + suffix.as_str());246 }247 }248249 return Ok(base_uri + token_id.to_string().as_str());250 }251 }252253 Ok("".into())254 }255}256257/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension258/// @dev See https://eips.ethereum.org/EIPS/eip-721259#[solidity_interface(name = "ERC721Enumerable")]260impl<T: Config> RefungibleHandle<T> {261 /// @notice Enumerate valid RFTs262 /// @param index A counter less than `totalSupply()`263 /// @return The token identifier for the `index`th NFT,264 /// (sort order not specified)265 fn token_by_index(&self, index: uint256) -> Result<uint256> {266 Ok(index)267 }268269 /// Not implemented270 fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {271 // TODO: Not implemetable272 Err("not implemented".into())273 }274275 /// @notice Count RFTs tracked by this contract276 /// @return A count of valid RFTs tracked by this contract, where each one of277 /// them has an assigned and queryable owner not equal to the zero address278 fn total_supply(&self) -> Result<uint256> {279 self.consume_store_reads(1)?;280 Ok(<Pallet<T>>::total_supply(self).into())281 }282}283284/// @title ERC-721 Non-Fungible Token Standard285/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md286#[solidity_interface(name = "ERC721", events(ERC721Events))]287impl<T: Config> RefungibleHandle<T> {288 /// @notice Count all RFTs assigned to an owner289 /// @dev RFTs assigned to the zero address are considered invalid, and this290 /// function throws for queries about the zero address.291 /// @param owner An address for whom to query the balance292 /// @return The number of RFTs owned by `owner`, possibly zero293 fn balance_of(&self, owner: address) -> Result<uint256> {294 self.consume_store_reads(1)?;295 let owner = T::CrossAccountId::from_eth(owner);296 let balance = <AccountBalance<T>>::get((self.id, owner));297 Ok(balance.into())298 }299300 fn owner_of(&self, token_id: uint256) -> Result<address> {301 self.consume_store_reads(2)?;302 let token = token_id.try_into()?;303 let owner = <Pallet<T>>::token_owner(self.id, token);304 Ok(owner305 .map(|address| *address.as_eth())306 .unwrap_or_else(|| H160::default()))307 }308309 /// @dev Not implemented310 fn safe_transfer_from_with_data(311 &mut self,312 _from: address,313 _to: address,314 _token_id: uint256,315 _data: bytes,316 _value: value,317 ) -> Result<void> {318 // TODO: Not implemetable319 Err("not implemented".into())320 }321322 /// @dev Not implemented323 fn safe_transfer_from(324 &mut self,325 _from: address,326 _to: address,327 _token_id: uint256,328 _value: value,329 ) -> Result<void> {330 // TODO: Not implemetable331 Err("not implemented".into())332 }333334 /// @dev Not implemented335 fn transfer_from(336 &mut self,337 _caller: caller,338 _from: address,339 _to: address,340 _token_id: uint256,341 _value: value,342 ) -> Result<void> {343 Err("not implemented".into())344 }345346 /// @dev Not implemented347 fn approve(348 &mut self,349 _caller: caller,350 _approved: address,351 _token_id: uint256,352 _value: value,353 ) -> Result<void> {354 Err("not implemented".into())355 }356357 /// @dev Not implemented358 fn set_approval_for_all(359 &mut self,360 _caller: caller,361 _operator: address,362 _approved: bool,363 ) -> Result<void> {364 // TODO: Not implemetable365 Err("not implemented".into())366 }367368 /// @dev Not implemented369 fn get_approved(&self, _token_id: uint256) -> Result<address> {370 // TODO: Not implemetable371 Err("not implemented".into())372 }373374 /// @dev Not implemented375 fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {376 // TODO: Not implemetable377 Err("not implemented".into())378 }379}380381/// @title ERC721 Token that can be irreversibly burned (destroyed).382#[solidity_interface(name = "ERC721Burnable")]383impl<T: Config> RefungibleHandle<T> {384 /// @dev Not implemented385 fn burn(&mut self, _caller: caller, _token_id: uint256, _value: value) -> Result<void> {386 Err("not implemented".into())387 }388}389390/// @title ERC721 minting logic.391#[solidity_interface(name = "ERC721Mintable", events(ERC721MintableEvents))]392impl<T: Config> RefungibleHandle<T> {393 fn minting_finished(&self) -> Result<bool> {394 Ok(false)395 }396397 /// @notice Function to mint token.398 /// @dev `tokenId` should be obtained with `nextTokenId` method,399 /// unlike standard, you can't specify it manually400 /// @param to The new owner401 /// @param tokenId ID of the minted RFT402 #[weight(<SelfWeightOf<T>>::create_item())]403 fn mint(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {404 let caller = T::CrossAccountId::from_eth(caller);405 let to = T::CrossAccountId::from_eth(to);406 let token_id: u32 = token_id.try_into()?;407 let budget = self408 .recorder409 .weight_calls_budget(<StructureWeight<T>>::find_parent());410411 if <TokensMinted<T>>::get(self.id)412 .checked_add(1)413 .ok_or("item id overflow")?414 != token_id415 {416 return Err("item id should be next".into());417 }418419 let const_data = BoundedVec::default();420 let users = [(to.clone(), 1)]421 .into_iter()422 .collect::<BTreeMap<_, _>>()423 .try_into()424 .unwrap();425 <Pallet<T>>::create_item(426 self,427 &caller,428 CreateItemData::<T> {429 const_data,430 users,431 properties: CollectionPropertiesVec::default(),432 },433 &budget,434 )435 .map_err(dispatch_to_evm::<T>)?;436437 Ok(true)438 }439440 /// @notice Function to mint token with the given tokenUri.441 /// @dev `tokenId` should be obtained with `nextTokenId` method,442 /// unlike standard, you can't specify it manually443 /// @param to The new owner444 /// @param tokenId ID of the minted RFT445 /// @param tokenUri Token URI that would be stored in the RFT properties446 #[solidity(rename_selector = "mintWithTokenURI")]447 #[weight(<SelfWeightOf<T>>::create_item())]448 fn mint_with_token_uri(449 &mut self,450 caller: caller,451 to: address,452 token_id: uint256,453 token_uri: string,454 ) -> Result<bool> {455 let key = key::url();456 let permission = get_token_permission::<T>(self.id, &key)?;457 if !permission.collection_admin {458 return Err("Operation is not allowed".into());459 }460461 let caller = T::CrossAccountId::from_eth(caller);462 let to = T::CrossAccountId::from_eth(to);463 let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;464 let budget = self465 .recorder466 .weight_calls_budget(<StructureWeight<T>>::find_parent());467468 if <TokensMinted<T>>::get(self.id)469 .checked_add(1)470 .ok_or("item id overflow")?471 != token_id472 {473 return Err("item id should be next".into());474 }475476 let mut properties = CollectionPropertiesVec::default();477 properties478 .try_push(Property {479 key,480 value: token_uri481 .into_bytes()482 .try_into()483 .map_err(|_| "token uri is too long")?,484 })485 .map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;486487 let const_data = BoundedVec::default();488 let users = [(to.clone(), 1)]489 .into_iter()490 .collect::<BTreeMap<_, _>>()491 .try_into()492 .unwrap();493 <Pallet<T>>::create_item(494 self,495 &caller,496 CreateItemData::<T> {497 const_data,498 users,499 properties,500 },501 &budget,502 )503 .map_err(dispatch_to_evm::<T>)?;504 Ok(true)505 }506507 /// @dev Not implemented508 fn finish_minting(&mut self, _caller: caller) -> Result<bool> {509 Err("not implementable".into())510 }511}512513fn get_token_property<T: Config>(514 collection: &CollectionHandle<T>,515 token_id: u32,516 key: &up_data_structs::PropertyKey,517) -> Result<string> {518 collection.consume_store_reads(1)?;519 let properties = <TokenProperties<T>>::try_get((collection.id, token_id))520 .map_err(|_| Error::Revert("Token properties not found".into()))?;521 if let Some(property) = properties.get(key) {522 return Ok(string::from_utf8_lossy(property).into());523 }524525 Err("Property tokenURI not found".into())526}527528fn is_erc721_metadata_compatible<T: Config>(collection_id: CollectionId) -> bool {529 if let Some(shema_name) =530 pallet_common::Pallet::<T>::get_collection_property(collection_id, &key::schema_name())531 {532 let shema_name = shema_name.into_inner();533 shema_name == property_value::ERC721_METADATA534 } else {535 false536 }537}538539fn get_token_permission<T: Config>(540 collection_id: CollectionId,541 key: &PropertyKey,542) -> Result<PropertyPermission> {543 let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)544 .map_err(|_| Error::Revert("No permissions for collection".into()))?;545 let a = token_property_permissions546 .get(key)547 .map(Clone::clone)548 .ok_or_else(|| {549 let key = string::from_utf8(key.clone().into_inner()).unwrap_or_default();550 Error::Revert(alloc::format!("No permission for key {}", key))551 })?;552 Ok(a)553}554555/// @title Unique extensions for ERC721.556#[solidity_interface(name = "ERC721UniqueExtensions")]557impl<T: Config> RefungibleHandle<T> {558 /// @notice Returns next free RFT ID.559 fn next_token_id(&self) -> Result<uint256> {560 self.consume_store_reads(1)?;561 Ok(<TokensMinted<T>>::get(self.id)562 .checked_add(1)563 .ok_or("item id overflow")?564 .into())565 }566567 /// @notice Function to mint multiple tokens.568 /// @dev `tokenIds` should be an array of consecutive numbers and first number569 /// should be obtained with `nextTokenId` method570 /// @param to The new owner571 /// @param tokenIds IDs of the minted RFTs572 #[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]573 fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {574 let caller = T::CrossAccountId::from_eth(caller);575 let to = T::CrossAccountId::from_eth(to);576 let mut expected_index = <TokensMinted<T>>::get(self.id)577 .checked_add(1)578 .ok_or("item id overflow")?;579 let budget = self580 .recorder581 .weight_calls_budget(<StructureWeight<T>>::find_parent());582583 let total_tokens = token_ids.len();584 for id in token_ids.into_iter() {585 let id: u32 = id.try_into().map_err(|_| "token id overflow")?;586 if id != expected_index {587 return Err("item id should be next".into());588 }589 expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;590 }591 let const_data = BoundedVec::default();592 let users = [(to.clone(), 1)]593 .into_iter()594 .collect::<BTreeMap<_, _>>()595 .try_into()596 .unwrap();597 let create_item_data = CreateItemData::<T> {598 const_data,599 users,600 properties: CollectionPropertiesVec::default(),601 };602 let data = (0..total_tokens)603 .map(|_| create_item_data.clone())604 .collect();605606 <Pallet<T>>::create_multiple_items(self, &caller, data, &budget)607 .map_err(dispatch_to_evm::<T>)?;608 Ok(true)609 }610611 /// @notice Function to mint multiple tokens with the given tokenUris.612 /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive613 /// numbers and first number should be obtained with `nextTokenId` method614 /// @param to The new owner615 /// @param tokens array of pairs of token ID and token URI for minted tokens616 #[solidity(rename_selector = "mintBulkWithTokenURI")]617 #[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]618 fn mint_bulk_with_token_uri(619 &mut self,620 caller: caller,621 to: address,622 tokens: Vec<(uint256, string)>,623 ) -> Result<bool> {624 let key = key::url();625 let caller = T::CrossAccountId::from_eth(caller);626 let to = T::CrossAccountId::from_eth(to);627 let mut expected_index = <TokensMinted<T>>::get(self.id)628 .checked_add(1)629 .ok_or("item id overflow")?;630 let budget = self631 .recorder632 .weight_calls_budget(<StructureWeight<T>>::find_parent());633634 let mut data = Vec::with_capacity(tokens.len());635 let const_data = BoundedVec::default();636 let users: BoundedBTreeMap<_, _, _> = [(to.clone(), 1)]637 .into_iter()638 .collect::<BTreeMap<_, _>>()639 .try_into()640 .unwrap();641 for (id, token_uri) in tokens {642 let id: u32 = id.try_into().map_err(|_| "token id overflow")?;643 if id != expected_index {644 return Err("item id should be next".into());645 }646 expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;647648 let mut properties = CollectionPropertiesVec::default();649 properties650 .try_push(Property {651 key: key.clone(),652 value: token_uri653 .into_bytes()654 .try_into()655 .map_err(|_| "token uri is too long")?,656 })657 .map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;658659 let create_item_data = CreateItemData::<T> {660 const_data: const_data.clone(),661 users: users.clone(),662 properties,663 };664 data.push(create_item_data);665 }666667 <Pallet<T>>::create_multiple_items(self, &caller, data, &budget)668 .map_err(dispatch_to_evm::<T>)?;669 Ok(true)670 }671}672673#[solidity_interface(674 name = "UniqueRefungible",675 is(676 ERC721,677 ERC721Metadata,678 ERC721Enumerable,679 ERC721UniqueExtensions,680 ERC721Mintable,681 ERC721Burnable,682 via("CollectionHandle<T>", common_mut, Collection),683 TokenProperties,684 )685)]686impl<T: Config> RefungibleHandle<T> where T::AccountId: From<[u8; 32]> {}687688// Not a tests, but code generators689generate_stubgen!(gen_impl, UniqueRefungibleCall<()>, true);690generate_stubgen!(gen_iface, UniqueRefungibleCall<()>, false);691692impl<T: Config> CommonEvmHandler for RefungibleHandle<T>693where694 T::AccountId: From<[u8; 32]>,695{696 const CODE: &'static [u8] = include_bytes!("./stubs/UniqueRefungible.raw");697 fn call(698 self,699 handle: &mut impl PrecompileHandle,700 ) -> Option<pallet_common::erc::PrecompileResult> {701 call::<T, UniqueRefungibleCall<T>, _, _>(handle, self)702 }703}