difftreelog
feat set/get tokenPropertyPermissions for NFT
in: master
7 files changed
pallets/common/src/eth.rsdiffbeforeafterboth--- a/pallets/common/src/eth.rs
+++ b/pallets/common/src/eth.rs
@@ -162,3 +162,12 @@
CollectionAdmin,
TokenOwner,
}
+
+#[derive(AbiCoder, Copy, Clone, Default, Debug)]
+#[repr(u8)]
+pub enum EthTokenPermissions {
+ #[default]
+ Mutable,
+ TokenOwner,
+ CollectionAdmin,
+}
pallets/nonfungible/src/erc.rsdiffbeforeafterboth--- a/pallets/nonfungible/src/erc.rs
+++ b/pallets/nonfungible/src/erc.rs
@@ -38,7 +38,7 @@
use pallet_common::{
CollectionHandle, CollectionPropertyPermissions, CommonCollectionOperations,
erc::{CommonEvmHandler, PrecompileResult, CollectionCall, static_property::key},
- eth::EthCrossAccount,
+ eth::{EthCrossAccount, EthTokenPermissions},
};
use pallet_evm::{account::CrossAccountId, PrecompileHandle};
use pallet_evm_coder_substrate::call;
@@ -60,6 +60,7 @@
/// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.
/// @param tokenOwner Permission to mutate property by token owner if property is mutable.
#[weight(<SelfWeightOf<T>>::set_token_property_permissions(1))]
+ #[solidity(hide)]
fn set_token_property_permission(
&mut self,
caller: caller,
@@ -69,10 +70,10 @@
token_owner: bool,
) -> Result<()> {
let caller = T::CrossAccountId::from_eth(caller);
- <Pallet<T>>::set_property_permission(
+ <Pallet<T>>::set_property_permissions(
self,
&caller,
- PropertyKeyPermission {
+ [PropertyKeyPermission {
key: <Vec<u8>>::from(key)
.try_into()
.map_err(|_| "too long key")?,
@@ -81,11 +82,81 @@
collection_admin,
token_owner,
},
- },
+ }]
+ .into(),
)
.map_err(dispatch_to_evm::<T>)
}
+ /// @notice Set permissions for token property.
+ /// @dev Throws error if `msg.sender` is not admin or owner of the collection.
+ /// @param permissions Permissions for keys.
+ fn set_token_property_permissions(
+ &mut self,
+ caller: caller,
+ permissions: Vec<(string, Vec<(EthTokenPermissions, bool)>)>,
+ ) -> Result<()> {
+ let caller = T::CrossAccountId::from_eth(caller);
+ const PERMISSIONS_FIELDS_COUNT: usize = 3;
+
+ let mut perms = <Vec<_>>::new();
+
+ for (key, pp) in permissions {
+ if pp.len() > PERMISSIONS_FIELDS_COUNT {
+ return Err(alloc::format!(
+ "Actual number of fields {} for {}, which exceeds the maximum value of {}",
+ pp.len(),
+ stringify!(EthTokenPermissions),
+ PERMISSIONS_FIELDS_COUNT
+ )
+ .as_str()
+ .into());
+ }
+
+ let mut token_permission = PropertyPermission {
+ mutable: false,
+ collection_admin: false,
+ token_owner: false,
+ };
+
+ for (perm, value) in pp {
+ match perm {
+ EthTokenPermissions::Mutable => token_permission.mutable = value,
+ EthTokenPermissions::TokenOwner => token_permission.token_owner = value,
+ EthTokenPermissions::CollectionAdmin => {
+ token_permission.collection_admin = value
+ }
+ }
+ }
+
+ perms.push(PropertyKeyPermission {
+ key: <Vec<u8>>::from(key)
+ .try_into()
+ .map_err(|_| "too long key")?,
+ permission: token_permission,
+ });
+ }
+
+ <Pallet<T>>::set_property_permissions(self, &caller, perms).map_err(dispatch_to_evm::<T>)
+ }
+
+ fn token_property_permissions(
+ &self,
+ ) -> Result<Vec<(string, Vec<(EthTokenPermissions, bool)>)>> {
+ let mut res = <Vec<_>>::new();
+ for (key, pp) in <Pallet<T>>::token_property_permission(self.id) {
+ let key = string::from_utf8(key.into_inner()).unwrap();
+ let pp = [
+ (EthTokenPermissions::Mutable, pp.mutable),
+ (EthTokenPermissions::TokenOwner, pp.token_owner),
+ (EthTokenPermissions::CollectionAdmin, pp.collection_admin),
+ ]
+ .into();
+ res.push((key, pp));
+ }
+ Ok(res)
+ }
+
/// @notice Set token property value.
/// @dev Throws error if `msg.sender` has no permission to edit the property.
/// @param tokenId ID of the token.
pallets/nonfungible/src/lib.rsdiffbeforeafterboth--- a/pallets/nonfungible/src/lib.rs
+++ b/pallets/nonfungible/src/lib.rs
@@ -103,7 +103,7 @@
AccessMode, CollectionId, CollectionFlags, CustomDataLimit, TokenId, CreateCollectionData,
CreateNftExData, mapping::TokenAddressMapping, budget::Budget, Property, PropertyPermission,
PropertyKey, PropertyValue, PropertyKeyPermission, Properties, PropertyScope, TrySetProperty,
- TokenChild, AuxPropertyValue,
+ TokenChild, AuxPropertyValue, PropertiesPermissionMap,
};
use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm};
use pallet_common::{
@@ -827,12 +827,16 @@
/// Set property permissions for the collection.
///
/// Sender should be the owner or admin of the collection.
- pub fn set_property_permission(
+ pub fn set_property_permissions(
collection: &CollectionHandle<T>,
sender: &T::CrossAccountId,
- permission: PropertyKeyPermission,
+ permission: Vec<PropertyKeyPermission>,
) -> DispatchResult {
- <PalletCommon<T>>::set_property_permission(collection, sender, permission)
+ <PalletCommon<T>>::set_token_property_permissions(collection, sender, permission)
+ }
+
+ pub fn token_property_permission(collection_id: CollectionId) -> PropertiesPermissionMap {
+ <PalletCommon<T>>::property_permissions(collection_id)
}
pub fn check_token_immediate_ownership(
pallets/nonfungible/src/stubs/UniqueNFT.soldiffbeforeafterboth1// SPDX-License-Identifier: OTHER2// This code is automatically generated34pragma solidity >=0.8.0 <0.9.0;56/// @dev common stubs holder7contract Dummy {8 uint8 dummy;9 string stub_error = "this contract is implemented in native";10}1112contract ERC165 is Dummy {13 function supportsInterface(bytes4 interfaceID) external view returns (bool) {14 require(false, stub_error);15 interfaceID;16 return true;17 }18}1920/// @title A contract that allows to set and delete token properties and change token property permissions.21/// @dev the ERC-165 identifier for this interface is 0x91a97a6822contract TokenProperties is Dummy, ERC165 {23 /// @notice Set permissions for token property.24 /// @dev Throws error if `msg.sender` is not admin or owner of the collection.25 /// @param key Property key.26 /// @param isMutable Permission to mutate property.27 /// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.28 /// @param tokenOwner Permission to mutate property by token owner if property is mutable.29 /// @dev EVM selector for this function is: 0x222d97fa,30 /// or in textual repr: setTokenPropertyPermission(string,bool,bool,bool)31 function setTokenPropertyPermission(32 string memory key,33 bool isMutable,34 bool collectionAdmin,35 bool tokenOwner36 ) public {37 require(false, stub_error);38 key;39 isMutable;40 collectionAdmin;41 tokenOwner;42 dummy = 0;43 }4445 // /// @notice Set token property value.46 // /// @dev Throws error if `msg.sender` has no permission to edit the property.47 // /// @param tokenId ID of the token.48 // /// @param key Property key.49 // /// @param value Property value.50 // /// @dev EVM selector for this function is: 0x1752d67b,51 // /// or in textual repr: setProperty(uint256,string,bytes)52 // function setProperty(uint256 tokenId, string memory key, bytes memory value) public {53 // require(false, stub_error);54 // tokenId;55 // key;56 // value;57 // dummy = 0;58 // }5960 /// @notice Set token properties value.61 /// @dev Throws error if `msg.sender` has no permission to edit the property.62 /// @param tokenId ID of the token.63 /// @param properties settable properties64 /// @dev EVM selector for this function is: 0x14ed3a6e,65 /// or in textual repr: setProperties(uint256,(string,bytes)[])66 function setProperties(uint256 tokenId, Property[] memory properties) public {67 require(false, stub_error);68 tokenId;69 properties;70 dummy = 0;71 }7273 // /// @notice Delete token property value.74 // /// @dev Throws error if `msg.sender` has no permission to edit the property.75 // /// @param tokenId ID of the token.76 // /// @param key Property key.77 // /// @dev EVM selector for this function is: 0x066111d1,78 // /// or in textual repr: deleteProperty(uint256,string)79 // function deleteProperty(uint256 tokenId, string memory key) public {80 // require(false, stub_error);81 // tokenId;82 // key;83 // dummy = 0;84 // }8586 /// @notice Delete token properties value.87 /// @dev Throws error if `msg.sender` has no permission to edit the property.88 /// @param tokenId ID of the token.89 /// @param keys Properties key.90 /// @dev EVM selector for this function is: 0xc472d371,91 /// or in textual repr: deleteProperties(uint256,string[])92 function deleteProperties(uint256 tokenId, string[] memory keys) public {93 require(false, stub_error);94 tokenId;95 keys;96 dummy = 0;97 }9899 /// @notice Get token property value.100 /// @dev Throws error if key not found101 /// @param tokenId ID of the token.102 /// @param key Property key.103 /// @return Property value bytes104 /// @dev EVM selector for this function is: 0x7228c327,105 /// or in textual repr: property(uint256,string)106 function property(uint256 tokenId, string memory key) public view returns (bytes memory) {107 require(false, stub_error);108 tokenId;109 key;110 dummy;111 return hex"";112 }113}114115/// @dev Property struct116struct Property {117 string key;118 bytes value;119}120121/// @title A contract that allows you to work with collections.122/// @dev the ERC-165 identifier for this interface is 0xb5e1747f123contract Collection is Dummy, ERC165 {124 // /// Set collection property.125 // ///126 // /// @param key Property key.127 // /// @param value Propery value.128 // /// @dev EVM selector for this function is: 0x2f073f66,129 // /// or in textual repr: setCollectionProperty(string,bytes)130 // function setCollectionProperty(string memory key, bytes memory value) public {131 // require(false, stub_error);132 // key;133 // value;134 // dummy = 0;135 // }136137 /// Set collection properties.138 ///139 /// @param properties Vector of properties key/value pair.140 /// @dev EVM selector for this function is: 0x50b26b2a,141 /// or in textual repr: setCollectionProperties((string,bytes)[])142 function setCollectionProperties(Property[] memory properties) public {143 require(false, stub_error);144 properties;145 dummy = 0;146 }147148 // /// Delete collection property.149 // ///150 // /// @param key Property key.151 // /// @dev EVM selector for this function is: 0x7b7debce,152 // /// or in textual repr: deleteCollectionProperty(string)153 // function deleteCollectionProperty(string memory key) public {154 // require(false, stub_error);155 // key;156 // dummy = 0;157 // }158159 /// Delete collection properties.160 ///161 /// @param keys Properties keys.162 /// @dev EVM selector for this function is: 0xee206ee3,163 /// or in textual repr: deleteCollectionProperties(string[])164 function deleteCollectionProperties(string[] memory keys) public {165 require(false, stub_error);166 keys;167 dummy = 0;168 }169170 /// Get collection property.171 ///172 /// @dev Throws error if key not found.173 ///174 /// @param key Property key.175 /// @return bytes The property corresponding to the key.176 /// @dev EVM selector for this function is: 0xcf24fd6d,177 /// or in textual repr: collectionProperty(string)178 function collectionProperty(string memory key) public view returns (bytes memory) {179 require(false, stub_error);180 key;181 dummy;182 return hex"";183 }184185 /// Get collection properties.186 ///187 /// @param keys Properties keys. Empty keys for all propertyes.188 /// @return Vector of properties key/value pairs.189 /// @dev EVM selector for this function is: 0x285fb8e6,190 /// or in textual repr: collectionProperties(string[])191 function collectionProperties(string[] memory keys) public view returns (Property[] memory) {192 require(false, stub_error);193 keys;194 dummy;195 return new Property[](0);196 }197198 // /// Set the sponsor of the collection.199 // ///200 // /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.201 // ///202 // /// @param sponsor Address of the sponsor from whose account funds will be debited for operations with the contract.203 // /// @dev EVM selector for this function is: 0x7623402e,204 // /// or in textual repr: setCollectionSponsor(address)205 // function setCollectionSponsor(address sponsor) public {206 // require(false, stub_error);207 // sponsor;208 // dummy = 0;209 // }210211 /// Set the sponsor of the collection.212 ///213 /// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.214 ///215 /// @param sponsor Cross account address of the sponsor from whose account funds will be debited for operations with the contract.216 /// @dev EVM selector for this function is: 0x84a1d5a8,217 /// or in textual repr: setCollectionSponsorCross((address,uint256))218 function setCollectionSponsorCross(EthCrossAccount memory sponsor) public {219 require(false, stub_error);220 sponsor;221 dummy = 0;222 }223224 /// Whether there is a pending sponsor.225 /// @dev EVM selector for this function is: 0x058ac185,226 /// or in textual repr: hasCollectionPendingSponsor()227 function hasCollectionPendingSponsor() public view returns (bool) {228 require(false, stub_error);229 dummy;230 return false;231 }232233 /// Collection sponsorship confirmation.234 ///235 /// @dev After setting the sponsor for the collection, it must be confirmed with this function.236 /// @dev EVM selector for this function is: 0x3c50e97a,237 /// or in textual repr: confirmCollectionSponsorship()238 function confirmCollectionSponsorship() public {239 require(false, stub_error);240 dummy = 0;241 }242243 /// Remove collection sponsor.244 /// @dev EVM selector for this function is: 0x6e0326a3,245 /// or in textual repr: removeCollectionSponsor()246 function removeCollectionSponsor() public {247 require(false, stub_error);248 dummy = 0;249 }250251 /// Get current sponsor.252 ///253 /// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.254 /// @dev EVM selector for this function is: 0x6ec0a9f1,255 /// or in textual repr: collectionSponsor()256 function collectionSponsor() public view returns (Tuple30 memory) {257 require(false, stub_error);258 dummy;259 return Tuple30(0x0000000000000000000000000000000000000000, 0);260 }261262 /// Set limits for the collection.263 /// @dev Throws error if limit not found.264 /// @param limit Name of the limit. Valid names:265 /// "accountTokenOwnershipLimit",266 /// "sponsoredDataSize",267 /// "sponsoredDataRateLimit",268 /// "tokenLimit",269 /// "sponsorTransferTimeout",270 /// "sponsorApproveTimeout"271 /// "ownerCanTransfer",272 /// "ownerCanDestroy",273 /// "transfersEnabled"274 /// @param value Value of the limit.275 /// @dev EVM selector for this function is: 0x4ad890a8,276 /// or in textual repr: setCollectionLimit(string,uint256)277 function setCollectionLimit(string memory limit, uint256 value) public {278 require(false, stub_error);279 limit;280 value;281 dummy = 0;282 }283284 /// Get contract address.285 /// @dev EVM selector for this function is: 0xf6b4dfb4,286 /// or in textual repr: contractAddress()287 function contractAddress() public view returns (address) {288 require(false, stub_error);289 dummy;290 return 0x0000000000000000000000000000000000000000;291 }292293 /// Add collection admin.294 /// @param newAdmin Cross account administrator address.295 /// @dev EVM selector for this function is: 0x859aa7d6,296 /// or in textual repr: addCollectionAdminCross((address,uint256))297 function addCollectionAdminCross(EthCrossAccount memory newAdmin) public {298 require(false, stub_error);299 newAdmin;300 dummy = 0;301 }302303 /// Remove collection admin.304 /// @param admin Cross account administrator address.305 /// @dev EVM selector for this function is: 0x6c0cd173,306 /// or in textual repr: removeCollectionAdminCross((address,uint256))307 function removeCollectionAdminCross(EthCrossAccount memory admin) public {308 require(false, stub_error);309 admin;310 dummy = 0;311 }312313 // /// Add collection admin.314 // /// @param newAdmin Address of the added administrator.315 // /// @dev EVM selector for this function is: 0x92e462c7,316 // /// or in textual repr: addCollectionAdmin(address)317 // function addCollectionAdmin(address newAdmin) public {318 // require(false, stub_error);319 // newAdmin;320 // dummy = 0;321 // }322323 // /// Remove collection admin.324 // ///325 // /// @param admin Address of the removed administrator.326 // /// @dev EVM selector for this function is: 0xfafd7b42,327 // /// or in textual repr: removeCollectionAdmin(address)328 // function removeCollectionAdmin(address admin) public {329 // require(false, stub_error);330 // admin;331 // dummy = 0;332 // }333334 /// Toggle accessibility of collection nesting.335 ///336 /// @param enable If "true" degenerates to nesting: 'Owner' else to nesting: 'Disabled'337 /// @dev EVM selector for this function is: 0x112d4586,338 /// or in textual repr: setCollectionNesting(bool)339 function setCollectionNesting(bool enable) public {340 require(false, stub_error);341 enable;342 dummy = 0;343 }344345 /// Toggle accessibility of collection nesting.346 ///347 /// @param enable If "true" degenerates to nesting: {OwnerRestricted: [1, 2, 3]} else to nesting: 'Disabled'348 /// @param collections Addresses of collections that will be available for nesting.349 /// @dev EVM selector for this function is: 0x64872396,350 /// or in textual repr: setCollectionNesting(bool,address[])351 function setCollectionNesting(bool enable, address[] memory collections) public {352 require(false, stub_error);353 enable;354 collections;355 dummy = 0;356 }357358 /// Returns nesting for a collection359 /// @dev EVM selector for this function is: 0x22d25bfe,360 /// or in textual repr: collectionNestingRestrictedCollectionIds()361 function collectionNestingRestrictedCollectionIds() public view returns (Tuple34 memory) {362 require(false, stub_error);363 dummy;364 return Tuple34(false, new uint256[](0));365 }366367 /// Returns permissions for a collection368 /// @dev EVM selector for this function is: 0x5b2eaf4b,369 /// or in textual repr: collectionNestingPermissions()370 function collectionNestingPermissions() public view returns (Tuple37[] memory) {371 require(false, stub_error);372 dummy;373 return new Tuple37[](0);374 }375376 /// Set the collection access method.377 /// @param mode Access mode378 /// 0 for Normal379 /// 1 for AllowList380 /// @dev EVM selector for this function is: 0x41835d4c,381 /// or in textual repr: setCollectionAccess(uint8)382 function setCollectionAccess(uint8 mode) public {383 require(false, stub_error);384 mode;385 dummy = 0;386 }387388 /// Checks that user allowed to operate with collection.389 ///390 /// @param user User address to check.391 /// @dev EVM selector for this function is: 0x91b6df49,392 /// or in textual repr: allowlistedCross((address,uint256))393 function allowlistedCross(EthCrossAccount memory user) public view returns (bool) {394 require(false, stub_error);395 user;396 dummy;397 return false;398 }399400 // /// Add the user to the allowed list.401 // ///402 // /// @param user Address of a trusted user.403 // /// @dev EVM selector for this function is: 0x67844fe6,404 // /// or in textual repr: addToCollectionAllowList(address)405 // function addToCollectionAllowList(address user) public {406 // require(false, stub_error);407 // user;408 // dummy = 0;409 // }410411 /// Add user to allowed list.412 ///413 /// @param user User cross account address.414 /// @dev EVM selector for this function is: 0xa0184a3a,415 /// or in textual repr: addToCollectionAllowListCross((address,uint256))416 function addToCollectionAllowListCross(EthCrossAccount memory user) public {417 require(false, stub_error);418 user;419 dummy = 0;420 }421422 // /// Remove the user from the allowed list.423 // ///424 // /// @param user Address of a removed user.425 // /// @dev EVM selector for this function is: 0x85c51acb,426 // /// or in textual repr: removeFromCollectionAllowList(address)427 // function removeFromCollectionAllowList(address user) public {428 // require(false, stub_error);429 // user;430 // dummy = 0;431 // }432433 /// Remove user from allowed list.434 ///435 /// @param user User cross account address.436 /// @dev EVM selector for this function is: 0x09ba452a,437 /// or in textual repr: removeFromCollectionAllowListCross((address,uint256))438 function removeFromCollectionAllowListCross(EthCrossAccount memory user) public {439 require(false, stub_error);440 user;441 dummy = 0;442 }443444 /// Switch permission for minting.445 ///446 /// @param mode Enable if "true".447 /// @dev EVM selector for this function is: 0x00018e84,448 /// or in textual repr: setCollectionMintMode(bool)449 function setCollectionMintMode(bool mode) public {450 require(false, stub_error);451 mode;452 dummy = 0;453 }454455 // /// Check that account is the owner or admin of the collection456 // ///457 // /// @param user account to verify458 // /// @return "true" if account is the owner or admin459 // /// @dev EVM selector for this function is: 0x9811b0c7,460 // /// or in textual repr: isOwnerOrAdmin(address)461 // function isOwnerOrAdmin(address user) public view returns (bool) {462 // require(false, stub_error);463 // user;464 // dummy;465 // return false;466 // }467468 /// Check that account is the owner or admin of the collection469 ///470 /// @param user User cross account to verify471 /// @return "true" if account is the owner or admin472 /// @dev EVM selector for this function is: 0x3e75a905,473 /// or in textual repr: isOwnerOrAdminCross((address,uint256))474 function isOwnerOrAdminCross(EthCrossAccount memory user) public view returns (bool) {475 require(false, stub_error);476 user;477 dummy;478 return false;479 }480481 /// Returns collection type482 ///483 /// @return `Fungible` or `NFT` or `ReFungible`484 /// @dev EVM selector for this function is: 0xd34b55b8,485 /// or in textual repr: uniqueCollectionType()486 function uniqueCollectionType() public view returns (string memory) {487 require(false, stub_error);488 dummy;489 return "";490 }491492 /// Get collection owner.493 ///494 /// @return Tuble with sponsor address and his substrate mirror.495 /// If address is canonical then substrate mirror is zero and vice versa.496 /// @dev EVM selector for this function is: 0xdf727d3b,497 /// or in textual repr: collectionOwner()498 function collectionOwner() public view returns (EthCrossAccount memory) {499 require(false, stub_error);500 dummy;501 return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);502 }503504 // /// Changes collection owner to another account505 // ///506 // /// @dev Owner can be changed only by current owner507 // /// @param newOwner new owner account508 // /// @dev EVM selector for this function is: 0x4f53e226,509 // /// or in textual repr: changeCollectionOwner(address)510 // function changeCollectionOwner(address newOwner) public {511 // require(false, stub_error);512 // newOwner;513 // dummy = 0;514 // }515516 /// Get collection administrators517 ///518 /// @return Vector of tuples with admins address and his substrate mirror.519 /// If address is canonical then substrate mirror is zero and vice versa.520 /// @dev EVM selector for this function is: 0x5813216b,521 /// or in textual repr: collectionAdmins()522 function collectionAdmins() public view returns (EthCrossAccount[] memory) {523 require(false, stub_error);524 dummy;525 return new EthCrossAccount[](0);526 }527528 /// Changes collection owner to another account529 ///530 /// @dev Owner can be changed only by current owner531 /// @param newOwner new owner cross account532 /// @dev EVM selector for this function is: 0x6496c497,533 /// or in textual repr: changeCollectionOwnerCross((address,uint256))534 function changeCollectionOwnerCross(EthCrossAccount memory newOwner) public {535 require(false, stub_error);536 newOwner;537 dummy = 0;538 }539}540541/// @dev Cross account struct542struct EthCrossAccount {543 address eth;544 uint256 sub;545}546547enum CollectionPermissions {548 CollectionAdmin,549 TokenOwner550}551552/// @dev anonymous struct553struct Tuple37 {554 CollectionPermissions field_0;555 bool field_1;556}557558/// @dev anonymous struct559struct Tuple34 {560 bool field_0;561 uint256[] field_1;562}563564/// @dev anonymous struct565struct Tuple30 {566 address field_0;567 uint256 field_1;568}569570/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension571/// @dev See https://eips.ethereum.org/EIPS/eip-721572/// @dev the ERC-165 identifier for this interface is 0x5b5e139f573contract ERC721Metadata is Dummy, ERC165 {574 // /// @notice A descriptive name for a collection of NFTs in this contract575 // /// @dev real implementation of this function lies in `ERC721UniqueExtensions`576 // /// @dev EVM selector for this function is: 0x06fdde03,577 // /// or in textual repr: name()578 // function name() public view returns (string memory) {579 // require(false, stub_error);580 // dummy;581 // return "";582 // }583584 // /// @notice An abbreviated name for NFTs in this contract585 // /// @dev real implementation of this function lies in `ERC721UniqueExtensions`586 // /// @dev EVM selector for this function is: 0x95d89b41,587 // /// or in textual repr: symbol()588 // function symbol() public view returns (string memory) {589 // require(false, stub_error);590 // dummy;591 // return "";592 // }593594 /// @notice A distinct Uniform Resource Identifier (URI) for a given asset.595 ///596 /// @dev If the token has a `url` property and it is not empty, it is returned.597 /// 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`.598 /// If the collection property `baseURI` is empty or absent, return "" (empty string)599 /// otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix600 /// otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings).601 ///602 /// @return token's const_metadata603 /// @dev EVM selector for this function is: 0xc87b56dd,604 /// or in textual repr: tokenURI(uint256)605 function tokenURI(uint256 tokenId) public view returns (string memory) {606 require(false, stub_error);607 tokenId;608 dummy;609 return "";610 }611}612613/// @title ERC721 Token that can be irreversibly burned (destroyed).614/// @dev the ERC-165 identifier for this interface is 0x42966c68615contract ERC721Burnable is Dummy, ERC165 {616 /// @notice Burns a specific ERC721 token.617 /// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized618 /// operator of the current owner.619 /// @param tokenId The NFT to approve620 /// @dev EVM selector for this function is: 0x42966c68,621 /// or in textual repr: burn(uint256)622 function burn(uint256 tokenId) public {623 require(false, stub_error);624 tokenId;625 dummy = 0;626 }627}628629/// @dev inlined interface630contract ERC721UniqueMintableEvents {631 event MintingFinished();632}633634/// @title ERC721 minting logic.635/// @dev the ERC-165 identifier for this interface is 0x476ff149636contract ERC721UniqueMintable is Dummy, ERC165, ERC721UniqueMintableEvents {637 /// @dev EVM selector for this function is: 0x05d2035b,638 /// or in textual repr: mintingFinished()639 function mintingFinished() public view returns (bool) {640 require(false, stub_error);641 dummy;642 return false;643 }644645 /// @notice Function to mint token.646 /// @param to The new owner647 /// @return uint256 The id of the newly minted token648 /// @dev EVM selector for this function is: 0x6a627842,649 /// or in textual repr: mint(address)650 function mint(address to) public returns (uint256) {651 require(false, stub_error);652 to;653 dummy = 0;654 return 0;655 }656657 // /// @notice Function to mint token.658 // /// @dev `tokenId` should be obtained with `nextTokenId` method,659 // /// unlike standard, you can't specify it manually660 // /// @param to The new owner661 // /// @param tokenId ID of the minted NFT662 // /// @dev EVM selector for this function is: 0x40c10f19,663 // /// or in textual repr: mint(address,uint256)664 // function mint(address to, uint256 tokenId) public returns (bool) {665 // require(false, stub_error);666 // to;667 // tokenId;668 // dummy = 0;669 // return false;670 // }671672 /// @notice Function to mint token with the given tokenUri.673 /// @param to The new owner674 /// @param tokenUri Token URI that would be stored in the NFT properties675 /// @return uint256 The id of the newly minted token676 /// @dev EVM selector for this function is: 0x45c17782,677 /// or in textual repr: mintWithTokenURI(address,string)678 function mintWithTokenURI(address to, string memory tokenUri) public returns (uint256) {679 require(false, stub_error);680 to;681 tokenUri;682 dummy = 0;683 return 0;684 }685686 // /// @notice Function to mint token with the given tokenUri.687 // /// @dev `tokenId` should be obtained with `nextTokenId` method,688 // /// unlike standard, you can't specify it manually689 // /// @param to The new owner690 // /// @param tokenId ID of the minted NFT691 // /// @param tokenUri Token URI that would be stored in the NFT properties692 // /// @dev EVM selector for this function is: 0x50bb4e7f,693 // /// or in textual repr: mintWithTokenURI(address,uint256,string)694 // function mintWithTokenURI(address to, uint256 tokenId, string memory tokenUri) public returns (bool) {695 // require(false, stub_error);696 // to;697 // tokenId;698 // tokenUri;699 // dummy = 0;700 // return false;701 // }702703 /// @dev Not implemented704 /// @dev EVM selector for this function is: 0x7d64bcb4,705 /// or in textual repr: finishMinting()706 function finishMinting() public returns (bool) {707 require(false, stub_error);708 dummy = 0;709 return false;710 }711}712713/// @title Unique extensions for ERC721.714/// @dev the ERC-165 identifier for this interface is 0xb74c26b7715contract ERC721UniqueExtensions is Dummy, ERC165 {716 /// @notice A descriptive name for a collection of NFTs in this contract717 /// @dev EVM selector for this function is: 0x06fdde03,718 /// or in textual repr: name()719 function name() public view returns (string memory) {720 require(false, stub_error);721 dummy;722 return "";723 }724725 /// @notice An abbreviated name for NFTs in this contract726 /// @dev EVM selector for this function is: 0x95d89b41,727 /// or in textual repr: symbol()728 function symbol() public view returns (string memory) {729 require(false, stub_error);730 dummy;731 return "";732 }733734 /// @notice A description for the collection.735 /// @dev EVM selector for this function is: 0x7284e416,736 /// or in textual repr: description()737 function description() public view returns (string memory) {738 require(false, stub_error);739 dummy;740 return "";741 }742743 /// Returns the owner (in cross format) of the token.744 ///745 /// @param tokenId Id for the token.746 /// @dev EVM selector for this function is: 0x2b29dace,747 /// or in textual repr: crossOwnerOf(uint256)748 function crossOwnerOf(uint256 tokenId) public view returns (EthCrossAccount memory) {749 require(false, stub_error);750 tokenId;751 dummy;752 return EthCrossAccount(0x0000000000000000000000000000000000000000, 0);753 }754755 /// Returns the token properties.756 ///757 /// @param tokenId Id for the token.758 /// @param keys Properties keys. Empty keys for all propertyes.759 /// @return Vector of properties key/value pairs.760 /// @dev EVM selector for this function is: 0xe07ede7e,761 /// or in textual repr: properties(uint256,string[])762 function properties(uint256 tokenId, string[] memory keys) public view returns (Property[] memory) {763 require(false, stub_error);764 tokenId;765 keys;766 dummy;767 return new Property[](0);768 }769770 /// @notice Set or reaffirm the approved address for an NFT771 /// @dev The zero address indicates there is no approved address.772 /// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized773 /// operator of the current owner.774 /// @param approved The new substrate address approved NFT controller775 /// @param tokenId The NFT to approve776 /// @dev EVM selector for this function is: 0x0ecd0ab0,777 /// or in textual repr: approveCross((address,uint256),uint256)778 function approveCross(EthCrossAccount memory approved, uint256 tokenId) public {779 require(false, stub_error);780 approved;781 tokenId;782 dummy = 0;783 }784785 /// @notice Transfer ownership of an NFT786 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`787 /// is the zero address. Throws if `tokenId` is not a valid NFT.788 /// @param to The new owner789 /// @param tokenId The NFT to transfer790 /// @dev EVM selector for this function is: 0xa9059cbb,791 /// or in textual repr: transfer(address,uint256)792 function transfer(address to, uint256 tokenId) public {793 require(false, stub_error);794 to;795 tokenId;796 dummy = 0;797 }798799 /// @notice Transfer ownership of an NFT800 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`801 /// is the zero address. Throws if `tokenId` is not a valid NFT.802 /// @param to The new owner803 /// @param tokenId The NFT to transfer804 /// @dev EVM selector for this function is: 0x2ada85ff,805 /// or in textual repr: transferCross((address,uint256),uint256)806 function transferCross(EthCrossAccount memory to, uint256 tokenId) public {807 require(false, stub_error);808 to;809 tokenId;810 dummy = 0;811 }812813 /// @notice Transfer ownership of an NFT from cross account address to cross account address814 /// @dev Throws unless `msg.sender` is the current owner. Throws if `to`815 /// is the zero address. Throws if `tokenId` is not a valid NFT.816 /// @param from Cross acccount address of current owner817 /// @param to Cross acccount address of new owner818 /// @param tokenId The NFT to transfer819 /// @dev EVM selector for this function is: 0xd5cf430b,820 /// or in textual repr: transferFromCross((address,uint256),(address,uint256),uint256)821 function transferFromCross(822 EthCrossAccount memory from,823 EthCrossAccount memory to,824 uint256 tokenId825 ) public {826 require(false, stub_error);827 from;828 to;829 tokenId;830 dummy = 0;831 }832833 // /// @notice Burns a specific ERC721 token.834 // /// @dev Throws unless `msg.sender` is the current owner or an authorized835 // /// operator for this NFT. Throws if `from` is not the current owner. Throws836 // /// if `to` is the zero address. Throws if `tokenId` is not a valid NFT.837 // /// @param from The current owner of the NFT838 // /// @param tokenId The NFT to transfer839 // /// @dev EVM selector for this function is: 0x79cc6790,840 // /// or in textual repr: burnFrom(address,uint256)841 // function burnFrom(address from, uint256 tokenId) public {842 // require(false, stub_error);843 // from;844 // tokenId;845 // dummy = 0;846 // }847848 /// @notice Burns a specific ERC721 token.849 /// @dev Throws unless `msg.sender` is the current owner or an authorized850 /// operator for this NFT. Throws if `from` is not the current owner. Throws851 /// if `to` is the zero address. Throws if `tokenId` is not a valid NFT.852 /// @param from The current owner of the NFT853 /// @param tokenId The NFT to transfer854 /// @dev EVM selector for this function is: 0xbb2f5a58,855 /// or in textual repr: burnFromCross((address,uint256),uint256)856 function burnFromCross(EthCrossAccount memory from, uint256 tokenId) public {857 require(false, stub_error);858 from;859 tokenId;860 dummy = 0;861 }862863 /// @notice Returns next free NFT ID.864 /// @dev EVM selector for this function is: 0x75794a3c,865 /// or in textual repr: nextTokenId()866 function nextTokenId() public view returns (uint256) {867 require(false, stub_error);868 dummy;869 return 0;870 }871 // /// @notice Function to mint multiple tokens.872 // /// @dev `tokenIds` should be an array of consecutive numbers and first number873 // /// should be obtained with `nextTokenId` method874 // /// @param to The new owner875 // /// @param tokenIds IDs of the minted NFTs876 // /// @dev EVM selector for this function is: 0x44a9945e,877 // /// or in textual repr: mintBulk(address,uint256[])878 // function mintBulk(address to, uint256[] memory tokenIds) public returns (bool) {879 // require(false, stub_error);880 // to;881 // tokenIds;882 // dummy = 0;883 // return false;884 // }885886 // /// @notice Function to mint multiple tokens with the given tokenUris.887 // /// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive888 // /// numbers and first number should be obtained with `nextTokenId` method889 // /// @param to The new owner890 // /// @param tokens array of pairs of token ID and token URI for minted tokens891 // /// @dev EVM selector for this function is: 0x36543006,892 // /// or in textual repr: mintBulkWithTokenURI(address,(uint256,string)[])893 // function mintBulkWithTokenURI(address to, Tuple15[] memory tokens) public returns (bool) {894 // require(false, stub_error);895 // to;896 // tokens;897 // dummy = 0;898 // return false;899 // }900901}902903/// @dev anonymous struct904struct Tuple15 {905 uint256 field_0;906 string field_1;907}908909/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension910/// @dev See https://eips.ethereum.org/EIPS/eip-721911/// @dev the ERC-165 identifier for this interface is 0x780e9d63912contract ERC721Enumerable is Dummy, ERC165 {913 /// @notice Enumerate valid NFTs914 /// @param index A counter less than `totalSupply()`915 /// @return The token identifier for the `index`th NFT,916 /// (sort order not specified)917 /// @dev EVM selector for this function is: 0x4f6ccce7,918 /// or in textual repr: tokenByIndex(uint256)919 function tokenByIndex(uint256 index) public view returns (uint256) {920 require(false, stub_error);921 index;922 dummy;923 return 0;924 }925926 /// @dev Not implemented927 /// @dev EVM selector for this function is: 0x2f745c59,928 /// or in textual repr: tokenOfOwnerByIndex(address,uint256)929 function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {930 require(false, stub_error);931 owner;932 index;933 dummy;934 return 0;935 }936937 /// @notice Count NFTs tracked by this contract938 /// @return A count of valid NFTs tracked by this contract, where each one of939 /// them has an assigned and queryable owner not equal to the zero address940 /// @dev EVM selector for this function is: 0x18160ddd,941 /// or in textual repr: totalSupply()942 function totalSupply() public view returns (uint256) {943 require(false, stub_error);944 dummy;945 return 0;946 }947}948949/// @dev inlined interface950contract ERC721Events {951 event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);952 event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);953 event ApprovalForAll(address indexed owner, address indexed operator, bool approved);954}955956/// @title ERC-721 Non-Fungible Token Standard957/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md958/// @dev the ERC-165 identifier for this interface is 0x983a942b959contract ERC721 is Dummy, ERC165, ERC721Events {960 /// @notice Count all NFTs assigned to an owner961 /// @dev NFTs assigned to the zero address are considered invalid, and this962 /// function throws for queries about the zero address.963 /// @param owner An address for whom to query the balance964 /// @return The number of NFTs owned by `owner`, possibly zero965 /// @dev EVM selector for this function is: 0x70a08231,966 /// or in textual repr: balanceOf(address)967 function balanceOf(address owner) public view returns (uint256) {968 require(false, stub_error);969 owner;970 dummy;971 return 0;972 }973974 /// @notice Find the owner of an NFT975 /// @dev NFTs assigned to zero address are considered invalid, and queries976 /// about them do throw.977 /// @param tokenId The identifier for an NFT978 /// @return The address of the owner of the NFT979 /// @dev EVM selector for this function is: 0x6352211e,980 /// or in textual repr: ownerOf(uint256)981 function ownerOf(uint256 tokenId) public view returns (address) {982 require(false, stub_error);983 tokenId;984 dummy;985 return 0x0000000000000000000000000000000000000000;986 }987988 /// @dev Not implemented989 /// @dev EVM selector for this function is: 0xb88d4fde,990 /// or in textual repr: safeTransferFrom(address,address,uint256,bytes)991 function safeTransferFrom(992 address from,993 address to,994 uint256 tokenId,995 bytes memory data996 ) public {997 require(false, stub_error);998 from;999 to;1000 tokenId;1001 data;1002 dummy = 0;1003 }10041005 /// @dev Not implemented1006 /// @dev EVM selector for this function is: 0x42842e0e,1007 /// or in textual repr: safeTransferFrom(address,address,uint256)1008 function safeTransferFrom(1009 address from,1010 address to,1011 uint256 tokenId1012 ) public {1013 require(false, stub_error);1014 from;1015 to;1016 tokenId;1017 dummy = 0;1018 }10191020 /// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE1021 /// TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE1022 /// THEY MAY BE PERMANENTLY LOST1023 /// @dev Throws unless `msg.sender` is the current owner or an authorized1024 /// operator for this NFT. Throws if `from` is not the current owner. Throws1025 /// if `to` is the zero address. Throws if `tokenId` is not a valid NFT.1026 /// @param from The current owner of the NFT1027 /// @param to The new owner1028 /// @param tokenId The NFT to transfer1029 /// @dev EVM selector for this function is: 0x23b872dd,1030 /// or in textual repr: transferFrom(address,address,uint256)1031 function transferFrom(1032 address from,1033 address to,1034 uint256 tokenId1035 ) public {1036 require(false, stub_error);1037 from;1038 to;1039 tokenId;1040 dummy = 0;1041 }10421043 /// @notice Set or reaffirm the approved address for an NFT1044 /// @dev The zero address indicates there is no approved address.1045 /// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized1046 /// operator of the current owner.1047 /// @param approved The new approved NFT controller1048 /// @param tokenId The NFT to approve1049 /// @dev EVM selector for this function is: 0x095ea7b3,1050 /// or in textual repr: approve(address,uint256)1051 function approve(address approved, uint256 tokenId) public {1052 require(false, stub_error);1053 approved;1054 tokenId;1055 dummy = 0;1056 }10571058 /// @notice Sets or unsets the approval of a given operator.1059 /// The `operator` is allowed to transfer all tokens of the `caller` on their behalf.1060 /// @param operator Operator1061 /// @param approved Should operator status be granted or revoked?1062 /// @dev EVM selector for this function is: 0xa22cb465,1063 /// or in textual repr: setApprovalForAll(address,bool)1064 function setApprovalForAll(address operator, bool approved) public {1065 require(false, stub_error);1066 operator;1067 approved;1068 dummy = 0;1069 }10701071 /// @dev Not implemented1072 /// @dev EVM selector for this function is: 0x081812fc,1073 /// or in textual repr: getApproved(uint256)1074 function getApproved(uint256 tokenId) public view returns (address) {1075 require(false, stub_error);1076 tokenId;1077 dummy;1078 return 0x0000000000000000000000000000000000000000;1079 }10801081 /// @notice Tells whether the given `owner` approves the `operator`.1082 /// @dev EVM selector for this function is: 0xe985e9c5,1083 /// or in textual repr: isApprovedForAll(address,address)1084 function isApprovedForAll(address owner, address operator) public view returns (bool) {1085 require(false, stub_error);1086 owner;1087 operator;1088 dummy;1089 return false;1090 }10911092 /// @notice Returns collection helper contract address1093 /// @dev EVM selector for this function is: 0x1896cce6,1094 /// or in textual repr: collectionHelperAddress()1095 function collectionHelperAddress() public view returns (address) {1096 require(false, stub_error);1097 dummy;1098 return 0x0000000000000000000000000000000000000000;1099 }1100}11011102contract UniqueNFT is1103 Dummy,1104 ERC165,1105 ERC721,1106 ERC721Enumerable,1107 ERC721UniqueExtensions,1108 ERC721UniqueMintable,1109 ERC721Burnable,1110 ERC721Metadata,1111 Collection,1112 TokenProperties1113{}tests/src/eth/abi/nonFungible.jsondiffbeforeafterboth--- a/tests/src/eth/abi/nonFungible.json
+++ b/tests/src/eth/abi/nonFungible.json
@@ -697,12 +697,29 @@
},
{
"inputs": [
- { "internalType": "string", "name": "key", "type": "string" },
- { "internalType": "bool", "name": "isMutable", "type": "bool" },
- { "internalType": "bool", "name": "collectionAdmin", "type": "bool" },
- { "internalType": "bool", "name": "tokenOwner", "type": "bool" }
+ {
+ "components": [
+ { "internalType": "string", "name": "field_0", "type": "string" },
+ {
+ "components": [
+ {
+ "internalType": "enum EthTokenPermissions",
+ "name": "field_0",
+ "type": "uint8"
+ },
+ { "internalType": "bool", "name": "field_1", "type": "bool" }
+ ],
+ "internalType": "struct Tuple46[]",
+ "name": "field_1",
+ "type": "tuple[]"
+ }
+ ],
+ "internalType": "struct Tuple48[]",
+ "name": "permissions",
+ "type": "tuple[]"
+ }
],
- "name": "setTokenPropertyPermission",
+ "name": "setTokenPropertyPermissions",
"outputs": [],
"stateMutability": "nonpayable",
"type": "function"
@@ -743,6 +760,35 @@
"type": "function"
},
{
+ "inputs": [],
+ "name": "tokenPropertyPermissions",
+ "outputs": [
+ {
+ "components": [
+ { "internalType": "string", "name": "field_0", "type": "string" },
+ {
+ "components": [
+ {
+ "internalType": "enum EthTokenPermissions",
+ "name": "field_0",
+ "type": "uint8"
+ },
+ { "internalType": "bool", "name": "field_1", "type": "bool" }
+ ],
+ "internalType": "struct Tuple46[]",
+ "name": "field_1",
+ "type": "tuple[]"
+ }
+ ],
+ "internalType": "struct Tuple48[]",
+ "name": "",
+ "type": "tuple[]"
+ }
+ ],
+ "stateMutability": "view",
+ "type": "function"
+ },
+ {
"inputs": [
{ "internalType": "uint256", "name": "tokenId", "type": "uint256" }
],
tests/src/eth/api/UniqueNFT.soldiffbeforeafterboth--- a/tests/src/eth/api/UniqueNFT.sol
+++ b/tests/src/eth/api/UniqueNFT.sol
@@ -13,22 +13,28 @@
}
/// @title A contract that allows to set and delete token properties and change token property permissions.
-/// @dev the ERC-165 identifier for this interface is 0x91a97a68
+/// @dev the ERC-165 identifier for this interface is 0xde0695c2
interface TokenProperties is Dummy, ERC165 {
+ // /// @notice Set permissions for token property.
+ // /// @dev Throws error if `msg.sender` is not admin or owner of the collection.
+ // /// @param key Property key.
+ // /// @param isMutable Permission to mutate property.
+ // /// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.
+ // /// @param tokenOwner Permission to mutate property by token owner if property is mutable.
+ // /// @dev EVM selector for this function is: 0x222d97fa,
+ // /// or in textual repr: setTokenPropertyPermission(string,bool,bool,bool)
+ // function setTokenPropertyPermission(string memory key, bool isMutable, bool collectionAdmin, bool tokenOwner) external;
+
/// @notice Set permissions for token property.
/// @dev Throws error if `msg.sender` is not admin or owner of the collection.
- /// @param key Property key.
- /// @param isMutable Permission to mutate property.
- /// @param collectionAdmin Permission to mutate property by collection admin if property is mutable.
- /// @param tokenOwner Permission to mutate property by token owner if property is mutable.
- /// @dev EVM selector for this function is: 0x222d97fa,
- /// or in textual repr: setTokenPropertyPermission(string,bool,bool,bool)
- function setTokenPropertyPermission(
- string memory key,
- bool isMutable,
- bool collectionAdmin,
- bool tokenOwner
- ) external;
+ /// @param permissions Permissions for keys.
+ /// @dev EVM selector for this function is: 0xbd92983a,
+ /// or in textual repr: setTokenPropertyPermissions((string,(uint8,bool)[])[])
+ function setTokenPropertyPermissions(Tuple43[] memory permissions) external;
+
+ /// @dev EVM selector for this function is: 0xf23d7790,
+ /// or in textual repr: tokenPropertyPermissions()
+ function tokenPropertyPermissions() external view returns (Tuple43[] memory);
// /// @notice Set token property value.
// /// @dev Throws error if `msg.sender` has no permission to edit the property.
@@ -79,6 +85,24 @@
bytes value;
}
+enum EthTokenPermissions {
+ Mutable,
+ TokenOwner,
+ CollectionAdmin
+}
+
+/// @dev anonymous struct
+struct Tuple43 {
+ string field_0;
+ Tuple41[] field_1;
+}
+
+/// @dev anonymous struct
+struct Tuple41 {
+ EthTokenPermissions field_0;
+ bool field_1;
+}
+
/// @title A contract that allows you to work with collections.
/// @dev the ERC-165 identifier for this interface is 0xb5e1747f
interface Collection is Dummy, ERC165 {
tests/src/eth/tokenProperties.test.tsdiffbeforeafterboth--- a/tests/src/eth/tokenProperties.test.ts
+++ b/tests/src/eth/tokenProperties.test.ts
@@ -32,7 +32,7 @@
});
});
- itEth('Can be reconfigured', async({helper}) => {
+ itEth.only('Can be reconfigured', async({helper}) => {
const caller = await helper.eth.createAccountWithBalance(donor);
for(const [mutable,collectionAdmin, tokenOwner] of cartesian([], [false, true], [false, true], [false, true])) {
const collection = await helper.nft.mintCollection(alice);
@@ -41,12 +41,16 @@
const address = helper.ethAddress.fromCollectionId(collection.collectionId);
const contract = helper.ethNativeContract.collection(address, 'nft', caller);
- await contract.methods.setTokenPropertyPermission('testKey', mutable, collectionAdmin, tokenOwner).send({from: caller});
+ await contract.methods.setTokenPropertyPermissions([['testKey', [[0, mutable], [1, tokenOwner], [2, collectionAdmin]]]]).send({from: caller});
expect(await collection.getPropertyPermissions()).to.be.deep.equal([{
key: 'testKey',
permission: {mutable, collectionAdmin, tokenOwner},
}]);
+
+ expect(await contract.methods.tokenPropertyPermissions().call({from: caller})).to.be.like([
+ ['testKey', [['0', mutable], ['1', tokenOwner], ['2', collectionAdmin]]]
+ ]);
}
});