difftreelog
refactor Make implementations of Abi* for EthCrossAccount via AbiCoder macro
in: master
2 files changed
crates/evm-coder/src/solidity/mod.rsdiffbeforeafterboth--- a/crates/evm-coder/src/solidity/mod.rs
+++ b/crates/evm-coder/src/solidity/mod.rs
@@ -86,7 +86,6 @@
data.into_iter().map(|(code, _)| code).collect()
}
}
-
#[derive(Default)]
pub struct UnnamedArgument<T>(PhantomData<*const T>);
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/>.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 core::{25 char::{REPLACEMENT_CHARACTER, decode_utf16},26 convert::TryInto,27};28use evm_coder::{29 abi::AbiType, ToLog, execution::*, generate_stubgen, solidity, solidity_interface, types::*,30 types::Property as PropertyStruct, weight,31};32use frame_support::{BoundedBTreeMap, BoundedVec};33use pallet_common::{34 CollectionHandle, CollectionPropertyPermissions,35 erc::{CommonEvmHandler, CollectionCall, static_property::key},36 eth::EthCrossAccount,37 CommonCollectionOperations,38};39use pallet_evm::{account::CrossAccountId, PrecompileHandle};40use pallet_evm_coder_substrate::{call, dispatch_to_evm};41use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};42use sp_core::{H160, Get};43use sp_std::{collections::btree_map::BTreeMap, vec::Vec, vec};44use up_data_structs::{45 CollectionId, CollectionPropertiesVec, mapping::TokenAddressMapping, Property, PropertyKey,46 PropertyKeyPermission, PropertyPermission, TokenId,47};4849use crate::{50 AccountBalance, Balance, Config, CreateItemData, Pallet, RefungibleHandle, SelfWeightOf,51 TokenProperties, TokensMinted, TotalSupply, weights::WeightInfo,52};5354pub const ADDRESS_FOR_PARTIALLY_OWNED_TOKENS: H160 = H160::repeat_byte(0xff);5556/// @title A contract that allows to set and delete token properties and change token property permissions.57#[solidity_interface(name = TokenProperties)]58impl<T: Config> RefungibleHandle<T> {59 /// @notice Set permissions for token property.60 /// @dev Throws error if `msg.sender` is not admin or owner of the collection.61 /// @param key Property key.62 /// @param isMutable Permission to mutate property.63 /// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.64 /// @param tokenOwner Permission to mutate property by token owner if property is mutable.65 fn set_token_property_permission(66 &mut self,67 caller: caller,68 key: string,69 is_mutable: bool,70 collection_admin: bool,71 token_owner: bool,72 ) -> Result<()> {73 let caller = T::CrossAccountId::from_eth(caller);74 <Pallet<T>>::set_token_property_permissions(75 self,76 &caller,77 vec![PropertyKeyPermission {78 key: <Vec<u8>>::from(key)79 .try_into()80 .map_err(|_| "too long key")?,81 permission: PropertyPermission {82 mutable: is_mutable,83 collection_admin,84 token_owner,85 },86 }],87 )88 .map_err(dispatch_to_evm::<T>)89 }9091 /// @notice Set token property value.92 /// @dev Throws error if `msg.sender` has no permission to edit the property.93 /// @param tokenId ID of the token.94 /// @param key Property key.95 /// @param value Property value.96 #[solidity(hide)]97 fn set_property(98 &mut self,99 caller: caller,100 token_id: uint256,101 key: string,102 value: bytes,103 ) -> Result<()> {104 let caller = T::CrossAccountId::from_eth(caller);105 let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;106 let key = <Vec<u8>>::from(key)107 .try_into()108 .map_err(|_| "key too long")?;109 let value = value.0.try_into().map_err(|_| "value too long")?;110111 let nesting_budget = self112 .recorder113 .weight_calls_budget(<StructureWeight<T>>::find_parent());114115 <Pallet<T>>::set_token_property(116 self,117 &caller,118 TokenId(token_id),119 Property { key, value },120 &nesting_budget,121 )122 .map_err(dispatch_to_evm::<T>)123 }124125 /// @notice Set token properties value.126 /// @dev Throws error if `msg.sender` has no permission to edit the property.127 /// @param tokenId ID of the token.128 /// @param properties settable properties129 fn set_properties(130 &mut self,131 caller: caller,132 token_id: uint256,133 properties: Vec<PropertyStruct>,134 ) -> Result<()> {135 let caller = T::CrossAccountId::from_eth(caller);136 let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;137138 let nesting_budget = self139 .recorder140 .weight_calls_budget(<StructureWeight<T>>::find_parent());141142 let properties = properties143 .into_iter()144 .map(|PropertyStruct { key, value }| {145 let key = <Vec<u8>>::from(key)146 .try_into()147 .map_err(|_| "key too large")?;148149 let value = value.0.try_into().map_err(|_| "value too large")?;150151 Ok(Property { key, value })152 })153 .collect::<Result<Vec<_>>>()?;154155 <Pallet<T>>::set_token_properties(156 self,157 &caller,158 TokenId(token_id),159 properties.into_iter(),160 <Pallet<T>>::token_exists(&self, TokenId(token_id)),161 &nesting_budget,162 )163 .map_err(dispatch_to_evm::<T>)164 }165166 /// @notice Delete token property value.167 /// @dev Throws error if `msg.sender` has no permission to edit the property.168 /// @param tokenId ID of the token.169 /// @param key Property key.170 #[solidity(hide)]171 fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {172 let caller = T::CrossAccountId::from_eth(caller);173 let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;174 let key = <Vec<u8>>::from(key)175 .try_into()176 .map_err(|_| "key too long")?;177178 let nesting_budget = self179 .recorder180 .weight_calls_budget(<StructureWeight<T>>::find_parent());181182 <Pallet<T>>::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget)183 .map_err(dispatch_to_evm::<T>)184 }185186 /// @notice Delete token properties value.187 /// @dev Throws error if `msg.sender` has no permission to edit the property.188 /// @param tokenId ID of the token.189 /// @param keys Properties key.190 fn delete_properties(191 &mut self,192 token_id: uint256,193 caller: caller,194 keys: Vec<string>,195 ) -> Result<()> {196 let caller = T::CrossAccountId::from_eth(caller);197 let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;198 let keys = keys199 .into_iter()200 .map(|k| Ok(<Vec<u8>>::from(k).try_into().map_err(|_| "key too long")?))201 .collect::<Result<Vec<_>>>()?;202203 let nesting_budget = self204 .recorder205 .weight_calls_budget(<StructureWeight<T>>::find_parent());206207 <Pallet<T>>::delete_token_properties(208 self,209 &caller,210 TokenId(token_id),211 keys.into_iter(),212 &nesting_budget,213 )214 .map_err(dispatch_to_evm::<T>)215 }216217 /// @notice Get token property value.218 /// @dev Throws error if key not found219 /// @param tokenId ID of the token.220 /// @param key Property key.221 /// @return Property value bytes222 fn property(&self, token_id: uint256, key: string) -> Result<bytes> {223 let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;224 let key = <Vec<u8>>::from(key)225 .try_into()226 .map_err(|_| "key too long")?;227228 let props = <TokenProperties<T>>::get((self.id, token_id));229 let prop = props.get(&key).ok_or("key not found")?;230231 Ok(prop.to_vec().into())232 }233}234235#[derive(ToLog)]236pub enum ERC721Events {237 /// @dev This event emits when NFTs are created (`from` == 0) and destroyed238 /// (`to` == 0). Exception: during contract creation, any number of RFTs239 /// may be created and assigned without emitting Transfer.240 Transfer {241 #[indexed]242 from: address,243 #[indexed]244 to: address,245 #[indexed]246 token_id: uint256,247 },248 /// @dev Not supported249 Approval {250 #[indexed]251 owner: address,252 #[indexed]253 approved: address,254 #[indexed]255 token_id: uint256,256 },257 /// @dev Not supported258 #[allow(dead_code)]259 ApprovalForAll {260 #[indexed]261 owner: address,262 #[indexed]263 operator: address,264 approved: bool,265 },266}267268#[derive(ToLog)]269pub enum ERC721UniqueMintableEvents {270 /// @dev Not supported271 #[allow(dead_code)]272 MintingFinished {},273}274275#[solidity_interface(name = ERC721Metadata)]276impl<T: Config> RefungibleHandle<T>277where278 T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,279{280 /// @notice A descriptive name for a collection of NFTs in this contract281 /// @dev real implementation of this function lies in `ERC721UniqueExtensions`282 #[solidity(hide, rename_selector = "name")]283 fn name_proxy(&self) -> Result<string> {284 self.name()285 }286287 /// @notice An abbreviated name for NFTs in this contract288 /// @dev real implementation of this function lies in `ERC721UniqueExtensions`289 #[solidity(hide, rename_selector = "symbol")]290 fn symbol_proxy(&self) -> Result<string> {291 self.symbol()292 }293294 /// @notice A distinct Uniform Resource Identifier (URI) for a given asset.295 ///296 /// @dev If the token has a `url` property and it is not empty, it is returned.297 /// 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`.298 /// If the collection property `baseURI` is empty or absent, return "" (empty string)299 /// otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix300 /// otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).301 ///302 /// @return token's const_metadata303 #[solidity(rename_selector = "tokenURI")]304 fn token_uri(&self, token_id: uint256) -> Result<string> {305 let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;306307 match get_token_property(self, token_id_u32, &key::url()).as_deref() {308 Err(_) | Ok("") => (),309 Ok(url) => {310 return Ok(url.into());311 }312 };313314 let base_uri =315 pallet_common::Pallet::<T>::get_collection_property(self.id, &key::base_uri())316 .map(BoundedVec::into_inner)317 .map(string::from_utf8)318 .transpose()319 .map_err(|e| {320 Error::Revert(alloc::format!(321 "Can not convert value \"baseURI\" to string with error \"{}\"",322 e323 ))324 })?;325326 let base_uri = match base_uri.as_deref() {327 None | Some("") => {328 return Ok("".into());329 }330 Some(base_uri) => base_uri.into(),331 };332333 Ok(334 match get_token_property(self, token_id_u32, &key::suffix()).as_deref() {335 Err(_) | Ok("") => base_uri,336 Ok(suffix) => base_uri + suffix,337 },338 )339 }340}341342/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension343/// @dev See https://eips.ethereum.org/EIPS/eip-721344#[solidity_interface(name = ERC721Enumerable)]345impl<T: Config> RefungibleHandle<T> {346 /// @notice Enumerate valid RFTs347 /// @param index A counter less than `totalSupply()`348 /// @return The token identifier for the `index`th NFT,349 /// (sort order not specified)350 fn token_by_index(&self, index: uint256) -> Result<uint256> {351 Ok(index)352 }353354 /// Not implemented355 fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {356 // TODO: Not implemetable357 Err("not implemented".into())358 }359360 /// @notice Count RFTs tracked by this contract361 /// @return A count of valid RFTs tracked by this contract, where each one of362 /// them has an assigned and queryable owner not equal to the zero address363 fn total_supply(&self) -> Result<uint256> {364 self.consume_store_reads(1)?;365 Ok(<Pallet<T>>::total_supply(self).into())366 }367}368369/// @title ERC-721 Non-Fungible Token Standard370/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md371#[solidity_interface(name = ERC721, events(ERC721Events))]372impl<T: Config> RefungibleHandle<T> {373 /// @notice Count all RFTs assigned to an owner374 /// @dev RFTs assigned to the zero address are considered invalid, and this375 /// function throws for queries about the zero address.376 /// @param owner An address for whom to query the balance377 /// @return The number of RFTs owned by `owner`, possibly zero378 fn balance_of(&self, owner: address) -> Result<uint256> {379 self.consume_store_reads(1)?;380 let owner = T::CrossAccountId::from_eth(owner);381 let balance = <AccountBalance<T>>::get((self.id, owner));382 Ok(balance.into())383 }384385 /// @notice Find the owner of an RFT386 /// @dev RFTs assigned to zero address are considered invalid, and queries387 /// about them do throw.388 /// Returns special 0xffffffffffffffffffffffffffffffffffffffff address for389 /// the tokens that are partially owned.390 /// @param tokenId The identifier for an RFT391 /// @return The address of the owner of the RFT392 fn owner_of(&self, token_id: uint256) -> Result<address> {393 self.consume_store_reads(2)?;394 let token = token_id.try_into()?;395 let owner = <Pallet<T>>::token_owner(self.id, token);396 Ok(owner397 .map(|address| *address.as_eth())398 .unwrap_or_else(|| ADDRESS_FOR_PARTIALLY_OWNED_TOKENS))399 }400401 /// @dev Not implemented402 fn safe_transfer_from_with_data(403 &mut self,404 _from: address,405 _to: address,406 _token_id: uint256,407 _data: bytes,408 ) -> Result<void> {409 // TODO: Not implemetable410 Err("not implemented".into())411 }412413 /// @dev Not implemented414 fn safe_transfer_from(415 &mut self,416 _from: address,417 _to: address,418 _token_id: uint256,419 ) -> Result<void> {420 // TODO: Not implemetable421 Err("not implemented".into())422 }423424 /// @notice Transfer ownership of an RFT -- THE CALLER IS RESPONSIBLE425 /// TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE426 /// THEY MAY BE PERMANENTLY LOST427 /// @dev Throws unless `msg.sender` is the current owner or an authorized428 /// operator for this RFT. Throws if `from` is not the current owner. Throws429 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.430 /// Throws if RFT pieces have multiple owners.431 /// @param from The current owner of the NFT432 /// @param to The new owner433 /// @param tokenId The NFT to transfer434 #[weight(<SelfWeightOf<T>>::transfer_from_creating_removing())]435 fn transfer_from(436 &mut self,437 caller: caller,438 from: address,439 to: address,440 token_id: uint256,441 ) -> Result<void> {442 let caller = T::CrossAccountId::from_eth(caller);443 let from = T::CrossAccountId::from_eth(from);444 let to = T::CrossAccountId::from_eth(to);445 let token = token_id.try_into()?;446 let budget = self447 .recorder448 .weight_calls_budget(<StructureWeight<T>>::find_parent());449450 let balance = balance(&self, token, &from)?;451 ensure_single_owner(&self, token, balance)?;452453 <Pallet<T>>::transfer_from(self, &caller, &from, &to, token, balance, &budget)454 .map_err(dispatch_to_evm::<T>)?;455456 Ok(())457 }458459 /// @dev Not implemented460 fn approve(&mut self, _caller: caller, _approved: address, _token_id: uint256) -> Result<void> {461 Err("not implemented".into())462 }463464 /// @dev Not implemented465 fn set_approval_for_all(466 &mut self,467 _caller: caller,468 _operator: address,469 _approved: bool,470 ) -> Result<void> {471 // TODO: Not implemetable472 Err("not implemented".into())473 }474475 /// @dev Not implemented476 fn get_approved(&self, _token_id: uint256) -> Result<address> {477 // TODO: Not implemetable478 Err("not implemented".into())479 }480481 /// @dev Not implemented482 fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {483 // TODO: Not implemetable484 Err("not implemented".into())485 }486487 /// @notice Returns collection helper contract address488 fn collection_helper_address(&self) -> Result<address> {489 Ok(T::ContractAddress::get())490 }491}492493/// Returns amount of pieces of `token` that `owner` have494pub fn balance<T: Config>(495 collection: &RefungibleHandle<T>,496 token: TokenId,497 owner: &T::CrossAccountId,498) -> Result<u128> {499 collection.consume_store_reads(1)?;500 let balance = <Balance<T>>::get((collection.id, token, &owner));501 Ok(balance)502}503504/// Throws if `owner_balance` is lower than total amount of `token` pieces505pub fn ensure_single_owner<T: Config>(506 collection: &RefungibleHandle<T>,507 token: TokenId,508 owner_balance: u128,509) -> Result<()> {510 collection.consume_store_reads(1)?;511 let total_supply = <TotalSupply<T>>::get((collection.id, token));512 if total_supply != owner_balance {513 return Err("token has multiple owners".into());514 }515 Ok(())516}517518/// @title ERC721 Token that can be irreversibly burned (destroyed).519#[solidity_interface(name = ERC721Burnable)]520impl<T: Config> RefungibleHandle<T> {521 /// @notice Burns a specific ERC721 token.522 /// @dev Throws unless `msg.sender` is the current RFT owner, or an authorized523 /// operator of the current owner.524 /// @param tokenId The RFT to approve525 #[weight(<SelfWeightOf<T>>::burn_item_fully())]526 fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {527 let caller = T::CrossAccountId::from_eth(caller);528 let token = token_id.try_into()?;529530 let balance = balance(&self, token, &caller)?;531 ensure_single_owner(&self, token, balance)?;532533 <Pallet<T>>::burn(self, &caller, token, balance).map_err(dispatch_to_evm::<T>)?;534 Ok(())535 }536}537538/// @title ERC721 minting logic.539#[solidity_interface(name = ERC721UniqueMintable, events(ERC721UniqueMintableEvents))]540impl<T: Config> RefungibleHandle<T> {541 fn minting_finished(&self) -> Result<bool> {542 Ok(false)543 }544545 /// @notice Function to mint token.546 /// @param to The new owner547 /// @return uint256 The id of the newly minted token548 #[weight(<SelfWeightOf<T>>::create_item())]549 fn mint(&mut self, caller: caller, to: address) -> Result<uint256> {550 let token_id: uint256 = <TokensMinted<T>>::get(self.id)551 .checked_add(1)552 .ok_or("item id overflow")?553 .into();554 self.mint_check_id(caller, to, token_id)?;555 Ok(token_id)556 }557558 /// @notice Function to mint token.559 /// @dev `tokenId` should be obtained with `nextTokenId` method,560 /// unlike standard, you can't specify it manually561 /// @param to The new owner562 /// @param tokenId ID of the minted RFT563 #[solidity(hide, rename_selector = "mint")]564 #[weight(<SelfWeightOf<T>>::create_item())]565 fn mint_check_id(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {566 let caller = T::CrossAccountId::from_eth(caller);567 let to = T::CrossAccountId::from_eth(to);568 let token_id: u32 = token_id.try_into()?;569 let budget = self570 .recorder571 .weight_calls_budget(<StructureWeight<T>>::find_parent());572573 if <TokensMinted<T>>::get(self.id)574 .checked_add(1)575 .ok_or("item id overflow")?576 != token_id577 {578 return Err("item id should be next".into());579 }580581 let users = [(to.clone(), 1)]582 .into_iter()583 .collect::<BTreeMap<_, _>>()584 .try_into()585 .unwrap();586 <Pallet<T>>::create_item(587 self,588 &caller,589 CreateItemData::<T::CrossAccountId> {590 users,591 properties: CollectionPropertiesVec::default(),592 },593 &budget,594 )595 .map_err(dispatch_to_evm::<T>)?;596597 Ok(true)598 }599600 /// @notice Function to mint token with the given tokenUri.601 /// @param to The new owner602 /// @param tokenUri Token URI that would be stored in the NFT properties603 /// @return uint256 The id of the newly minted token604 #[solidity(rename_selector = "mintWithTokenURI")]605 #[weight(<SelfWeightOf<T>>::create_item())]606 fn mint_with_token_uri(607 &mut self,608 caller: caller,609 to: address,610 token_uri: string,611 ) -> Result<uint256> {612 let token_id: uint256 = <TokensMinted<T>>::get(self.id)613 .checked_add(1)614 .ok_or("item id overflow")?615 .into();616 self.mint_with_token_uri_check_id(caller, to, token_id, token_uri)?;617 Ok(token_id)618 }619620 /// @notice Function to mint token with the given tokenUri.621 /// @dev `tokenId` should be obtained with `nextTokenId` method,622 /// unlike standard, you can't specify it manually623 /// @param to The new owner624 /// @param tokenId ID of the minted RFT625 /// @param tokenUri Token URI that would be stored in the RFT properties626 #[solidity(hide, rename_selector = "mintWithTokenURI")]627 #[weight(<SelfWeightOf<T>>::create_item())]628 fn mint_with_token_uri_check_id(629 &mut self,630 caller: caller,631 to: address,632 token_id: uint256,633 token_uri: string,634 ) -> Result<bool> {635 let key = key::url();636 let permission = get_token_permission::<T>(self.id, &key)?;637 if !permission.collection_admin {638 return Err("Operation is not allowed".into());639 }640641 let caller = T::CrossAccountId::from_eth(caller);642 let to = T::CrossAccountId::from_eth(to);643 let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;644 let budget = self645 .recorder646 .weight_calls_budget(<StructureWeight<T>>::find_parent());647648 if <TokensMinted<T>>::get(self.id)649 .checked_add(1)650 .ok_or("item id overflow")?651 != token_id652 {653 return Err("item id should be next".into());654 }655656 let mut properties = CollectionPropertiesVec::default();657 properties658 .try_push(Property {659 key,660 value: token_uri661 .into_bytes()662 .try_into()663 .map_err(|_| "token uri is too long")?,664 })665 .map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;666667 let users = [(to.clone(), 1)]668 .into_iter()669 .collect::<BTreeMap<_, _>>()670 .try_into()671 .unwrap();672 <Pallet<T>>::create_item(673 self,674 &caller,675 CreateItemData::<T::CrossAccountId> { users, properties },676 &budget,677 )678 .map_err(dispatch_to_evm::<T>)?;679 Ok(true)680 }681682 /// @dev Not implemented683 fn finish_minting(&mut self, _caller: caller) -> Result<bool> {684 Err("not implementable".into())685 }686}687688fn get_token_property<T: Config>(689 collection: &CollectionHandle<T>,690 token_id: u32,691 key: &up_data_structs::PropertyKey,692) -> Result<string> {693 collection.consume_store_reads(1)?;694 let properties = <TokenProperties<T>>::try_get((collection.id, token_id))695 .map_err(|_| Error::Revert("Token properties not found".into()))?;696 if let Some(property) = properties.get(key) {697 return Ok(string::from_utf8_lossy(property).into());698 }699700 Err("Property tokenURI not found".into())701}702703fn get_token_permission<T: Config>(704 collection_id: CollectionId,705 key: &PropertyKey,706) -> Result<PropertyPermission> {707 let token_property_permissions = CollectionPropertyPermissions::<T>::try_get(collection_id)708 .map_err(|_| Error::Revert("No permissions for collection".into()))?;709 let a = token_property_permissions710 .get(key)711 .map(Clone::clone)712 .ok_or_else(|| {713 let key = string::from_utf8(key.clone().into_inner()).unwrap_or_default();714 Error::Revert(alloc::format!("No permission for key {}", key))715 })?;716 Ok(a)717}718719/// @title Unique extensions for ERC721.720#[solidity_interface(name = ERC721UniqueExtensions)]721impl<T: Config> RefungibleHandle<T>722where723 T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,724{725 /// @notice A descriptive name for a collection of NFTs in this contract726 fn name(&self) -> Result<string> {727 Ok(decode_utf16(self.name.iter().copied())728 .map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))729 .collect::<string>())730 }731732 /// @notice An abbreviated name for NFTs in this contract733 fn symbol(&self) -> Result<string> {734 Ok(string::from_utf8_lossy(&self.token_prefix).into())735 }736737 /// @notice A description for the collection.738 fn description(&self) -> Result<string> {739 Ok(decode_utf16(self.description.iter().copied())740 .map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))741 .collect::<string>())742 }743744 /// Returns the owner (in cross format) of the token.745 ///746 /// @param tokenId Id for the token.747 fn cross_owner_of(&self, token_id: uint256) -> Result<EthCrossAccount> {748 Self::token_owner(&self, token_id.try_into()?)749 .map(|o| EthCrossAccount::from_sub_cross_account::<T>(&o))750 .ok_or(Error::Revert("key too large".into()))751 }752753 /// Returns the token properties.754 ///755 /// @param tokenId Id for the token.756 /// @param keys Properties keys. Empty keys for all propertyes.757 /// @return Vector of properties key/value pairs.758 fn properties(&self, token_id: uint256, keys: Vec<string>) -> Result<Vec<PropertyStruct>> {759 let keys = keys760 .into_iter()761 .map(|key| {762 <Vec<u8>>::from(key)763 .try_into()764 .map_err(|_| Error::Revert("key too large".into()))765 })766 .collect::<Result<Vec<_>>>()?;767768 <Self as CommonCollectionOperations<T>>::token_properties(769 &self,770 token_id.try_into()?,771 if keys.is_empty() { None } else { Some(keys) },772 )773 .into_iter()774 .map(|p| {775 let key = string::from_utf8(p.key.to_vec())776 .map_err(|e| Error::Revert(alloc::format!("{}", e)))?;777 let value = bytes(p.value.to_vec());778 Ok(PropertyStruct { key, value })779 })780 .collect::<Result<Vec<_>>>()781 }782 /// @notice Transfer ownership of an RFT783 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`784 /// is the zero address. Throws if `tokenId` is not a valid RFT.785 /// Throws if RFT pieces have multiple owners.786 /// @param to The new owner787 /// @param tokenId The RFT to transfer788 #[weight(<SelfWeightOf<T>>::transfer_creating_removing())]789 fn transfer(&mut self, caller: caller, to: address, token_id: uint256) -> Result<void> {790 let caller = T::CrossAccountId::from_eth(caller);791 let to = T::CrossAccountId::from_eth(to);792 let token = token_id.try_into()?;793 let budget = self794 .recorder795 .weight_calls_budget(<StructureWeight<T>>::find_parent());796797 let balance = balance(self, token, &caller)?;798 ensure_single_owner(self, token, balance)?;799800 <Pallet<T>>::transfer(self, &caller, &to, token, balance, &budget)801 .map_err(dispatch_to_evm::<T>)?;802 Ok(())803 }804805 /// @notice Transfer ownership of an RFT806 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`807 /// is the zero address. Throws if `tokenId` is not a valid RFT.808 /// Throws if RFT pieces have multiple owners.809 /// @param to The new owner810 /// @param tokenId The RFT to transfer811 #[weight(<SelfWeightOf<T>>::transfer_creating_removing())]812 fn transfer_cross(813 &mut self,814 caller: caller,815 to: EthCrossAccount,816 token_id: uint256,817 ) -> Result<void> {818 let caller = T::CrossAccountId::from_eth(caller);819 let to = to.into_sub_cross_account::<T>()?;820 let token = token_id.try_into()?;821 let budget = self822 .recorder823 .weight_calls_budget(<StructureWeight<T>>::find_parent());824825 let balance = balance(self, token, &caller)?;826 ensure_single_owner(self, token, balance)?;827828 <Pallet<T>>::transfer(self, &caller, &to, token, balance, &budget)829 .map_err(dispatch_to_evm::<T>)?;830 Ok(())831 }832833 /// @notice Transfer ownership of an RFT834 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`835 /// is the zero address. Throws if `tokenId` is not a valid RFT.836 /// Throws if RFT pieces have multiple owners.837 /// @param to The new owner838 /// @param tokenId The RFT to transfer839 #[weight(<SelfWeightOf<T>>::transfer_creating_removing())]840 fn transfer_from_cross(841 &mut self,842 caller: caller,843 from: EthCrossAccount,844 to: EthCrossAccount,845 token_id: uint256,846 ) -> Result<void> {847 let caller = T::CrossAccountId::from_eth(caller);848 let from = from.into_sub_cross_account::<T>()?;849 let to = to.into_sub_cross_account::<T>()?;850 let token_id = token_id.try_into()?;851 let budget = self852 .recorder853 .weight_calls_budget(<StructureWeight<T>>::find_parent());854855 let balance = balance(self, token_id, &from)?;856 ensure_single_owner(self, token_id, balance)?;857858 Pallet::<T>::transfer_from(self, &caller, &from, &to, token_id, balance, &budget)859 .map_err(dispatch_to_evm::<T>)?;860 Ok(())861 }862863 /// @notice Burns a specific ERC721 token.864 /// @dev Throws unless `msg.sender` is the current owner or an authorized865 /// operator for this RFT. Throws if `from` is not the current owner. Throws866 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.867 /// Throws if RFT pieces have multiple owners.868 /// @param from The current owner of the RFT869 /// @param tokenId The RFT to transfer870 #[solidity(hide)]871 #[weight(<SelfWeightOf<T>>::burn_from())]872 fn burn_from(&mut self, caller: caller, from: address, token_id: uint256) -> Result<void> {873 let caller = T::CrossAccountId::from_eth(caller);874 let from = T::CrossAccountId::from_eth(from);875 let token = token_id.try_into()?;876 let budget = self877 .recorder878 .weight_calls_budget(<StructureWeight<T>>::find_parent());879880 let balance = balance(self, token, &from)?;881 ensure_single_owner(self, token, balance)?;882883 <Pallet<T>>::burn_from(self, &caller, &from, token, balance, &budget)884 .map_err(dispatch_to_evm::<T>)?;885 Ok(())886 }887888 /// @notice Burns a specific ERC721 token.889 /// @dev Throws unless `msg.sender` is the current owner or an authorized890 /// operator for this RFT. Throws if `from` is not the current owner. Throws891 /// if `to` is the zero address. Throws if `tokenId` is not a valid RFT.892 /// Throws if RFT pieces have multiple owners.893 /// @param from The current owner of the RFT894 /// @param tokenId The RFT to transfer895 #[weight(<SelfWeightOf<T>>::burn_from())]896 fn burn_from_cross(897 &mut self,898 caller: caller,899 from: EthCrossAccount,900 token_id: uint256,901 ) -> Result<void> {902 let caller = T::CrossAccountId::from_eth(caller);903 let from = from.into_sub_cross_account::<T>()?;904 let token = token_id.try_into()?;905 let budget = self906 .recorder907 .weight_calls_budget(<StructureWeight<T>>::find_parent());908909 let balance = balance(self, token, &from)?;910 ensure_single_owner(self, token, balance)?;911912 <Pallet<T>>::burn_from(self, &caller, &from, token, balance, &budget)913 .map_err(dispatch_to_evm::<T>)?;914 Ok(())915 }916917 /// @notice Returns next free RFT ID.918 fn next_token_id(&self) -> Result<uint256> {919 self.consume_store_reads(1)?;920 Ok(<TokensMinted<T>>::get(self.id)921 .checked_add(1)922 .ok_or("item id overflow")?923 .into())924 }925926 /// @notice Function to mint multiple tokens.927 /// @dev `tokenIds` should be an array of consecutive numbers and first number928 /// should be obtained with `nextTokenId` method929 /// @param to The new owner930 /// @param tokenIds IDs of the minted RFTs931 #[solidity(hide)]932 #[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]933 fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {934 let caller = T::CrossAccountId::from_eth(caller);935 let to = T::CrossAccountId::from_eth(to);936 let mut expected_index = <TokensMinted<T>>::get(self.id)937 .checked_add(1)938 .ok_or("item id overflow")?;939 let budget = self940 .recorder941 .weight_calls_budget(<StructureWeight<T>>::find_parent());942943 let total_tokens = token_ids.len();944 for id in token_ids.into_iter() {945 let id: u32 = id.try_into().map_err(|_| "token id overflow")?;946 if id != expected_index {947 return Err("item id should be next".into());948 }949 expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;950 }951 let users = [(to.clone(), 1)]952 .into_iter()953 .collect::<BTreeMap<_, _>>()954 .try_into()955 .unwrap();956 let create_item_data = CreateItemData::<T::CrossAccountId> {957 users,958 properties: CollectionPropertiesVec::default(),959 };960 let data = (0..total_tokens)961 .map(|_| create_item_data.clone())962 .collect();963964 <Pallet<T>>::create_multiple_items(self, &caller, data, &budget)965 .map_err(dispatch_to_evm::<T>)?;966 Ok(true)967 }968969 /// @notice Function to mint multiple tokens with the given tokenUris.970 /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive971 /// numbers and first number should be obtained with `nextTokenId` method972 /// @param to The new owner973 /// @param tokens array of pairs of token ID and token URI for minted tokens974 #[solidity(hide, rename_selector = "mintBulkWithTokenURI")]975 #[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]976 fn mint_bulk_with_token_uri(977 &mut self,978 caller: caller,979 to: address,980 tokens: Vec<(uint256, string)>,981 ) -> Result<bool> {982 let key = key::url();983 let caller = T::CrossAccountId::from_eth(caller);984 let to = T::CrossAccountId::from_eth(to);985 let mut expected_index = <TokensMinted<T>>::get(self.id)986 .checked_add(1)987 .ok_or("item id overflow")?;988 let budget = self989 .recorder990 .weight_calls_budget(<StructureWeight<T>>::find_parent());991992 let mut data = Vec::with_capacity(tokens.len());993 let users: BoundedBTreeMap<_, _, _> = [(to.clone(), 1)]994 .into_iter()995 .collect::<BTreeMap<_, _>>()996 .try_into()997 .unwrap();998 for (id, token_uri) in tokens {999 let id: u32 = id.try_into().map_err(|_| "token id overflow")?;1000 if id != expected_index {1001 return Err("item id should be next".into());1002 }1003 expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;10041005 let mut properties = CollectionPropertiesVec::default();1006 properties1007 .try_push(Property {1008 key: key.clone(),1009 value: token_uri1010 .into_bytes()1011 .try_into()1012 .map_err(|_| "token uri is too long")?,1013 })1014 .map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?;10151016 let create_item_data = CreateItemData::<T::CrossAccountId> {1017 users: users.clone(),1018 properties,1019 };1020 data.push(create_item_data);1021 }10221023 <Pallet<T>>::create_multiple_items(self, &caller, data, &budget)1024 .map_err(dispatch_to_evm::<T>)?;1025 Ok(true)1026 }10271028 /// Returns EVM address for refungible token1029 ///1030 /// @param token ID of the token1031 fn token_contract_address(&self, token: uint256) -> Result<address> {1032 Ok(T::EvmTokenAddressMapping::token_to_address(1033 self.id,1034 token.try_into().map_err(|_| "token id overflow")?,1035 ))1036 }1037}10381039#[solidity_interface(1040 name = UniqueRefungible,1041 is(1042 ERC721,1043 ERC721Enumerable,1044 ERC721UniqueExtensions,1045 ERC721UniqueMintable,1046 ERC721Burnable,1047 ERC721Metadata(if(this.flags.erc721metadata)),1048 Collection(via(common_mut returns CollectionHandle<T>)),1049 TokenProperties,1050 )1051)]1052impl<T: Config> RefungibleHandle<T> where T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]> {}10531054// Not a tests, but code generators1055generate_stubgen!(gen_impl, UniqueRefungibleCall<()>, true);1056generate_stubgen!(gen_iface, UniqueRefungibleCall<()>, false);10571058impl<T: Config> CommonEvmHandler for RefungibleHandle<T>1059where1060 T::AccountId: From<[u8; 32]> + AsRef<[u8; 32]>,1061{1062 const CODE: &'static [u8] = include_bytes!("./stubs/UniqueRefungible.raw");1063 fn call(1064 self,1065 handle: &mut impl PrecompileHandle,1066 ) -> Option<pallet_common::erc::PrecompileResult> {1067 call::<T, UniqueRefungibleCall<T>, _, _>(handle, self)1068 }1069}