From 749341e77d246a000d85bb6b8ad74785b9d6cfc6 Mon Sep 17 00:00:00 2001 From: Grigoriy Simonov Date: Mon, 25 Jul 2022 07:54:39 +0000 Subject: [PATCH] feat(refungible-pallet): ERC-721 EVM API --- --- a/Makefile +++ b/Makefile @@ -15,8 +15,9 @@ NONFUNGIBLE_EVM_STUBS=./pallets/nonfungible/src/stubs NONFUNGIBLE_EVM_ABI=./tests/src/eth/nonFungibleAbi.json -RENFUNGIBLE_EVM_ABI=./tests/src/eth/reFungibleAbi.json -RENFUNGIBLE_TOKEN_EVM_ABI=./tests/src/eth/reFungibleTokenAbi.json +REFUNGIBLE_EVM_STUBS=./pallets/refungible/src/stubs +REFUNGIBLE_EVM_ABI=./tests/src/eth/reFungibleAbi.json +REFUNGIBLE_TOKEN_EVM_ABI=./tests/src/eth/reFungibleTokenAbi.json CONTRACT_HELPERS_STUBS=./pallets/evm-contract-helpers/src/stubs/ CONTRACT_HELPERS_ABI=./tests/src/eth/util/contractHelpersAbi.json @@ -36,6 +37,10 @@ UniqueNFT.sol: PACKAGE=pallet-nonfungible NAME=erc::gen_iface OUTPUT=$(TESTS_API)/$@ ./.maintain/scripts/generate_sol.sh PACKAGE=pallet-nonfungible NAME=erc::gen_impl OUTPUT=$(NONFUNGIBLE_EVM_STUBS)/$@ ./.maintain/scripts/generate_sol.sh + +UniqueRefungible.sol: + PACKAGE=pallet-refungible NAME=erc::gen_iface OUTPUT=$(TESTS_API)/$@ ./.maintain/scripts/generate_sol.sh + PACKAGE=pallet-refungible NAME=erc::gen_impl OUTPUT=$(REFUNGIBLE_EVM_STUBS)/$@ ./.maintain/scripts/generate_sol.sh UniqueRefungible.sol: PACKAGE=pallet-refungible NAME=erc::gen_iface OUTPUT=$(TESTS_API)/$@ ./.maintain/scripts/generate_sol.sh @@ -61,9 +66,13 @@ INPUT=$(NONFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(NONFUNGIBLE_EVM_STUBS)/UniqueNFT.raw ./.maintain/scripts/compile_stub.sh INPUT=$(NONFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(NONFUNGIBLE_EVM_ABI) ./.maintain/scripts/generate_abi.sh +UniqueRefungible: UniqueRefungible.sol + INPUT=$(REFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(REFUNGIBLE_EVM_STUBS)/UniqueRefungible.raw ./.maintain/scripts/compile_stub.sh + INPUT=$(REFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(REFUNGIBLE_EVM_ABI) ./.maintain/scripts/generate_abi.sh + UniqueRefungibleToken: UniqueRefungibleToken.sol INPUT=$(REFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(REFUNGIBLE_EVM_STUBS)/UniqueRefungibleToken.raw ./.maintain/scripts/compile_stub.sh - INPUT=$(REFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(RENFUNGIBLE_TOKEN_EVM_ABI) ./.maintain/scripts/generate_abi.sh + INPUT=$(REFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(REFUNGIBLE_TOKEN_EVM_ABI) ./.maintain/scripts/generate_abi.sh UniqueRefungible: UniqueRefungible.sol INPUT=$(REFUNGIBLE_EVM_STUBS)/$< OUTPUT=$(REFUNGIBLE_EVM_STUBS)/UniqueRefungible.raw ./.maintain/scripts/compile_stub.sh --- a/pallets/refungible/src/erc.rs +++ b/pallets/refungible/src/erc.rs @@ -15,18 +15,607 @@ // along with Unique Network. If not, see . extern crate alloc; -use evm_coder::{generate_stubgen, solidity_interface, types::*}; -use pallet_common::{CollectionHandle, erc::CollectionCall, erc::CommonEvmHandler}; +use alloc::string::ToString; +use core::{ + char::{REPLACEMENT_CHARACTER, decode_utf16}, + convert::TryInto, +}; +use evm_coder::{ToLog, execution::*, generate_stubgen, solidity, solidity_interface, types::*, weight}; +use frame_support::{BoundedBTreeMap, BoundedVec}; +use pallet_common::{ + CollectionHandle, CollectionPropertyPermissions, + erc::{ + CommonEvmHandler, CollectionCall, + static_property::{key, value as property_value}, + }, +}; +use pallet_evm::{account::CrossAccountId, PrecompileHandle}; +use pallet_evm_coder_substrate::{call, dispatch_to_evm}; +use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _}; +use sp_core::H160; +use sp_std::{collections::btree_map::BTreeMap, vec::Vec, vec}; +use up_data_structs::{ + CollectionId, CollectionPropertiesVec, Property, PropertyKey, PropertyKeyPermission, + PropertyPermission, TokenId, +}; + +use crate::{ + AccountBalance, Config, CreateItemData, Pallet, RefungibleHandle, SelfWeightOf, + TokenProperties, TokensMinted, weights::WeightInfo, +}; -use pallet_evm::PrecompileHandle; -use pallet_evm_coder_substrate::call; +#[solidity_interface(name = "TokenProperties")] +impl RefungibleHandle { + fn set_token_property_permission( + &mut self, + caller: caller, + key: string, + is_mutable: bool, + collection_admin: bool, + token_owner: bool, + ) -> Result<()> { + let caller = T::CrossAccountId::from_eth(caller); + >::set_token_property_permissions( + self, + &caller, + vec![PropertyKeyPermission { + key: >::from(key) + .try_into() + .map_err(|_| "too long key")?, + permission: PropertyPermission { + mutable: is_mutable, + collection_admin, + token_owner, + }, + }], + ) + .map_err(dispatch_to_evm::) + } -use crate::{Config, RefungibleHandle}; + fn set_property( + &mut self, + caller: caller, + token_id: uint256, + key: string, + value: bytes, + ) -> Result<()> { + let caller = T::CrossAccountId::from_eth(caller); + let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?; + let key = >::from(key) + .try_into() + .map_err(|_| "key too long")?; + let value = value.try_into().map_err(|_| "value too long")?; + let nesting_budget = self + .recorder + .weight_calls_budget(>::find_parent()); + + >::set_token_property( + self, + &caller, + TokenId(token_id), + Property { key, value }, + &nesting_budget, + ) + .map_err(dispatch_to_evm::) + } + + fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> { + let caller = T::CrossAccountId::from_eth(caller); + let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?; + let key = >::from(key) + .try_into() + .map_err(|_| "key too long")?; + + let nesting_budget = self + .recorder + .weight_calls_budget(>::find_parent()); + + >::delete_token_property(self, &caller, TokenId(token_id), key, &nesting_budget) + .map_err(dispatch_to_evm::) + } + + /// Throws error if key not found + fn property(&self, token_id: uint256, key: string) -> Result { + let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?; + let key = >::from(key) + .try_into() + .map_err(|_| "key too long")?; + + let props = >::get((self.id, token_id)); + let prop = props.get(&key).ok_or("key not found")?; + + Ok(prop.to_vec()) + } +} + +#[derive(ToLog)] +pub enum ERC721Events { + Transfer { + #[indexed] + from: address, + #[indexed] + to: address, + #[indexed] + token_id: uint256, + }, + /// @dev Not supported + Approval { + #[indexed] + owner: address, + #[indexed] + approved: address, + #[indexed] + token_id: uint256, + }, + /// @dev Not supported + #[allow(dead_code)] + ApprovalForAll { + #[indexed] + owner: address, + #[indexed] + operator: address, + approved: bool, + }, +} + +#[derive(ToLog)] +pub enum ERC721MintableEvents { + /// @dev Not supported + #[allow(dead_code)] + MintingFinished {}, +} + +#[solidity_interface(name = "ERC721Metadata")] +impl RefungibleHandle { + fn name(&self) -> Result { + Ok(decode_utf16(self.name.iter().copied()) + .map(|r| r.unwrap_or(REPLACEMENT_CHARACTER)) + .collect::()) + } + + fn symbol(&self) -> Result { + Ok(string::from_utf8_lossy(&self.token_prefix).into()) + } + + /// @notice A distinct Uniform Resource Identifier (URI) for a given asset. + /// + /// @dev If the token has a `url` property and it is not empty, it is returned. + /// 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`. + /// If the collection property `baseURI` is empty or absent, return "" (empty string) + /// otherwise, if token property `suffix` present and is non-empty, return concatenation of baseURI and suffix + /// otherwise, return concatenation of `baseURI` and stringified token id (decimal stringifying, without paddings). + /// + /// @return token's const_metadata + #[solidity(rename_selector = "tokenURI")] + fn token_uri(&self, token_id: uint256) -> Result { + let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?; + + if let Ok(url) = get_token_property(self, token_id_u32, &key::url()) { + if !url.is_empty() { + return Ok(url); + } + } else if !is_erc721_metadata_compatible::(self.id) { + return Err("tokenURI not set".into()); + } + + if let Some(base_uri) = + pallet_common::Pallet::::get_collection_property(self.id, &key::base_uri()) + { + if !base_uri.is_empty() { + let base_uri = string::from_utf8(base_uri.into_inner()).map_err(|e| { + Error::Revert(alloc::format!( + "Can not convert value \"baseURI\" to string with error \"{}\"", + e + )) + })?; + if let Ok(suffix) = get_token_property(self, token_id_u32, &key::suffix()) { + if !suffix.is_empty() { + return Ok(base_uri + suffix.as_str()); + } + } + + return Ok(base_uri + token_id.to_string().as_str()); + } + } + + Ok("".into()) + } +} + +#[solidity_interface(name = "ERC721Enumerable")] +impl RefungibleHandle { + fn token_by_index(&self, index: uint256) -> Result { + Ok(index) + } + + /// Not implemented + fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result { + // TODO: Not implemetable + Err("not implemented".into()) + } + + fn total_supply(&self) -> Result { + self.consume_store_reads(1)?; + Ok(>::total_supply(self).into()) + } +} + +#[solidity_interface(name = "ERC721", events(ERC721Events))] +impl RefungibleHandle { + fn balance_of(&self, owner: address) -> Result { + self.consume_store_reads(1)?; + let owner = T::CrossAccountId::from_eth(owner); + let balance = >::get((self.id, owner)); + Ok(balance.into()) + } + + fn owner_of(&self, token_id: uint256) -> Result
{ + self.consume_store_reads(2)?; + let token = token_id.try_into()?; + let owner = >::token_owner(self.id, token); + Ok(owner + .map(|address| *address.as_eth()) + .unwrap_or_else(|| H160::default())) + } + + /// @dev Not implemented + fn safe_transfer_from_with_data( + &mut self, + _from: address, + _to: address, + _token_id: uint256, + _data: bytes, + _value: value, + ) -> Result { + // TODO: Not implemetable + Err("not implemented".into()) + } + + /// @dev Not implemented + fn safe_transfer_from( + &mut self, + _from: address, + _to: address, + _token_id: uint256, + _value: value, + ) -> Result { + // TODO: Not implemetable + Err("not implemented".into()) + } + + /// @dev Not implemented + fn transfer_from( + &mut self, + _caller: caller, + _from: address, + _to: address, + _token_id: uint256, + _value: value, + ) -> Result { + Err("not implemented".into()) + } + + /// @dev Not implemented + fn approve( + &mut self, + _caller: caller, + _approved: address, + _token_id: uint256, + _value: value, + ) -> Result { + Err("not implemented".into()) + } + + /// @dev Not implemented + fn set_approval_for_all( + &mut self, + _caller: caller, + _operator: address, + _approved: bool, + ) -> Result { + // TODO: Not implemetable + Err("not implemented".into()) + } + + /// @dev Not implemented + fn get_approved(&self, _token_id: uint256) -> Result
{ + // TODO: Not implemetable + Err("not implemented".into()) + } + + /// @dev Not implemented + fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result
{ + // TODO: Not implemetable + Err("not implemented".into()) + } +} + +#[solidity_interface(name = "ERC721Burnable")] +impl RefungibleHandle { + /// @dev Not implemented + fn burn(&mut self, _caller: caller, _token_id: uint256, _value: value) -> Result { + Err("not implemented".into()) + } +} + +#[solidity_interface(name = "ERC721Mintable", events(ERC721MintableEvents))] +impl RefungibleHandle { + fn minting_finished(&self) -> Result { + Ok(false) + } + + /// `token_id` should be obtained with `next_token_id` method, + /// unlike standard, you can't specify it manually + #[weight(>::create_item())] + fn mint(&mut self, caller: caller, to: address, token_id: uint256) -> Result { + let caller = T::CrossAccountId::from_eth(caller); + let to = T::CrossAccountId::from_eth(to); + let token_id: u32 = token_id.try_into()?; + let budget = self + .recorder + .weight_calls_budget(>::find_parent()); + + if >::get(self.id) + .checked_add(1) + .ok_or("item id overflow")? + != token_id + { + return Err("item id should be next".into()); + } + + let const_data = BoundedVec::default(); + let users = [(to.clone(), 1)] + .into_iter() + .collect::>() + .try_into() + .unwrap(); + >::create_item( + self, + &caller, + CreateItemData:: { + const_data, + users, + properties: CollectionPropertiesVec::default(), + }, + &budget, + ) + .map_err(dispatch_to_evm::)?; + + Ok(true) + } + + /// `token_id` should be obtained with `next_token_id` method, + /// unlike standard, you can't specify it manually + #[solidity(rename_selector = "mintWithTokenURI")] + #[weight(>::create_item())] + fn mint_with_token_uri( + &mut self, + caller: caller, + to: address, + token_id: uint256, + token_uri: string, + ) -> Result { + let key = key::url(); + let permission = get_token_permission::(self.id, &key)?; + if !permission.collection_admin { + return Err("Operation is not allowed".into()); + } + + let caller = T::CrossAccountId::from_eth(caller); + let to = T::CrossAccountId::from_eth(to); + let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?; + let budget = self + .recorder + .weight_calls_budget(>::find_parent()); + + if >::get(self.id) + .checked_add(1) + .ok_or("item id overflow")? + != token_id + { + return Err("item id should be next".into()); + } + + let mut properties = CollectionPropertiesVec::default(); + properties + .try_push(Property { + key, + value: token_uri + .into_bytes() + .try_into() + .map_err(|_| "token uri is too long")?, + }) + .map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?; + + let const_data = BoundedVec::default(); + let users = [(to.clone(), 1)] + .into_iter() + .collect::>() + .try_into() + .unwrap(); + >::create_item( + self, + &caller, + CreateItemData:: { + const_data, + users, + properties, + }, + &budget, + ) + .map_err(dispatch_to_evm::)?; + Ok(true) + } + + /// @dev Not implemented + fn finish_minting(&mut self, _caller: caller) -> Result { + Err("not implementable".into()) + } +} + +fn get_token_property( + collection: &CollectionHandle, + token_id: u32, + key: &up_data_structs::PropertyKey, +) -> Result { + collection.consume_store_reads(1)?; + let properties = >::try_get((collection.id, token_id)) + .map_err(|_| Error::Revert("Token properties not found".into()))?; + if let Some(property) = properties.get(key) { + return Ok(string::from_utf8_lossy(property).into()); + } + + Err("Property tokenURI not found".into()) +} + +fn is_erc721_metadata_compatible(collection_id: CollectionId) -> bool { + if let Some(shema_name) = + pallet_common::Pallet::::get_collection_property(collection_id, &key::schema_name()) + { + let shema_name = shema_name.into_inner(); + shema_name == property_value::ERC721_METADATA + } else { + false + } +} + +fn get_token_permission( + collection_id: CollectionId, + key: &PropertyKey, +) -> Result { + let token_property_permissions = CollectionPropertyPermissions::::try_get(collection_id) + .map_err(|_| Error::Revert("No permissions for collection".into()))?; + let a = token_property_permissions + .get(key) + .map(Clone::clone) + .ok_or_else(|| { + let key = string::from_utf8(key.clone().into_inner()).unwrap_or_default(); + Error::Revert(alloc::format!("No permission for key {}", key)) + })?; + Ok(a) +} + +#[solidity_interface(name = "ERC721UniqueExtensions")] +impl RefungibleHandle { + /// @notice Returns next free RFT ID. + fn next_token_id(&self) -> Result { + self.consume_store_reads(1)?; + Ok(>::get(self.id) + .checked_add(1) + .ok_or("item id overflow")? + .into()) + } + + #[weight(>::create_multiple_items(token_ids.len() as u32))] + fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec) -> Result { + let caller = T::CrossAccountId::from_eth(caller); + let to = T::CrossAccountId::from_eth(to); + let mut expected_index = >::get(self.id) + .checked_add(1) + .ok_or("item id overflow")?; + let budget = self + .recorder + .weight_calls_budget(>::find_parent()); + + let total_tokens = token_ids.len(); + for id in token_ids.into_iter() { + let id: u32 = id.try_into().map_err(|_| "token id overflow")?; + if id != expected_index { + return Err("item id should be next".into()); + } + expected_index = expected_index.checked_add(1).ok_or("item id overflow")?; + } + let const_data = BoundedVec::default(); + let users = [(to.clone(), 1)] + .into_iter() + .collect::>() + .try_into() + .unwrap(); + let create_item_data = CreateItemData:: { + const_data, + users, + properties: CollectionPropertiesVec::default(), + }; + let data = (0..total_tokens) + .map(|_| create_item_data.clone()) + .collect(); + + >::create_multiple_items(self, &caller, data, &budget) + .map_err(dispatch_to_evm::)?; + Ok(true) + } + + #[solidity(rename_selector = "mintBulkWithTokenURI")] + #[weight(>::create_multiple_items(tokens.len() as u32))] + fn mint_bulk_with_token_uri( + &mut self, + caller: caller, + to: address, + tokens: Vec<(uint256, string)>, + ) -> Result { + let key = key::url(); + let caller = T::CrossAccountId::from_eth(caller); + let to = T::CrossAccountId::from_eth(to); + let mut expected_index = >::get(self.id) + .checked_add(1) + .ok_or("item id overflow")?; + let budget = self + .recorder + .weight_calls_budget(>::find_parent()); + + let mut data = Vec::with_capacity(tokens.len()); + let const_data = BoundedVec::default(); + let users: BoundedBTreeMap<_, _, _> = [(to.clone(), 1)] + .into_iter() + .collect::>() + .try_into() + .unwrap(); + for (id, token_uri) in tokens { + let id: u32 = id.try_into().map_err(|_| "token id overflow")?; + if id != expected_index { + return Err("item id should be next".into()); + } + expected_index = expected_index.checked_add(1).ok_or("item id overflow")?; + + let mut properties = CollectionPropertiesVec::default(); + properties + .try_push(Property { + key: key.clone(), + value: token_uri + .into_bytes() + .try_into() + .map_err(|_| "token uri is too long")?, + }) + .map_err(|e| Error::Revert(alloc::format!("Can't add property: {:?}", e)))?; + + let create_item_data = CreateItemData:: { + const_data: const_data.clone(), + users: users.clone(), + properties, + }; + data.push(create_item_data); + } + + >::create_multiple_items(self, &caller, data, &budget) + .map_err(dispatch_to_evm::)?; + Ok(true) + } +} + #[solidity_interface( name = "UniqueRefungible", - is(via("CollectionHandle", common_mut, Collection),) + is( + ERC721, + ERC721Metadata, + ERC721Enumerable, + ERC721UniqueExtensions, + ERC721Mintable, + ERC721Burnable, + via("CollectionHandle", common_mut, Collection), + TokenProperties, + ) )] impl RefungibleHandle where T::AccountId: From<[u8; 32]> {} --- a/pallets/refungible/src/lib.rs +++ b/pallets/refungible/src/lib.rs @@ -88,6 +88,7 @@ #![cfg_attr(not(feature = "std"), no_std)] use crate::erc_token::ERC20Events; +use crate::erc::ERC721Events; use codec::{Encode, Decode, MaxEncodedLen}; use core::ops::Deref; @@ -96,7 +97,8 @@ use pallet_evm::{account::CrossAccountId, Pallet as PalletEvm}; use pallet_evm_coder_substrate::WithRecorder; use pallet_common::{ - CommonCollectionOperations, Error as CommonError, Event as CommonEvent, Pallet as PalletCommon, + CommonCollectionOperations, Error as CommonError, Event as CommonEvent, + eth::collection_id_to_address, Pallet as PalletCommon, }; use pallet_structure::Pallet as PalletStructure; use scale_info::TypeInfo; @@ -117,6 +119,9 @@ pub mod erc; pub mod erc_token; pub mod weights; + +pub type CreateItemData = + CreateRefungibleExData<::CrossAccountId>; pub(crate) type SelfWeightOf = ::WeightInfo; /// Token data, stored independently from other data used to describe it @@ -779,6 +784,7 @@ token, )), ); + >::deposit_event(CommonEvent::Transfer( collection.id, token, @@ -797,7 +803,7 @@ pub fn create_multiple_items( collection: &RefungibleHandle, sender: &T::CrossAccountId, - data: Vec>, + data: Vec>, nesting_budget: &dyn Budget, ) -> DispatchResult { if !collection.is_owner_or_admin(sender) { @@ -942,6 +948,14 @@ TokenId(token_id), )), ); + >::deposit_log( + ERC721Events::Transfer { + from: H160::default(), + to: *user.as_eth(), + token_id: token_id.into(), + } + .to_log(collection_id_to_address(collection.id)), + ); >::deposit_event(CommonEvent::ItemCreated( collection.id, TokenId(token_id), @@ -1120,7 +1134,7 @@ pub fn create_item( collection: &RefungibleHandle, sender: &T::CrossAccountId, - data: CreateRefungibleExData, + data: CreateItemData, nesting_budget: &dyn Budget, ) -> DispatchResult { Self::create_multiple_items(collection, sender, vec![data], nesting_budget) --- a/pallets/refungible/src/stubs/UniqueRefungible.sol +++ b/pallets/refungible/src/stubs/UniqueRefungible.sol @@ -3,6 +3,12 @@ pragma solidity >=0.8.0 <0.9.0; +// Anonymous struct +struct Tuple0 { + uint256 field_0; + string field_1; +} + // Common stubs holder contract Dummy { uint8 dummy; @@ -21,6 +27,351 @@ } } +// Inline +contract ERC721Events { + event Transfer( + address indexed from, + address indexed to, + uint256 indexed tokenId + ); + event Approval( + address indexed owner, + address indexed approved, + uint256 indexed tokenId + ); + event ApprovalForAll( + address indexed owner, + address indexed operator, + bool approved + ); +} + +// Inline +contract ERC721MintableEvents { + event MintingFinished(); +} + +// Selector: 0784ee64 +contract ERC721UniqueExtensions is Dummy, ERC165 { + // @notice Returns next free RFT ID. + // + // Selector: nextTokenId() 75794a3c + function nextTokenId() public view returns (uint256) { + require(false, stub_error); + dummy; + return 0; + } + + // Selector: mintBulk(address,uint256[]) 44a9945e + function mintBulk(address to, uint256[] memory tokenIds) + public + returns (bool) + { + require(false, stub_error); + to; + tokenIds; + dummy = 0; + return false; + } + + // Selector: mintBulkWithTokenURI(address,(uint256,string)[]) 36543006 + function mintBulkWithTokenURI(address to, Tuple0[] memory tokens) + public + returns (bool) + { + require(false, stub_error); + to; + tokens; + dummy = 0; + return false; + } +} + +// Selector: 41369377 +contract TokenProperties is Dummy, ERC165 { + // Selector: setTokenPropertyPermission(string,bool,bool,bool) 222d97fa + function setTokenPropertyPermission( + string memory key, + bool isMutable, + bool collectionAdmin, + bool tokenOwner + ) public { + require(false, stub_error); + key; + isMutable; + collectionAdmin; + tokenOwner; + dummy = 0; + } + + // Selector: setProperty(uint256,string,bytes) 1752d67b + function setProperty( + uint256 tokenId, + string memory key, + bytes memory value + ) public { + require(false, stub_error); + tokenId; + key; + value; + dummy = 0; + } + + // Selector: deleteProperty(uint256,string) 066111d1 + function deleteProperty(uint256 tokenId, string memory key) public { + require(false, stub_error); + tokenId; + key; + dummy = 0; + } + + // Throws error if key not found + // + // Selector: property(uint256,string) 7228c327 + function property(uint256 tokenId, string memory key) + public + view + returns (bytes memory) + { + require(false, stub_error); + tokenId; + key; + dummy; + return hex""; + } +} + +// Selector: 42966c68 +contract ERC721Burnable is Dummy, ERC165 { + // @dev Not implemented + // + // Selector: burn(uint256) 42966c68 + function burn(uint256 tokenId) public { + require(false, stub_error); + tokenId; + dummy = 0; + } +} + +// Selector: 58800161 +contract ERC721 is Dummy, ERC165, ERC721Events { + // Selector: balanceOf(address) 70a08231 + function balanceOf(address owner) public view returns (uint256) { + require(false, stub_error); + owner; + dummy; + return 0; + } + + // Selector: ownerOf(uint256) 6352211e + function ownerOf(uint256 tokenId) public view returns (address) { + require(false, stub_error); + tokenId; + dummy; + return 0x0000000000000000000000000000000000000000; + } + + // @dev Not implemented + // + // Selector: safeTransferFromWithData(address,address,uint256,bytes) 60a11672 + function safeTransferFromWithData( + address from, + address to, + uint256 tokenId, + bytes memory data + ) public { + require(false, stub_error); + from; + to; + tokenId; + data; + dummy = 0; + } + + // @dev Not implemented + // + // Selector: safeTransferFrom(address,address,uint256) 42842e0e + function safeTransferFrom( + address from, + address to, + uint256 tokenId + ) public { + require(false, stub_error); + from; + to; + tokenId; + dummy = 0; + } + + // @dev Not implemented + // + // Selector: transferFrom(address,address,uint256) 23b872dd + function transferFrom( + address from, + address to, + uint256 tokenId + ) public { + require(false, stub_error); + from; + to; + tokenId; + dummy = 0; + } + + // @dev Not implemented + // + // Selector: approve(address,uint256) 095ea7b3 + function approve(address approved, uint256 tokenId) public { + require(false, stub_error); + approved; + tokenId; + dummy = 0; + } + + // @dev Not implemented + // + // Selector: setApprovalForAll(address,bool) a22cb465 + function setApprovalForAll(address operator, bool approved) public { + require(false, stub_error); + operator; + approved; + dummy = 0; + } + + // @dev Not implemented + // + // Selector: getApproved(uint256) 081812fc + function getApproved(uint256 tokenId) public view returns (address) { + require(false, stub_error); + tokenId; + dummy; + return 0x0000000000000000000000000000000000000000; + } + + // @dev Not implemented + // + // Selector: isApprovedForAll(address,address) e985e9c5 + function isApprovedForAll(address owner, address operator) + public + view + returns (address) + { + require(false, stub_error); + owner; + operator; + dummy; + return 0x0000000000000000000000000000000000000000; + } +} + +// Selector: 5b5e139f +contract ERC721Metadata is Dummy, ERC165 { + // Selector: name() 06fdde03 + function name() public view returns (string memory) { + require(false, stub_error); + dummy; + return ""; + } + + // Selector: symbol() 95d89b41 + function symbol() public view returns (string memory) { + require(false, stub_error); + dummy; + return ""; + } + + // Returns token's const_metadata + // + // Selector: tokenURI(uint256) c87b56dd + function tokenURI(uint256 tokenId) public view returns (string memory) { + require(false, stub_error); + tokenId; + dummy; + return ""; + } +} + +// Selector: 68ccfe89 +contract ERC721Mintable is Dummy, ERC165, ERC721MintableEvents { + // Selector: mintingFinished() 05d2035b + function mintingFinished() public view returns (bool) { + require(false, stub_error); + dummy; + return false; + } + + // `token_id` should be obtained with `next_token_id` method, + // unlike standard, you can't specify it manually + // + // Selector: mint(address,uint256) 40c10f19 + function mint(address to, uint256 tokenId) public returns (bool) { + require(false, stub_error); + to; + tokenId; + dummy = 0; + return false; + } + + // `token_id` should be obtained with `next_token_id` method, + // unlike standard, you can't specify it manually + // + // Selector: mintWithTokenURI(address,uint256,string) 50bb4e7f + function mintWithTokenURI( + address to, + uint256 tokenId, + string memory tokenUri + ) public returns (bool) { + require(false, stub_error); + to; + tokenId; + tokenUri; + dummy = 0; + return false; + } + + // @dev Not implemented + // + // Selector: finishMinting() 7d64bcb4 + function finishMinting() public returns (bool) { + require(false, stub_error); + dummy = 0; + return false; + } +} + +// Selector: 780e9d63 +contract ERC721Enumerable is Dummy, ERC165 { + // Selector: tokenByIndex(uint256) 4f6ccce7 + function tokenByIndex(uint256 index) public view returns (uint256) { + require(false, stub_error); + index; + dummy; + return 0; + } + + // Not implemented + // + // Selector: tokenOfOwnerByIndex(address,uint256) 2f745c59 + function tokenOfOwnerByIndex(address owner, uint256 index) + public + view + returns (uint256) + { + require(false, stub_error); + owner; + index; + dummy; + return 0; + } + + // Selector: totalSupply() 18160ddd + function totalSupply() public view returns (uint256) { + require(false, stub_error); + dummy; + return 0; + } +} + // Selector: 7d9262e6 contract Collection is Dummy, ERC165 { // Set collection property. @@ -248,4 +599,15 @@ } } -contract UniqueRefungible is Dummy, ERC165, Collection {} +contract UniqueRefungible is + Dummy, + ERC165, + ERC721, + ERC721Metadata, + ERC721Enumerable, + ERC721UniqueExtensions, + ERC721Mintable, + ERC721Burnable, + Collection, + TokenProperties +{} --- a/tests/src/eth/api/UniqueRefungible.sol +++ b/tests/src/eth/api/UniqueRefungible.sol @@ -3,6 +3,12 @@ pragma solidity >=0.8.0 <0.9.0; +// Anonymous struct +struct Tuple0 { + uint256 field_0; + string field_1; +} + // Common stubs holder interface Dummy { @@ -12,6 +18,203 @@ function supportsInterface(bytes4 interfaceID) external view returns (bool); } +// Inline +interface ERC721Events { + event Transfer( + address indexed from, + address indexed to, + uint256 indexed tokenId + ); + event Approval( + address indexed owner, + address indexed approved, + uint256 indexed tokenId + ); + event ApprovalForAll( + address indexed owner, + address indexed operator, + bool approved + ); +} + +// Inline +interface ERC721MintableEvents { + event MintingFinished(); +} + +// Selector: 0784ee64 +interface ERC721UniqueExtensions is Dummy, ERC165 { + // @notice Returns next free RFT ID. + // + // Selector: nextTokenId() 75794a3c + function nextTokenId() external view returns (uint256); + + // Selector: mintBulk(address,uint256[]) 44a9945e + function mintBulk(address to, uint256[] memory tokenIds) + external + returns (bool); + + // Selector: mintBulkWithTokenURI(address,(uint256,string)[]) 36543006 + function mintBulkWithTokenURI(address to, Tuple0[] memory tokens) + external + returns (bool); +} + +// Selector: 41369377 +interface TokenProperties is Dummy, ERC165 { + // Selector: setTokenPropertyPermission(string,bool,bool,bool) 222d97fa + function setTokenPropertyPermission( + string memory key, + bool isMutable, + bool collectionAdmin, + bool tokenOwner + ) external; + + // Selector: setProperty(uint256,string,bytes) 1752d67b + function setProperty( + uint256 tokenId, + string memory key, + bytes memory value + ) external; + + // Selector: deleteProperty(uint256,string) 066111d1 + function deleteProperty(uint256 tokenId, string memory key) external; + + // Throws error if key not found + // + // Selector: property(uint256,string) 7228c327 + function property(uint256 tokenId, string memory key) + external + view + returns (bytes memory); +} + +// Selector: 42966c68 +interface ERC721Burnable is Dummy, ERC165 { + // @dev Not implemented + // + // Selector: burn(uint256) 42966c68 + function burn(uint256 tokenId) external; +} + +// Selector: 58800161 +interface ERC721 is Dummy, ERC165, ERC721Events { + // Selector: balanceOf(address) 70a08231 + function balanceOf(address owner) external view returns (uint256); + + // Selector: ownerOf(uint256) 6352211e + function ownerOf(uint256 tokenId) external view returns (address); + + // @dev Not implemented + // + // Selector: safeTransferFromWithData(address,address,uint256,bytes) 60a11672 + function safeTransferFromWithData( + address from, + address to, + uint256 tokenId, + bytes memory data + ) external; + + // @dev Not implemented + // + // Selector: safeTransferFrom(address,address,uint256) 42842e0e + function safeTransferFrom( + address from, + address to, + uint256 tokenId + ) external; + + // @dev Not implemented + // + // Selector: transferFrom(address,address,uint256) 23b872dd + function transferFrom( + address from, + address to, + uint256 tokenId + ) external; + + // @dev Not implemented + // + // Selector: approve(address,uint256) 095ea7b3 + function approve(address approved, uint256 tokenId) external; + + // @dev Not implemented + // + // Selector: setApprovalForAll(address,bool) a22cb465 + function setApprovalForAll(address operator, bool approved) external; + + // @dev Not implemented + // + // Selector: getApproved(uint256) 081812fc + function getApproved(uint256 tokenId) external view returns (address); + + // @dev Not implemented + // + // Selector: isApprovedForAll(address,address) e985e9c5 + function isApprovedForAll(address owner, address operator) + external + view + returns (address); +} + +// Selector: 5b5e139f +interface ERC721Metadata is Dummy, ERC165 { + // Selector: name() 06fdde03 + function name() external view returns (string memory); + + // Selector: symbol() 95d89b41 + function symbol() external view returns (string memory); + + // Returns token's const_metadata + // + // Selector: tokenURI(uint256) c87b56dd + function tokenURI(uint256 tokenId) external view returns (string memory); +} + +// Selector: 68ccfe89 +interface ERC721Mintable is Dummy, ERC165, ERC721MintableEvents { + // Selector: mintingFinished() 05d2035b + function mintingFinished() external view returns (bool); + + // `token_id` should be obtained with `next_token_id` method, + // unlike standard, you can't specify it manually + // + // Selector: mint(address,uint256) 40c10f19 + function mint(address to, uint256 tokenId) external returns (bool); + + // `token_id` should be obtained with `next_token_id` method, + // unlike standard, you can't specify it manually + // + // Selector: mintWithTokenURI(address,uint256,string) 50bb4e7f + function mintWithTokenURI( + address to, + uint256 tokenId, + string memory tokenUri + ) external returns (bool); + + // @dev Not implemented + // + // Selector: finishMinting() 7d64bcb4 + function finishMinting() external returns (bool); +} + +// Selector: 780e9d63 +interface ERC721Enumerable is Dummy, ERC165 { + // Selector: tokenByIndex(uint256) 4f6ccce7 + function tokenByIndex(uint256 index) external view returns (uint256); + + // Not implemented + // + // Selector: tokenOfOwnerByIndex(address,uint256) 2f745c59 + function tokenOfOwnerByIndex(address owner, uint256 index) + external + view + returns (uint256); + + // Selector: totalSupply() 18160ddd + function totalSupply() external view returns (uint256); +} + // Selector: 7d9262e6 interface Collection is Dummy, ERC165 { // Set collection property. @@ -160,4 +363,15 @@ function setCollectionMintMode(bool mode) external; } -interface UniqueRefungible is Dummy, ERC165, Collection {} +interface UniqueRefungible is + Dummy, + ERC165, + ERC721, + ERC721Metadata, + ERC721Enumerable, + ERC721UniqueExtensions, + ERC721Mintable, + ERC721Burnable, + Collection, + TokenProperties +{} --- /dev/null +++ b/tests/src/eth/reFungibleAbi.json @@ -0,0 +1,510 @@ +[ + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "owner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "approved", + "type": "address" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + } + ], + "name": "Approval", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "owner", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "operator", + "type": "address" + }, + { + "indexed": false, + "internalType": "bool", + "name": "approved", + "type": "bool" + } + ], + "name": "ApprovalForAll", + "type": "event" + }, + { + "anonymous": false, + "inputs": [], + "name": "MintingFinished", + "type": "event" + }, + { + "anonymous": false, + "inputs": [ + { + "indexed": true, + "internalType": "address", + "name": "from", + "type": "address" + }, + { + "indexed": true, + "internalType": "address", + "name": "to", + "type": "address" + }, + { + "indexed": true, + "internalType": "uint256", + "name": "tokenId", + "type": "uint256" + } + ], + "name": "Transfer", + "type": "event" + }, + { + "inputs": [ + { "internalType": "address", "name": "newAdmin", "type": "address" } + ], + "name": "addCollectionAdmin", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "uint256", "name": "newAdmin", "type": "uint256" } + ], + "name": "addCollectionAdminSubstrate", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "address", "name": "user", "type": "address" } + ], + "name": "addToCollectionAllowList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "address", "name": "approved", "type": "address" }, + { "internalType": "uint256", "name": "tokenId", "type": "uint256" } + ], + "name": "approve", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "address", "name": "owner", "type": "address" } + ], + "name": "balanceOf", + "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { "internalType": "uint256", "name": "tokenId", "type": "uint256" } + ], + "name": "burn", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [{ "internalType": "string", "name": "key", "type": "string" }], + "name": "collectionProperty", + "outputs": [{ "internalType": "bytes", "name": "", "type": "bytes" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "confirmCollectionSponsorship", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "contractAddress", + "outputs": [{ "internalType": "address", "name": "", "type": "address" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [{ "internalType": "string", "name": "key", "type": "string" }], + "name": "deleteCollectionProperty", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "uint256", "name": "tokenId", "type": "uint256" }, + { "internalType": "string", "name": "key", "type": "string" } + ], + "name": "deleteProperty", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "finishMinting", + "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "uint256", "name": "tokenId", "type": "uint256" } + ], + "name": "getApproved", + "outputs": [{ "internalType": "address", "name": "", "type": "address" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { "internalType": "address", "name": "owner", "type": "address" }, + { "internalType": "address", "name": "operator", "type": "address" } + ], + "name": "isApprovedForAll", + "outputs": [{ "internalType": "address", "name": "", "type": "address" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { "internalType": "address", "name": "to", "type": "address" }, + { "internalType": "uint256", "name": "tokenId", "type": "uint256" } + ], + "name": "mint", + "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "address", "name": "to", "type": "address" }, + { "internalType": "uint256[]", "name": "tokenIds", "type": "uint256[]" } + ], + "name": "mintBulk", + "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "address", "name": "to", "type": "address" }, + { + "components": [ + { "internalType": "uint256", "name": "field_0", "type": "uint256" }, + { "internalType": "string", "name": "field_1", "type": "string" } + ], + "internalType": "struct Tuple0[]", + "name": "tokens", + "type": "tuple[]" + } + ], + "name": "mintBulkWithTokenURI", + "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "address", "name": "to", "type": "address" }, + { "internalType": "uint256", "name": "tokenId", "type": "uint256" }, + { "internalType": "string", "name": "tokenUri", "type": "string" } + ], + "name": "mintWithTokenURI", + "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [], + "name": "mintingFinished", + "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "name", + "outputs": [{ "internalType": "string", "name": "", "type": "string" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "nextTokenId", + "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { "internalType": "uint256", "name": "tokenId", "type": "uint256" } + ], + "name": "ownerOf", + "outputs": [{ "internalType": "address", "name": "", "type": "address" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { "internalType": "uint256", "name": "tokenId", "type": "uint256" }, + { "internalType": "string", "name": "key", "type": "string" } + ], + "name": "property", + "outputs": [{ "internalType": "bytes", "name": "", "type": "bytes" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { "internalType": "address", "name": "admin", "type": "address" } + ], + "name": "removeCollectionAdmin", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "uint256", "name": "admin", "type": "uint256" } + ], + "name": "removeCollectionAdminSubstrate", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "address", "name": "user", "type": "address" } + ], + "name": "removeFromCollectionAllowList", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "address", "name": "from", "type": "address" }, + { "internalType": "address", "name": "to", "type": "address" }, + { "internalType": "uint256", "name": "tokenId", "type": "uint256" } + ], + "name": "safeTransferFrom", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "address", "name": "from", "type": "address" }, + { "internalType": "address", "name": "to", "type": "address" }, + { "internalType": "uint256", "name": "tokenId", "type": "uint256" }, + { "internalType": "bytes", "name": "data", "type": "bytes" } + ], + "name": "safeTransferFromWithData", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "address", "name": "operator", "type": "address" }, + { "internalType": "bool", "name": "approved", "type": "bool" } + ], + "name": "setApprovalForAll", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [{ "internalType": "uint8", "name": "mode", "type": "uint8" }], + "name": "setCollectionAccess", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "string", "name": "limit", "type": "string" }, + { "internalType": "uint32", "name": "value", "type": "uint32" } + ], + "name": "setCollectionLimit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "string", "name": "limit", "type": "string" }, + { "internalType": "bool", "name": "value", "type": "bool" } + ], + "name": "setCollectionLimit", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [{ "internalType": "bool", "name": "mode", "type": "bool" }], + "name": "setCollectionMintMode", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [{ "internalType": "bool", "name": "enable", "type": "bool" }], + "name": "setCollectionNesting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "bool", "name": "enable", "type": "bool" }, + { + "internalType": "address[]", + "name": "collections", + "type": "address[]" + } + ], + "name": "setCollectionNesting", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "string", "name": "key", "type": "string" }, + { "internalType": "bytes", "name": "value", "type": "bytes" } + ], + "name": "setCollectionProperty", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "address", "name": "sponsor", "type": "address" } + ], + "name": "setCollectionSponsor", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "uint256", "name": "tokenId", "type": "uint256" }, + { "internalType": "string", "name": "key", "type": "string" }, + { "internalType": "bytes", "name": "value", "type": "bytes" } + ], + "name": "setProperty", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "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" } + ], + "name": "setTokenPropertyPermission", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + }, + { + "inputs": [ + { "internalType": "bytes4", "name": "interfaceID", "type": "bytes4" } + ], + "name": "supportsInterface", + "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "symbol", + "outputs": [{ "internalType": "string", "name": "", "type": "string" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { "internalType": "uint256", "name": "index", "type": "uint256" } + ], + "name": "tokenByIndex", + "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { "internalType": "address", "name": "owner", "type": "address" }, + { "internalType": "uint256", "name": "index", "type": "uint256" } + ], + "name": "tokenOfOwnerByIndex", + "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { "internalType": "uint256", "name": "tokenId", "type": "uint256" } + ], + "name": "tokenURI", + "outputs": [{ "internalType": "string", "name": "", "type": "string" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [], + "name": "totalSupply", + "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }], + "stateMutability": "view", + "type": "function" + }, + { + "inputs": [ + { "internalType": "address", "name": "from", "type": "address" }, + { "internalType": "address", "name": "to", "type": "address" }, + { "internalType": "uint256", "name": "tokenId", "type": "uint256" } + ], + "name": "transferFrom", + "outputs": [], + "stateMutability": "nonpayable", + "type": "function" + } +] --- a/tests/src/interfaces/augment-api-errors.ts +++ b/tests/src/interfaces/augment-api-errors.ts @@ -446,25 +446,83 @@ [key: string]: AugmentedError; }; rmrkCore: { + /** + * Not the target owner of the sent NFT. + **/ CannotAcceptNonOwnedNft: AugmentedError; + /** + * Not the target owner of the sent NFT. + **/ CannotRejectNonOwnedNft: AugmentedError; + /** + * NFT was not sent and is not pending. + **/ CannotRejectNonPendingNft: AugmentedError; + /** + * If an NFT is sent to a descendant, that would form a nesting loop, an ouroboros. + * Sending to self is redundant. + **/ CannotSendToDescendentOrSelf: AugmentedError; + /** + * Too many tokens created in the collection, no new ones are allowed. + **/ CollectionFullOrLocked: AugmentedError; + /** + * Only destroying collections without tokens is allowed. + **/ CollectionNotEmpty: AugmentedError; + /** + * Collection does not exist, has a wrong type, or does not map to a Unique ID. + **/ CollectionUnknown: AugmentedError; + /** + * Property of the type of RMRK collection could not be read successfully. + **/ CorruptedCollectionType: AugmentedError; - NftTypeEncodeError: AugmentedError; + /** + * Could not find an ID for a collection. It is likely there were too many collections created on the chain, causing an overflow. + **/ NoAvailableCollectionId: AugmentedError; + /** + * Token does not exist, or there is no suitable ID for it, likely too many tokens were created in a collection, causing an overflow. + **/ NoAvailableNftId: AugmentedError; + /** + * Could not find an ID for the resource. It is likely there were too many resources created on an NFT, causing an overflow. + **/ NoAvailableResourceId: AugmentedError; + /** + * Token is marked as non-transferable, and thus cannot be transferred. + **/ NonTransferable: AugmentedError; + /** + * No permission to perform action. + **/ NoPermission: AugmentedError; + /** + * No such resource found. + **/ ResourceDoesntExist: AugmentedError; + /** + * Resource is not pending for the operation. + **/ ResourceNotPending: AugmentedError; + /** + * Could not find a property by the supplied key. + **/ RmrkPropertyIsNotFound: AugmentedError; + /** + * Too many symbols supplied as the property key. The maximum is [256](up_data_structs::MAX_PROPERTY_KEY_LENGTH). + **/ RmrkPropertyKeyIsTooLong: AugmentedError; + /** + * Too many bytes supplied as the property value. The maximum is [32768](up_data_structs::MAX_PROPERTY_VALUE_LENGTH). + **/ RmrkPropertyValueIsTooLong: AugmentedError; + /** + * Something went wrong when decoding encoded data from the storage. + * Perhaps, there was a wrong key supplied for the type, or the data was improperly stored. + **/ UnableToDecodeRmrkData: AugmentedError; /** * Generic error @@ -472,12 +530,33 @@ [key: string]: AugmentedError; }; rmrkEquip: { + /** + * Base collection linked to this ID does not exist. + **/ BaseDoesntExist: AugmentedError; + /** + * No Theme named "default" is associated with the Base. + **/ NeedsDefaultThemeFirst: AugmentedError; + /** + * Could not find an ID for a Base collection. It is likely there were too many collections created on the chain, causing an overflow. + **/ NoAvailableBaseId: AugmentedError; + /** + * Could not find a suitable ID for a Part, likely too many Part tokens were created in the Base, causing an overflow + **/ NoAvailablePartId: AugmentedError; + /** + * Cannot assign equippables to a fixed Part. + **/ NoEquippableOnFixedPart: AugmentedError; + /** + * Part linked to this ID does not exist. + **/ PartDoesntExist: AugmentedError; + /** + * No permission to perform action. + **/ PermissionError: AugmentedError; /** * Generic error @@ -508,15 +587,15 @@ }; structure: { /** - * While iterating over children, reached the breadth limit. + * While nesting, reached the breadth limit of nesting, exceeding the provided budget. **/ BreadthLimit: AugmentedError; /** - * While searching for the owner, reached the depth limit. + * While nesting, reached the depth limit of nesting, exceeding the provided budget. **/ DepthLimit: AugmentedError; /** - * While searching for the owner, encountered an already checked account, detecting a loop. + * While nesting, encountered an already checked account, detecting a loop. **/ OuroborosDetected: AugmentedError; /** --- a/tests/src/interfaces/augment-api-query.ts +++ b/tests/src/interfaces/augment-api-query.ts @@ -492,7 +492,13 @@ [key: string]: QueryableStorageEntry; }; rmrkCore: { + /** + * Latest yet-unused collection ID. + **/ collectionIndex: AugmentedQuery Observable, []> & QueryableStorageEntry; + /** + * Mapping from RMRK collection ID to Unique's. + **/ uniqueCollectionId: AugmentedQuery Observable, [u32]> & QueryableStorageEntry; /** * Generic query @@ -500,7 +506,13 @@ [key: string]: QueryableStorageEntry; }; rmrkEquip: { + /** + * Checkmark that a Base has a Theme NFT named "default". + **/ baseHasDefaultTheme: AugmentedQuery Observable, [u32]> & QueryableStorageEntry; + /** + * Map of a Base ID and a Part ID to an NFT in the Base collection serving as the Part. + **/ inernalPartId: AugmentedQuery Observable>, [u32, u32]> & QueryableStorageEntry; /** * Generic query --- a/tests/src/interfaces/augment-api-tx.ts +++ b/tests/src/interfaces/augment-api-tx.ts @@ -348,103 +348,259 @@ }; rmrkCore: { /** - * Accepts an NFT sent from another account to self or owned NFT + * Accept an NFT sent from another account to self or an owned NFT. + * + * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first. * - * Parameters: - * - `origin`: sender of the transaction - * - `rmrk_collection_id`: collection id of the nft to be accepted - * - `rmrk_nft_id`: nft id of the nft to be accepted - * - `new_owner`: either origin's account ID or origin-owned NFT, whichever the NFT was - * sent to + * # Permissions: + * - Token-owner-to-be + * + * # Arguments: + * - `rmrk_collection_id`: RMRK collection ID of the NFT to be accepted. + * - `rmrk_nft_id`: ID of the NFT to be accepted. + * - `new_owner`: Either the sender's account ID or a sender-owned NFT, + * whichever the accepted NFT was sent to. **/ acceptNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>; /** - * accept the addition of a new resource to an existing NFT + * Accept the addition of a newly created pending resource to an existing NFT. + * + * This transaction is needed when a resource is created and assigned to an NFT + * by a non-owner, i.e. the collection issuer, with one of the + * [`add_...` transactions](Pallet::add_basic_resource). + * + * # Permissions: + * - Token owner + * + * # Arguments: + * - `rmrk_collection_id`: RMRK collection ID of the NFT. + * - `rmrk_nft_id`: ID of the NFT with a pending resource to be accepted. + * - `resource_id`: ID of the newly created pending resource. **/ acceptResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32, u32, u32]>; /** - * accept the removal of a resource of an existing NFT + * Accept the removal of a removal-pending resource from an NFT. + * + * This transaction is needed when a non-owner, i.e. the collection issuer, + * requests a [removal](`Pallet::remove_resource`) of a resource from an NFT. + * + * # Permissions: + * - Token owner + * + * # Arguments: + * - `rmrk_collection_id`: RMRK collection ID of the NFT. + * - `rmrk_nft_id`: ID of the NFT with a resource to be removed. + * - `resource_id`: ID of the removal-pending resource. **/ acceptResourceRemoval: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32, u32, u32]>; /** - * Create basic resource + * Create and set/propose a basic resource for an NFT. + * + * A basic resource is the simplest, lacking a Base and anything that comes with it. + * See RMRK docs for more information and examples. + * + * # Permissions: + * - Collection issuer - if not the token owner, adding the resource will warrant + * the owner's [acceptance](Pallet::accept_resource). + * + * # Arguments: + * - `rmrk_collection_id`: RMRK collection ID of the NFT. + * - `nft_id`: ID of the NFT to assign a resource to. + * - `resource`: Data of the resource to be created. **/ addBasicResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resource: RmrkTraitsResourceBasicResource | { src?: any; metadata?: any; license?: any; thumb?: any } | string | Uint8Array) => SubmittableExtrinsic, [u32, u32, RmrkTraitsResourceBasicResource]>; /** - * Create composable resource + * Create and set/propose a composable resource for an NFT. + * + * A composable resource links to a Base and has a subset of its Parts it is composed of. + * See RMRK docs for more information and examples. + * + * # Permissions: + * - Collection issuer - if not the token owner, adding the resource will warrant + * the owner's [acceptance](Pallet::accept_resource). + * + * # Arguments: + * - `rmrk_collection_id`: RMRK collection ID of the NFT. + * - `nft_id`: ID of the NFT to assign a resource to. + * - `resource`: Data of the resource to be created. **/ addComposableResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resource: RmrkTraitsResourceComposableResource | { parts?: any; base?: any; src?: any; metadata?: any; license?: any; thumb?: any } | string | Uint8Array) => SubmittableExtrinsic, [u32, u32, RmrkTraitsResourceComposableResource]>; /** - * Create slot resource + * Create and set/propose a slot resource for an NFT. + * + * A slot resource links to a Base and a slot ID in it which it can fit into. + * See RMRK docs for more information and examples. + * + * # Permissions: + * - Collection issuer - if not the token owner, adding the resource will warrant + * the owner's [acceptance](Pallet::accept_resource). + * + * # Arguments: + * - `rmrk_collection_id`: RMRK collection ID of the NFT. + * - `nft_id`: ID of the NFT to assign a resource to. + * - `resource`: Data of the resource to be created. **/ addSlotResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resource: RmrkTraitsResourceSlotResource | { base?: any; src?: any; metadata?: any; slot?: any; license?: any; thumb?: any } | string | Uint8Array) => SubmittableExtrinsic, [u32, u32, RmrkTraitsResourceSlotResource]>; /** - * burn nft + * Burn an NFT, destroying it and its nested tokens up to the specified limit. + * If the burning budget is exceeded, the transaction is reverted. + * + * This is the way to burn a nested token as well. + * + * For more information, see [`burn_recursively`](pallet_nonfungible::pallet::Pallet::burn_recursively). + * + * # Permissions: + * * Token owner + * + * # Arguments: + * - `collection_id`: RMRK ID of the collection in which the NFT to burn belongs to. + * - `nft_id`: ID of the NFT to be destroyed. + * - `max_burns`: Maximum number of tokens to burn, assuming nesting. The transaction + * is reverted if there are more tokens to burn in the nesting tree than this number. + * This is primarily a mechanism of transaction weight control. **/ burnNft: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, maxBurns: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32, u32, u32]>; /** - * Change the issuer of a collection + * Change the issuer of a collection. Analogous to Unique's collection's [`owner`](up_data_structs::Collection). * - * Parameters: - * - `origin`: sender of the transaction - * - `collection_id`: collection id of the nft to change issuer of - * - `new_issuer`: Collection's new issuer + * # Permissions: + * * Collection issuer + * + * # Arguments: + * - `collection_id`: RMRK collection ID to change the issuer of. + * - `new_issuer`: Collection's new issuer. **/ changeCollectionIssuer: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array, newIssuer: MultiAddress | { Id: any } | { Index: any } | { Raw: any } | { Address32: any } | { Address20: any } | string | Uint8Array) => SubmittableExtrinsic, [u32, MultiAddress]>; /** - * Create a collection + * Create a new collection of NFTs. + * + * # Permissions: + * * Anyone - will be assigned as the issuer of the collection. + * + * # Arguments: + * - `metadata`: Metadata describing the collection, e.g. IPFS hash. Cannot be changed. + * - `max`: Optional maximum number of tokens. + * - `symbol`: UTF-8 string with token prefix, by which to represent the token in wallets and UIs. + * Analogous to Unique's [`token_prefix`](up_data_structs::Collection). Cannot be changed. **/ createCollection: AugmentedSubmittable<(metadata: Bytes | string | Uint8Array, max: Option | null | object | string | Uint8Array, symbol: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Bytes, Option, Bytes]>; /** - * destroy collection + * Destroy a collection. + * + * Only empty collections can be destroyed. If it has any tokens, they must be burned first. + * + * # Permissions: + * * Collection issuer + * + * # Arguments: + * - `collection_id`: RMRK ID of the collection to destroy. **/ destroyCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; /** - * lock collection + * "Lock" the collection and prevent new token creation. Cannot be undone. + * + * # Permissions: + * * Collection issuer + * + * # Arguments: + * - `collection_id`: RMRK ID of the collection to lock. **/ lockCollection: AugmentedSubmittable<(collectionId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32]>; /** - * Mints an NFT in the specified collection - * Sets metadata and the royalty attribute + * Mint an NFT in a specified collection. + * + * # Permissions: + * * Collection issuer * - * Parameters: - * - `collection_id`: The class of the asset to be minted. - * - `nft_id`: The nft value of the asset to be minted. - * - `recipient`: Receiver of the royalty - * - `royalty`: Permillage reward from each trade for the Recipient - * - `metadata`: Arbitrary data about an nft, e.g. IPFS hash - * - `transferable`: Ability to transfer this NFT + * # Arguments: + * - `owner`: Owner account of the NFT. If set to None, defaults to the sender (collection issuer). + * - `collection_id`: RMRK collection ID for the NFT to be minted within. Cannot be changed. + * - `recipient`: Receiver account of the royalty. Has no effect if the `royalty_amount` is not set. Cannot be changed. + * - `royalty_amount`: Optional permillage reward from each trade for the `recipient`. Cannot be changed. + * - `metadata`: Arbitrary data about an NFT, e.g. IPFS hash. Cannot be changed. + * - `transferable`: Can this NFT be transferred? Cannot be changed. + * - `resources`: Resource data to be added to the NFT immediately after minting. **/ mintNft: AugmentedSubmittable<(owner: Option | null | object | string | Uint8Array, collectionId: u32 | AnyNumber | Uint8Array, recipient: Option | null | object | string | Uint8Array, royaltyAmount: Option | null | object | string | Uint8Array, metadata: Bytes | string | Uint8Array, transferable: bool | boolean | Uint8Array, resources: Option> | null | object | string | Uint8Array) => SubmittableExtrinsic, [Option, u32, Option, Option, Bytes, bool, Option>]>; /** - * Rejects an NFT sent from another account to self or owned NFT + * Reject an NFT sent from another account to self or owned NFT. + * The NFT in question will not be sent back and burnt instead. + * + * The NFT in question must be pending, and, thus, be [sent](`Pallet::send`) first. + * + * # Permissions: + * - Token-owner-to-be-not * - * Parameters: - * - `origin`: sender of the transaction - * - `rmrk_collection_id`: collection id of the nft to be accepted - * - `rmrk_nft_id`: nft id of the nft to be accepted + * # Arguments: + * - `rmrk_collection_id`: RMRK ID of the NFT to be rejected. + * - `rmrk_nft_id`: ID of the NFT to be rejected. **/ rejectNft: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32, u32]>; /** - * remove resource + * Remove and erase a resource from an NFT. + * + * If the sender does not own the NFT, then it will be pending confirmation, + * and will have to be [accepted](Pallet::accept_resource_removal) by the token owner. + * + * # Permissions + * - Collection issuer + * + * # Arguments + * - `collection_id`: RMRK ID of a collection to which the NFT making use of the resource belongs to. + * - `nft_id`: ID of the NFT with a resource to be removed. + * - `resource_id`: ID of the resource to be removed. **/ removeResource: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, nftId: u32 | AnyNumber | Uint8Array, resourceId: u32 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [u32, u32, u32]>; /** - * Transfers a NFT from an Account or NFT A to another Account or NFT B + * Transfer an NFT from an account/NFT A to another account/NFT B. + * The token must be transferable. Nesting cannot occur deeper than the [`NESTING_BUDGET`]. * - * Parameters: - * - `origin`: sender of the transaction - * - `rmrk_collection_id`: collection id of the nft to be transferred - * - `rmrk_nft_id`: nft id of the nft to be transferred - * - `new_owner`: new owner of the nft which can be either an account or a NFT + * If the target owner is an NFT owned by another account, then the NFT will enter + * the pending state and will have to be accepted by the other account. + * + * # Permissions: + * - Token owner + * + * # Arguments: + * - `collection_id`: RMRK ID of the collection of the NFT to be transferred. + * - `nft_id`: ID of the NFT to be transferred. + * - `new_owner`: New owner of the nft which can be either an account or a NFT. **/ send: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, newOwner: RmrkTraitsNftAccountIdOrCollectionNftTuple | { AccountId: any } | { CollectionAndNftTuple: any } | string | Uint8Array) => SubmittableExtrinsic, [u32, u32, RmrkTraitsNftAccountIdOrCollectionNftTuple]>; /** - * set a different order of resource priority + * Set a different order of resource priorities for an NFT. Priorities can be used, + * for example, for order of rendering. + * + * Note that the priorities are not updated automatically, and are an empty vector + * by default. There is no pre-set definition for the order to be particular, + * it can be interpreted arbitrarily use-case by use-case. + * + * # Permissions: + * - Token owner + * + * # Arguments: + * - `rmrk_collection_id`: RMRK collection ID of the NFT. + * - `rmrk_nft_id`: ID of the NFT to rearrange resource priorities for. + * - `priorities`: Ordered vector of resource IDs. **/ setPriority: AugmentedSubmittable<(rmrkCollectionId: u32 | AnyNumber | Uint8Array, rmrkNftId: u32 | AnyNumber | Uint8Array, priorities: Vec | (u32 | AnyNumber | Uint8Array)[]) => SubmittableExtrinsic, [u32, u32, Vec]>; /** - * set a custom value on an NFT + * Add or edit a custom user property, a key-value pair, describing the metadata + * of a token or a collection, on either one of these. + * + * Note that in this proxy implementation many details regarding RMRK are stored + * as scoped properties prefixed with "rmrk:", normally inaccessible + * to external transactions and RPCs. + * + * # Permissions: + * - Collection issuer - in case of collection property + * - Token owner - in case of NFT property + * + * # Arguments: + * - `rmrk_collection_id`: RMRK collection ID. + * - `maybe_nft_id`: Optional ID of the NFT. If left empty, then the property is set for the collection. + * - `key`: Key of the custom property to be referenced by. + * - `value`: Value of the custom property to be stored. **/ setProperty: AugmentedSubmittable<(rmrkCollectionId: Compact | AnyNumber | Uint8Array, maybeNftId: Option | null | object | string | Uint8Array, key: Bytes | string | Uint8Array, value: Bytes | string | Uint8Array) => SubmittableExtrinsic, [Compact, Option, Bytes, Bytes]>; /** @@ -454,32 +610,50 @@ }; rmrkEquip: { /** - * Creates a new Base. - * Modeled after [base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md) + * Create a new Base. + * + * Modeled after the [Base interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/base.md) + * + * # Permissions + * - Anyone - will be assigned as the issuer of the Base. * - * Parameters: - * - origin: Caller, will be assigned as the issuer of the Base - * - base_type: media type, e.g. "svg" - * - symbol: arbitrary client-chosen symbol - * - parts: array of Fixed and Slot parts composing the base, confined in length by - * RmrkPartsLimit + * # Arguments: + * - `base_type`: Arbitrary media type, e.g. "svg". + * - `symbol`: Arbitrary client-chosen symbol. + * - `parts`: Array of Fixed and Slot Parts composing the Base, + * confined in length by [`RmrkPartsLimit`](up_data_structs::RmrkPartsLimit). **/ createBase: AugmentedSubmittable<(baseType: Bytes | string | Uint8Array, symbol: Bytes | string | Uint8Array, parts: Vec | (RmrkTraitsPartPartType | { FixedPart: any } | { SlotPart: any } | string | Uint8Array)[]) => SubmittableExtrinsic, [Bytes, Bytes, Vec]>; + /** + * Update the array of Collections allowed to be equipped to a Base's specified Slot Part. + * + * Modeled after [equippable interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/equippable.md). + * + * # Permissions: + * - Base issuer + * + * # Arguments: + * - `base_id`: Base containing the Slot Part to be updated. + * - `part_id`: Slot Part whose Equippable List is being updated. + * - `equippables`: List of equippables that will override the current Equippables list. + **/ equippable: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, slotId: u32 | AnyNumber | Uint8Array, equippables: RmrkTraitsPartEquippableList | { All: any } | { Empty: any } | { Custom: any } | string | Uint8Array) => SubmittableExtrinsic, [u32, u32, RmrkTraitsPartEquippableList]>; /** - * Adds a Theme to a Base. - * Modeled after [themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md) - * Themes are stored in the Themes storage + * Add a Theme to a Base. * A Theme named "default" is required prior to adding other Themes. * - * Parameters: - * - origin: The caller of the function, must be issuer of the base - * - base_id: The Base containing the Theme to be updated - * - theme: The Theme to add to the Base. A Theme has a name and properties, which are an + * Modeled after [Themeadd interaction](https://github.com/rmrk-team/rmrk-spec/blob/master/standards/rmrk2.0.0/interactions/themeadd.md). + * + * # Permissions: + * - Base issuer + * + * # Arguments: + * - `base_id`: Base ID containing the Theme to be updated. + * - `theme`: Theme to add to the Base. A Theme has a name and properties, which are an * array of [key, value, inherit]. - * - key: arbitrary BoundedString, defined by client - * - value: arbitrary BoundedString, defined by client - * - inherit: optional bool + * - `key`: Arbitrary BoundedString, defined by client. + * - `value`: Arbitrary BoundedString, defined by client. + * - `inherit`: Optional bool. **/ themeAdd: AugmentedSubmittable<(baseId: u32 | AnyNumber | Uint8Array, theme: RmrkTraitsTheme | { name?: any; properties?: any; inherit?: any } | string | Uint8Array) => SubmittableExtrinsic, [u32, RmrkTraitsTheme]>; /** --- a/tests/src/interfaces/default/types.ts +++ b/tests/src/interfaces/default/types.ts @@ -1314,7 +1314,6 @@ /** @name PalletRmrkCoreError */ export interface PalletRmrkCoreError extends Enum { readonly isCorruptedCollectionType: boolean; - readonly isNftTypeEncodeError: boolean; readonly isRmrkPropertyKeyIsTooLong: boolean; readonly isRmrkPropertyValueIsTooLong: boolean; readonly isRmrkPropertyIsNotFound: boolean; @@ -1333,7 +1332,7 @@ readonly isCannotRejectNonPendingNft: boolean; readonly isResourceNotPending: boolean; readonly isNoAvailableResourceId: boolean; - readonly type: 'CorruptedCollectionType' | 'NftTypeEncodeError' | 'RmrkPropertyKeyIsTooLong' | 'RmrkPropertyValueIsTooLong' | 'RmrkPropertyIsNotFound' | 'UnableToDecodeRmrkData' | 'CollectionNotEmpty' | 'NoAvailableCollectionId' | 'NoAvailableNftId' | 'CollectionUnknown' | 'NoPermission' | 'NonTransferable' | 'CollectionFullOrLocked' | 'ResourceDoesntExist' | 'CannotSendToDescendentOrSelf' | 'CannotAcceptNonOwnedNft' | 'CannotRejectNonOwnedNft' | 'CannotRejectNonPendingNft' | 'ResourceNotPending' | 'NoAvailableResourceId'; + readonly type: 'CorruptedCollectionType' | 'RmrkPropertyKeyIsTooLong' | 'RmrkPropertyValueIsTooLong' | 'RmrkPropertyIsNotFound' | 'UnableToDecodeRmrkData' | 'CollectionNotEmpty' | 'NoAvailableCollectionId' | 'NoAvailableNftId' | 'CollectionUnknown' | 'NoPermission' | 'NonTransferable' | 'CollectionFullOrLocked' | 'ResourceDoesntExist' | 'CannotSendToDescendentOrSelf' | 'CannotAcceptNonOwnedNft' | 'CannotRejectNonOwnedNft' | 'CannotRejectNonPendingNft' | 'ResourceNotPending' | 'NoAvailableResourceId'; } /** @name PalletRmrkCoreEvent */ --- a/tests/src/interfaces/lookup.ts +++ b/tests/src/interfaces/lookup.ts @@ -2990,7 +2990,7 @@ * Lookup400: pallet_rmrk_core::pallet::Error **/ PalletRmrkCoreError: { - _enum: ['CorruptedCollectionType', 'NftTypeEncodeError', 'RmrkPropertyKeyIsTooLong', 'RmrkPropertyValueIsTooLong', 'RmrkPropertyIsNotFound', 'UnableToDecodeRmrkData', 'CollectionNotEmpty', 'NoAvailableCollectionId', 'NoAvailableNftId', 'CollectionUnknown', 'NoPermission', 'NonTransferable', 'CollectionFullOrLocked', 'ResourceDoesntExist', 'CannotSendToDescendentOrSelf', 'CannotAcceptNonOwnedNft', 'CannotRejectNonOwnedNft', 'CannotRejectNonPendingNft', 'ResourceNotPending', 'NoAvailableResourceId'] + _enum: ['CorruptedCollectionType', 'RmrkPropertyKeyIsTooLong', 'RmrkPropertyValueIsTooLong', 'RmrkPropertyIsNotFound', 'UnableToDecodeRmrkData', 'CollectionNotEmpty', 'NoAvailableCollectionId', 'NoAvailableNftId', 'CollectionUnknown', 'NoPermission', 'NonTransferable', 'CollectionFullOrLocked', 'ResourceDoesntExist', 'CannotSendToDescendentOrSelf', 'CannotAcceptNonOwnedNft', 'CannotRejectNonOwnedNft', 'CannotRejectNonPendingNft', 'ResourceNotPending', 'NoAvailableResourceId'] }, /** * Lookup402: pallet_rmrk_equip::pallet::Error --- a/tests/src/interfaces/types-lookup.ts +++ b/tests/src/interfaces/types-lookup.ts @@ -3144,7 +3144,6 @@ /** @name PalletRmrkCoreError (400) */ export interface PalletRmrkCoreError extends Enum { readonly isCorruptedCollectionType: boolean; - readonly isNftTypeEncodeError: boolean; readonly isRmrkPropertyKeyIsTooLong: boolean; readonly isRmrkPropertyValueIsTooLong: boolean; readonly isRmrkPropertyIsNotFound: boolean; @@ -3163,7 +3162,7 @@ readonly isCannotRejectNonPendingNft: boolean; readonly isResourceNotPending: boolean; readonly isNoAvailableResourceId: boolean; - readonly type: 'CorruptedCollectionType' | 'NftTypeEncodeError' | 'RmrkPropertyKeyIsTooLong' | 'RmrkPropertyValueIsTooLong' | 'RmrkPropertyIsNotFound' | 'UnableToDecodeRmrkData' | 'CollectionNotEmpty' | 'NoAvailableCollectionId' | 'NoAvailableNftId' | 'CollectionUnknown' | 'NoPermission' | 'NonTransferable' | 'CollectionFullOrLocked' | 'ResourceDoesntExist' | 'CannotSendToDescendentOrSelf' | 'CannotAcceptNonOwnedNft' | 'CannotRejectNonOwnedNft' | 'CannotRejectNonPendingNft' | 'ResourceNotPending' | 'NoAvailableResourceId'; + readonly type: 'CorruptedCollectionType' | 'RmrkPropertyKeyIsTooLong' | 'RmrkPropertyValueIsTooLong' | 'RmrkPropertyIsNotFound' | 'UnableToDecodeRmrkData' | 'CollectionNotEmpty' | 'NoAvailableCollectionId' | 'NoAvailableNftId' | 'CollectionUnknown' | 'NoPermission' | 'NonTransferable' | 'CollectionFullOrLocked' | 'ResourceDoesntExist' | 'CannotSendToDescendentOrSelf' | 'CannotAcceptNonOwnedNft' | 'CannotRejectNonOwnedNft' | 'CannotRejectNonPendingNft' | 'ResourceNotPending' | 'NoAvailableResourceId'; } /** @name PalletRmrkEquipError (402) */ -- gitstuff