`069b0ad95761`

4 files changed

modifiedpallets/nonfungible/src/erc.rsdiff before after both

--- a/pallets/nonfungible/src/erc.rs
+++ b/pallets/nonfungible/src/erc.rs
@@ -14,6 +14,11 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
+//! # Nonfungible Pallet EVM API
+//! 
+//! Provides ERC-721 standart support implementation and EVM API for unique extensions for Nonfungible Pallet.
+//! Method implementations are mostly doing parameter conversion and calling Nonfungible Pallet methods.
+
 extern crate alloc;
 use core::{
 	char::{REPLACEMENT_CHARACTER, decode_utf16},
@@ -40,8 +45,16 @@
 	SelfWeightOf, weights::WeightInfo, TokenProperties,
 };
 
+/// @title A contract that allows to set and delete token properties and change token property permissions.
+/// 
 #[solidity_interface(name = "TokenProperties")]
 impl<T: Config> NonfungibleHandle<T> {
+	/// @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 is_mutable Permission to mutate property.
+	/// @param collection_admin Permission to mutate property by collection admin if property is mutable.
+	/// @param token_owner Permission to mutate property by token owner if property is mutable.
 	fn set_token_property_permission(
 		&mut self,
 		caller: caller,
@@ -68,6 +81,11 @@
 		.map_err(dispatch_to_evm::<T>)
 	}
 
+	/// @notice Set token property value.
+	/// @dev Throws error if `msg.sender` has no permission to edit the property.
+	/// @param tokenId ID of the token.
+	/// @param key Property key.
+	/// @param value Property value.
 	fn set_property(
 		&mut self,
 		caller: caller,
@@ -96,6 +114,10 @@
 		.map_err(dispatch_to_evm::<T>)
 	}
 
+	/// @notice Delete token property value.
+	/// @dev Throws error if `msg.sender` has no permission to edit the property.
+	/// @param tokenId ID of the token.
+	/// @param key Property key.
 	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")?;
@@ -111,7 +133,10 @@
 			.map_err(dispatch_to_evm::<T>)
 	}
 
-	/// Throws error if key not found
+	/// @notice Get token property value.
+	/// @dev Throws error if key not found
+	/// @param tokenId ID of the token.
+	/// @param key Property key.
 	fn property(&self, token_id: uint256, key: string) -> Result<bytes> {
 		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
 		let key = <Vec<u8>>::from(key)
@@ -127,6 +152,11 @@
 
 #[derive(ToLog)]
 pub enum ERC721Events {
+	/// @dev This emits when ownership of any NFT changes by any mechanism.
+	///  This event emits when NFTs are created (`from` == 0) and destroyed
+	///  (`to` == 0). Exception: during contract creation, any number of NFTs
+	///  may be created and assigned without emitting Transfer. At the time of
+	///  any transfer, the approved address for that NFT (if any) is reset to none.
 	Transfer {
 		#[indexed]
 		from: address,
@@ -135,6 +165,10 @@
 		#[indexed]
 		token_id: uint256,
 	},
+	/// @dev This emits when the approved address for an NFT is changed or
+	///  reaffirmed. The zero address indicates there is no approved address.
+	///  When a Transfer event emits, this also indicates that the approved
+	///  address for that NFT (if any) is reset to none.
 	Approval {
 		#[indexed]
 		owner: address,
@@ -143,6 +177,8 @@
 		#[indexed]
 		token_id: uint256,
 	},
+	/// @dev This emits when an operator is enabled or disabled for an owner.
+	///  The operator can manage all NFTs of the owner.
 	#[allow(dead_code)]
 	ApprovalForAll {
 		#[indexed]
@@ -159,19 +195,27 @@
 	MintingFinished {},
 }
 
+/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension
+/// @dev See https://eips.ethereum.org/EIPS/eip-721
 #[solidity_interface(name = "ERC721Metadata")]
 impl<T: Config> NonfungibleHandle<T> {
+	/// @notice A descriptive name for a collection of NFTs in this contract
 	fn name(&self) -> Result<string> {
 		Ok(decode_utf16(self.name.iter().copied())
 			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))
 			.collect::<string>())
 	}
 
+	/// @notice An abbreviated name for NFTs in this contract
 	fn symbol(&self) -> Result<string> {
 		Ok(string::from_utf8_lossy(&self.token_prefix).into())
 	}
 
-	/// Returns token's const_metadata
+	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.
+    /// @dev Throws if `tokenId` is not a valid NFT. URIs are defined in RFC
+    ///  3986. The URI may point to a JSON file that conforms to the "ERC721
+    ///  Metadata JSON Schema".
+	/// @return token's const_metadata
 	#[solidity(rename_selector = "tokenURI")]
 	fn token_uri(&self, token_id: uint256) -> Result<string> {
 		let key = token_uri_key();
@@ -192,32 +236,53 @@
 	}
 }
 
+/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
+/// @dev See https://eips.ethereum.org/EIPS/eip-721
 #[solidity_interface(name = "ERC721Enumerable")]
 impl<T: Config> NonfungibleHandle<T> {
+	/// @notice Enumerate valid NFTs
+    /// @param index A counter less than `totalSupply()`
+    /// @return The token identifier for the `index`th NFT,
+    ///  (sort order not specified)
 	fn token_by_index(&self, index: uint256) -> Result<uint256> {
 		Ok(index)
 	}
 
-	/// Not implemented
+	/// @dev Not implemented
 	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {
 		// TODO: Not implemetable
 		Err("not implemented".into())
 	}
 
+	/// @notice Count NFTs tracked by this contract
+    /// @return A count of valid NFTs tracked by this contract, where each one of
+    ///  them has an assigned and queryable owner not equal to the zero address
 	fn total_supply(&self) -> Result<uint256> {
 		self.consume_store_reads(1)?;
 		Ok(<Pallet<T>>::total_supply(self).into())
 	}
 }
 
+/// @title ERC-721 Non-Fungible Token Standard
+/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
 #[solidity_interface(name = "ERC721", events(ERC721Events))]
 impl<T: Config> NonfungibleHandle<T> {
+	/// @notice Count all NFTs assigned to an owner
+	/// @dev NFTs assigned to the zero address are considered invalid, and this
+	///  function throws for queries about the zero address.
+	/// @param owner An address for whom to query the balance
+	/// @return The number of NFTs owned by `owner`, possibly zero
 	fn balance_of(&self, owner: address) -> Result<uint256> {
 		self.consume_store_reads(1)?;
 		let owner = T::CrossAccountId::from_eth(owner);
 		let balance = <AccountBalance<T>>::get((self.id, owner));
 		Ok(balance.into())
 	}
+	/// @notice Find the owner of an NFT
+	/// @dev NFTs assigned to zero address are considered invalid, and queries
+	///  about them do throw.
+	/// @param tokenId The identifier for an NFT
+	/// @return The address of the owner of the NFT
 	fn owner_of(&self, token_id: uint256) -> Result<address> {
 		self.consume_store_reads(1)?;
 		let token: TokenId = token_id.try_into()?;
@@ -226,7 +291,7 @@
 			.owner
 			.as_eth())
 	}
-	/// Not implemented
+	/// @dev Not implemented
 	fn safe_transfer_from_with_data(
 		&mut self,
 		_from: address,
@@ -238,7 +303,7 @@
 		// TODO: Not implemetable
 		Err("not implemented".into())
 	}
-	/// Not implemented
+	/// @dev Not implemented
 	fn safe_transfer_from(
 		&mut self,
 		_from: address,
@@ -250,6 +315,16 @@
 		Err("not implemented".into())
 	}
 
+	/// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE
+	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE
+	///  THEY MAY BE PERMANENTLY LOST
+	/// @dev Throws unless `msg.sender` is the current owner or an authorized
+	///  operator for this NFT. Throws if `from` is not the current owner. Throws
+	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.
+	/// @param from The current owner of the NFT
+	/// @param to The new owner
+	/// @param tokenId The NFT to transfer
+	/// @param _value Not used for an NFT
 	#[weight(<SelfWeightOf<T>>::transfer_from())]
 	fn transfer_from(
 		&mut self,
@@ -272,6 +347,12 @@
 		Ok(())
 	}
 
+	/// @notice Set or reaffirm the approved address for an NFT
+	/// @dev The zero address indicates there is no approved address.
+	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized
+	///  operator of the current owner.
+	/// @param approved The new approved NFT controller
+	/// @param tokenId The NFT to approve
 	#[weight(<SelfWeightOf<T>>::approve())]
 	fn approve(
 		&mut self,
@@ -289,7 +370,7 @@
 		Ok(())
 	}
 
-	/// Not implemented
+	/// @dev Not implemented
 	fn set_approval_for_all(
 		&mut self,
 		_caller: caller,
@@ -300,21 +381,26 @@
 		Err("not implemented".into())
 	}
 
-	/// Not implemented
+	/// @dev Not implemented
 	fn get_approved(&self, _token_id: uint256) -> Result<address> {
 		// TODO: Not implemetable
 		Err("not implemented".into())
 	}
 
-	/// Not implemented
+	/// @dev Not implemented
 	fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {
 		// TODO: Not implemetable
 		Err("not implemented".into())
 	}
 }
 
+/// @title ERC721 Token that can be irreversibly burned (destroyed).
 #[solidity_interface(name = "ERC721Burnable")]
 impl<T: Config> NonfungibleHandle<T> {
+	/// @notice Burns a specific ERC721 token.
+	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized
+	///  operator of the current owner.
+	/// @param tokenId The NFT to approve
 	#[weight(<SelfWeightOf<T>>::burn_item())]
 	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {
 		let caller = T::CrossAccountId::from_eth(caller);
@@ -325,14 +411,18 @@
 	}
 }
 
+/// @title ERC721 minting logic.
 #[solidity_interface(name = "ERC721Mintable", events(ERC721MintableEvents))]
 impl<T: Config> NonfungibleHandle<T> {
 	fn minting_finished(&self) -> Result<bool> {
 		Ok(false)
 	}
 
-	/// `token_id` should be obtained with `next_token_id` method,
-	/// unlike standard, you can't specify it manually
+	/// @notice Function to mint token.
+	/// @dev `tokenId` should be obtained with `nextTokenId` method,
+	///  unlike standard, you can't specify it manually
+	/// @param to The new owner
+	/// @param tokenId ID of the minted NFT
 	#[weight(<SelfWeightOf<T>>::create_item())]
 	fn mint(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
@@ -364,8 +454,12 @@
 		Ok(true)
 	}
 
-	/// `token_id` should be obtained with `next_token_id` method,
-	/// unlike standard, you can't specify it manually
+	/// @notice Function to mint token with the given tokenUri.
+	/// @dev `tokenId` should be obtained with `nextTokenId` method,
+	///  unlike standard, you can't specify it manually
+	/// @param to The new owner
+	/// @param tokenId ID of the minted NFT
+	/// @param tokenUri Token URI that would be stored in the NFT properties
 	#[solidity(rename_selector = "mintWithTokenURI")]
 	#[weight(<SelfWeightOf<T>>::create_item())]
 	fn mint_with_token_uri(
@@ -420,7 +514,7 @@
 		Ok(true)
 	}
 
-	/// Not implemented
+	/// @dev Not implemented
 	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {
 		Err("not implementable".into())
 	}
@@ -449,8 +543,15 @@
 	false
 }
 
+/// @title Unique extensions for ERC721.
 #[solidity_interface(name = "ERC721UniqueExtensions")]
 impl<T: Config> NonfungibleHandle<T> {
+	/// @notice Transfer ownership of an NFT
+	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`
+	///  is the zero address. Throws if `tokenId` is not a valid NFT.
+	/// @param to The new owner
+	/// @param tokenId The NFT to transfer
+	/// @param _value Not used for an NFT
 	#[weight(<SelfWeightOf<T>>::transfer())]
 	fn transfer(
 		&mut self,
@@ -470,6 +571,13 @@
 		Ok(())
 	}
 
+	/// @notice Burns a specific ERC721 token.
+	/// @dev Throws unless `msg.sender` is the current owner or an authorized
+	///  operator for this NFT. Throws if `from` is not the current owner. Throws
+	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.
+	/// @param from The current owner of the NFT
+	/// @param tokenId The NFT to transfer
+	/// @param _value Not used for an NFT
 	#[weight(<SelfWeightOf<T>>::burn_from())]
 	fn burn_from(
 		&mut self,
@@ -490,6 +598,7 @@
 		Ok(())
 	}
 
+	/// @notice Returns next free NFT ID.
 	fn next_token_id(&self) -> Result<uint256> {
 		self.consume_store_reads(1)?;
 		Ok(<TokensMinted<T>>::get(self.id)
@@ -498,6 +607,11 @@
 			.into())
 	}
 
+	/// @notice Function to mint multiple tokens.
+	/// @dev `tokenIds` should be an array of consecutive numbers and first number
+	///  should be obtained with `nextTokenId` method
+	/// @param to The new owner
+	/// @param tokenIds IDs of the minted NFTs
 	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]
 	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {
 		let caller = T::CrossAccountId::from_eth(caller);
@@ -529,6 +643,11 @@
 		Ok(true)
 	}
 
+	/// @notice Function to mint multiple tokens with the given tokenUris.
+	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive
+	///  numbers and first number should be obtained with `nextTokenId` method
+	/// @param to The new owner
+	/// @param tokens array of pairs of token ID and token URI for minted tokens
 	#[solidity(rename_selector = "mintBulkWithTokenURI")]
 	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]
 	fn mint_bulk_with_token_uri(

modifiedpallets/nonfungible/src/stubs/UniqueNFT.rawdiff before after both

binary blob — no preview

modifiedpallets/nonfungible/src/stubs/UniqueNFT.soldiff before after both

--- a/pallets/nonfungible/src/stubs/UniqueNFT.sol
+++ b/pallets/nonfungible/src/stubs/UniqueNFT.sol
@@ -53,6 +53,13 @@
 
 // Selector: 41369377
 contract 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 is_mutable Permission to mutate property.
+	// @param collection_admin Permission to mutate property by collection admin if property is mutable.
+	// @param token_owner Permission to mutate property by token owner if property is mutable.
+	//
 	// Selector: setTokenPropertyPermission(string,bool,bool,bool) 222d97fa
 	function setTokenPropertyPermission(
 		string memory key,
@@ -68,6 +75,12 @@
 		dummy = 0;
 	}
 
+	// @notice Set token property value.
+	// @dev Throws error if `msg.sender` has no permission to edit the property.
+	// @param token_id ID of the token.
+	// @param key Property key.
+	// @param value Property value.
+	//
 	// Selector: setProperty(uint256,string,bytes) 1752d67b
 	function setProperty(
 		uint256 tokenId,
@@ -81,6 +94,11 @@
 		dummy = 0;
 	}
 
+	// @notice Delete token property value.
+	// @dev Throws error if `msg.sender` has no permission to edit the property.
+	// @param token_id ID of the token.
+	// @param key Property key.
+	//
 	// Selector: deleteProperty(uint256,string) 066111d1
 	function deleteProperty(uint256 tokenId, string memory key) public {
 		require(false, stub_error);
@@ -89,7 +107,10 @@
 		dummy = 0;
 	}
 
-	// Throws error if key not found
+	// @notice Get token property value.
+	// @dev Throws error if key not found
+	// @param token_id ID of the token.
+	// @param key Property key.
 	//
 	// Selector: property(uint256,string) 7228c327
 	function property(uint256 tokenId, string memory key)
@@ -107,6 +128,11 @@
 
 // Selector: 42966c68
 contract ERC721Burnable is Dummy, ERC165 {
+	// @notice Burns a specific ERC721 token.
+	// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized
+	//  operator of the current owner.
+	// @param tokenId The NFT to approve
+	//
 	// Selector: burn(uint256) 42966c68
 	function burn(uint256 tokenId) public {
 		require(false, stub_error);
@@ -117,6 +143,12 @@
 
 // Selector: 58800161
 contract ERC721 is Dummy, ERC165, ERC721Events {
+	// @notice Count all NFTs assigned to an owner
+	// @dev NFTs assigned to the zero address are considered invalid, and this
+	//  function throws for queries about the zero address.
+	// @param _owner An address for whom to query the balance
+	// @return The number of NFTs owned by `_owner`, possibly zero
+	//
 	// Selector: balanceOf(address) 70a08231
 	function balanceOf(address owner) public view returns (uint256) {
 		require(false, stub_error);
@@ -125,6 +157,12 @@
 		return 0;
 	}
 
+	// @notice Find the owner of an NFT
+	// @dev NFTs assigned to zero address are considered invalid, and queries
+	//  about them do throw.
+	// @param _tokenId The identifier for an NFT
+	// @return The address of the owner of the NFT
+	//
 	// Selector: ownerOf(uint256) 6352211e
 	function ownerOf(uint256 tokenId) public view returns (address) {
 		require(false, stub_error);
@@ -133,7 +171,7 @@
 		return 0x0000000000000000000000000000000000000000;
 	}
 
-	// Not implemented
+	// @dev Not implemented
 	//
 	// Selector: safeTransferFromWithData(address,address,uint256,bytes) 60a11672
 	function safeTransferFromWithData(
@@ -150,7 +188,7 @@
 		dummy = 0;
 	}
 
-	// Not implemented
+	// @dev Not implemented
 	//
 	// Selector: safeTransferFrom(address,address,uint256) 42842e0e
 	function safeTransferFrom(
@@ -165,6 +203,17 @@
 		dummy = 0;
 	}
 
+	// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE
+	//  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE
+	//  THEY MAY BE PERMANENTLY LOST
+	// @dev Throws unless `msg.sender` is the current owner or an authorized
+	//  operator for this NFT. Throws if `from` is not the current owner. Throws
+	//  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.
+	// @param from The current owner of the NFT
+	// @param to The new owner
+	// @param tokenId The NFT to transfer
+	// @param _value Not used for an NFT
+	//
 	// Selector: transferFrom(address,address,uint256) 23b872dd
 	function transferFrom(
 		address from,
@@ -178,6 +227,13 @@
 		dummy = 0;
 	}
 
+	// @notice Set or reaffirm the approved address for an NFT
+	// @dev The zero address indicates there is no approved address.
+	// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized
+	//  operator of the current owner.
+	// @param approved The new approved NFT controller
+	// @param tokenId The NFT to approve
+	//
 	// Selector: approve(address,uint256) 095ea7b3
 	function approve(address approved, uint256 tokenId) public {
 		require(false, stub_error);
@@ -186,7 +242,7 @@
 		dummy = 0;
 	}
 
-	// Not implemented
+	// @dev Not implemented
 	//
 	// Selector: setApprovalForAll(address,bool) a22cb465
 	function setApprovalForAll(address operator, bool approved) public {
@@ -196,7 +252,7 @@
 		dummy = 0;
 	}
 
-	// Not implemented
+	// @dev Not implemented
 	//
 	// Selector: getApproved(uint256) 081812fc
 	function getApproved(uint256 tokenId) public view returns (address) {
@@ -206,7 +262,7 @@
 		return 0x0000000000000000000000000000000000000000;
 	}
 
-	// Not implemented
+	// @dev Not implemented
 	//
 	// Selector: isApprovedForAll(address,address) e985e9c5
 	function isApprovedForAll(address owner, address operator)
@@ -224,6 +280,8 @@
 
 // Selector: 5b5e139f
 contract ERC721Metadata is Dummy, ERC165 {
+	// @notice A descriptive name for a collection of NFTs in this contract
+	//
 	// Selector: name() 06fdde03
 	function name() public view returns (string memory) {
 		require(false, stub_error);
@@ -231,6 +289,8 @@
 		return "";
 	}
 
+	// @notice An abbreviated name for NFTs in this contract
+	//
 	// Selector: symbol() 95d89b41
 	function symbol() public view returns (string memory) {
 		require(false, stub_error);
@@ -238,7 +298,11 @@
 		return "";
 	}
 
-	// Returns token's const_metadata
+	// @notice A distinct Uniform Resource Identifier (URI) for a given asset.
+	// @dev Throws if `tokenId` is not a valid NFT. URIs are defined in RFC
+	//  3986. The URI may point to a JSON file that conforms to the "ERC721
+	//  Metadata JSON Schema".
+	// @return token's const_metadata
 	//
 	// Selector: tokenURI(uint256) c87b56dd
 	function tokenURI(uint256 tokenId) public view returns (string memory) {
@@ -258,8 +322,11 @@
 		return false;
 	}
 
-	// `token_id` should be obtained with `next_token_id` method,
-	// unlike standard, you can't specify it manually
+	// @notice Function to mint token.
+	// @dev `tokenId` should be obtained with `nextTokenId` method,
+	//  unlike standard, you can't specify it manually
+	// @param to The new owner
+	// @param tokenId ID of the minted NFT
 	//
 	// Selector: mint(address,uint256) 40c10f19
 	function mint(address to, uint256 tokenId) public returns (bool) {
@@ -270,8 +337,12 @@
 		return false;
 	}
 
-	// `token_id` should be obtained with `next_token_id` method,
-	// unlike standard, you can't specify it manually
+	// @notice Function to mint token with the given tokenUri.
+	// @dev `tokenId` should be obtained with `nextTokenId` method,
+	//  unlike standard, you can't specify it manually
+	// @param to The new owner
+	// @param tokenId ID of the minted NFT
+	// @param tokenUri Token URI that would be stored in the NFT properties
 	//
 	// Selector: mintWithTokenURI(address,uint256,string) 50bb4e7f
 	function mintWithTokenURI(
@@ -287,7 +358,7 @@
 		return false;
 	}
 
-	// Not implemented
+	// @dev Not implemented
 	//
 	// Selector: finishMinting() 7d64bcb4
 	function finishMinting() public returns (bool) {
@@ -299,6 +370,12 @@
 
 // Selector: 780e9d63
 contract ERC721Enumerable is Dummy, ERC165 {
+	// @notice Enumerate valid NFTs
+	// @dev Throws if `index` >= `totalSupply()`.
+	// @param index A counter less than `totalSupply()`
+	// @return The token identifier for the `index`th NFT,
+	//  (sort order not specified)
+	//
 	// Selector: tokenByIndex(uint256) 4f6ccce7
 	function tokenByIndex(uint256 index) public view returns (uint256) {
 		require(false, stub_error);
@@ -307,7 +384,7 @@
 		return 0;
 	}
 
-	// Not implemented
+	// @dev Not implemented
 	//
 	// Selector: tokenOfOwnerByIndex(address,uint256) 2f745c59
 	function tokenOfOwnerByIndex(address owner, uint256 index)
@@ -322,6 +399,10 @@
 		return 0;
 	}
 
+	// @notice Count NFTs tracked by this contract
+	// @return A count of valid NFTs tracked by this contract, where each one of
+	//  them has an assigned and queryable owner not equal to the zero address
+	//
 	// Selector: totalSupply() 18160ddd
 	function totalSupply() public view returns (uint256) {
 		require(false, stub_error);
@@ -475,6 +556,15 @@
 
 // Selector: d74d154f
 contract ERC721UniqueExtensions is Dummy, ERC165 {
+	// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE
+	//  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE
+	//  THEY MAY BE PERMANENTLY LOST
+	// @dev Throws unless `msg.sender` is the current owner. Throws if `to`
+	//  is the zero address. Throws if `tokenId` is not a valid NFT.
+	// @param to The new owner
+	// @param tokenId The NFT to transfer
+	// @param _value Not used for an NFT
+	//
 	// Selector: transfer(address,uint256) a9059cbb
 	function transfer(address to, uint256 tokenId) public {
 		require(false, stub_error);
@@ -483,6 +573,14 @@
 		dummy = 0;
 	}
 
+	// @notice Burns a specific ERC721 token.
+	// @dev Throws unless `msg.sender` is the current owner or an authorized
+	//  operator for this NFT. Throws if `from` is not the current owner. Throws
+	//  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.
+	// @param from The current owner of the NFT
+	// @param tokenId The NFT to transfer
+	// @param _value Not used for an NFT
+	//
 	// Selector: burnFrom(address,uint256) 79cc6790
 	function burnFrom(address from, uint256 tokenId) public {
 		require(false, stub_error);
@@ -491,6 +589,8 @@
 		dummy = 0;
 	}
 
+	// @notice Returns next free NFT ID.
+	//
 	// Selector: nextTokenId() 75794a3c
 	function nextTokenId() public view returns (uint256) {
 		require(false, stub_error);
@@ -498,6 +598,12 @@
 		return 0;
 	}
 
+	// @notice Function to mint multiple tokens.
+	// @dev `tokenIds` should be an array of consecutive numbers and first number
+	//  should be obtained with `nextTokenId` method
+	// @param to The new owner
+	// @param tokenIds IDs of the minted NFTs
+	//
 	// Selector: mintBulk(address,uint256[]) 44a9945e
 	function mintBulk(address to, uint256[] memory tokenIds)
 		public
@@ -510,6 +616,12 @@
 		return false;
 	}
 
+	// @notice Function to mint multiple tokens with the given tokenUris.
+	// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive
+	//  numbers and first number should be obtained with `nextTokenId` method
+	// @param to The new owner
+	// @param tokens array of pairs of token ID and token URI for minted tokens
+	//
 	// Selector: mintBulkWithTokenURI(address,(uint256,string)[]) 36543006
 	function mintBulkWithTokenURI(address to, Tuple0[] memory tokens)
 		public

modifiedtests/src/eth/api/UniqueNFT.soldiff before after both

4444
45// Selector: 4136937745// Selector: 41369377
46interface TokenProperties is Dummy, ERC165 {46interface TokenProperties is Dummy, ERC165 {
47	// @notice Set permissions for token property.
48	// @dev Throws error if `msg.sender` is not admin or owner of the collection.
49	// @param key Property key.
50	// @param is_mutable Permission to mutate property.
51	// @param collection_admin Permission to mutate property by collection admin if property is mutable.
52	// @param token_owner Permission to mutate property by token owner if property is mutable.
53	//
47	// Selector: setTokenPropertyPermission(string,bool,bool,bool) 222d97fa54	// Selector: setTokenPropertyPermission(string,bool,bool,bool) 222d97fa
48	function setTokenPropertyPermission(55	function setTokenPropertyPermission(
49		string memory key,56		string memory key,
52		bool tokenOwner59		bool tokenOwner
53	) external;60	) external;
5461
62	// @notice Set token property value.
63	// @dev Throws error if `msg.sender` has no permission to edit the property.
64	// @param token_id ID of the token.
65	// @param key Property key.
66	// @param value Property value.
67	//
55	// Selector: setProperty(uint256,string,bytes) 1752d67b68	// Selector: setProperty(uint256,string,bytes) 1752d67b
56	function setProperty(69	function setProperty(
57		uint256 tokenId,70		uint256 tokenId,
58		string memory key,71		string memory key,
59		bytes memory value72		bytes memory value
60	) external;73	) external;
6174
75	// @notice Delete token property value.
76	// @dev Throws error if `msg.sender` has no permission to edit the property.
77	// @param token_id ID of the token.
78	// @param key Property key.
79	//
62	// Selector: deleteProperty(uint256,string) 066111d180	// Selector: deleteProperty(uint256,string) 066111d1
63	function deleteProperty(uint256 tokenId, string memory key) external;81	function deleteProperty(uint256 tokenId, string memory key) external;
6482
83	// @notice Get token property value.
65	// Throws error if key not found84	// @dev Throws error if key not found
85	// @param token_id ID of the token.
86	// @param key Property key.
66	//87	//
67	// Selector: property(uint256,string) 7228c32788	// Selector: property(uint256,string) 7228c327
68	function property(uint256 tokenId, string memory key)89	function property(uint256 tokenId, string memory key)
7394
74// Selector: 42966c6895// Selector: 42966c68
75interface ERC721Burnable is Dummy, ERC165 {96interface ERC721Burnable is Dummy, ERC165 {
97	// @notice Burns a specific ERC721 token.
98	// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized
99	//  operator of the current owner.
100	// @param tokenId The NFT to approve
101	//
76	// Selector: burn(uint256) 42966c68102	// Selector: burn(uint256) 42966c68
77	function burn(uint256 tokenId) external;103	function burn(uint256 tokenId) external;
78}104}
79105
80// Selector: 58800161106// Selector: 58800161
81interface ERC721 is Dummy, ERC165, ERC721Events {107interface ERC721 is Dummy, ERC165, ERC721Events {
108	// @notice Count all NFTs assigned to an owner
109	// @dev NFTs assigned to the zero address are considered invalid, and this
110	//  function throws for queries about the zero address.
111	// @param _owner An address for whom to query the balance
112	// @return The number of NFTs owned by `_owner`, possibly zero
113	//
82	// Selector: balanceOf(address) 70a08231114	// Selector: balanceOf(address) 70a08231
83	function balanceOf(address owner) external view returns (uint256);115	function balanceOf(address owner) external view returns (uint256);
84116
117	// @notice Find the owner of an NFT
118	// @dev NFTs assigned to zero address are considered invalid, and queries
119	//  about them do throw.
120	// @param _tokenId The identifier for an NFT
121	// @return The address of the owner of the NFT
122	//
85	// Selector: ownerOf(uint256) 6352211e123	// Selector: ownerOf(uint256) 6352211e
86	function ownerOf(uint256 tokenId) external view returns (address);124	function ownerOf(uint256 tokenId) external view returns (address);
87125
88	// Not implemented126	// @dev Not implemented
89	//127	//
90	// Selector: safeTransferFromWithData(address,address,uint256,bytes) 60a11672128	// Selector: safeTransferFromWithData(address,address,uint256,bytes) 60a11672
91	function safeTransferFromWithData(129	function safeTransferFromWithData(
95		bytes memory data133		bytes memory data
96	) external;134	) external;
97135
98	// Not implemented136	// @dev Not implemented
99	//137	//
100	// Selector: safeTransferFrom(address,address,uint256) 42842e0e138	// Selector: safeTransferFrom(address,address,uint256) 42842e0e
101	function safeTransferFrom(139	function safeTransferFrom(
104		uint256 tokenId142		uint256 tokenId
105	) external;143	) external;
106144
145	// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE
146	//  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE
147	//  THEY MAY BE PERMANENTLY LOST
148	// @dev Throws unless `msg.sender` is the current owner or an authorized
149	//  operator for this NFT. Throws if `from` is not the current owner. Throws
150	//  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.
151	// @param from The current owner of the NFT
152	// @param to The new owner
153	// @param tokenId The NFT to transfer
154	// @param _value Not used for an NFT
155	//
107	// Selector: transferFrom(address,address,uint256) 23b872dd156	// Selector: transferFrom(address,address,uint256) 23b872dd
108	function transferFrom(157	function transferFrom(
109		address from,158		address from,
110		address to,159		address to,
111		uint256 tokenId160		uint256 tokenId
112	) external;161	) external;
113162
163	// @notice Set or reaffirm the approved address for an NFT
164	// @dev The zero address indicates there is no approved address.
165	// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized
166	//  operator of the current owner.
167	// @param approved The new approved NFT controller
168	// @param tokenId The NFT to approve
169	//
114	// Selector: approve(address,uint256) 095ea7b3170	// Selector: approve(address,uint256) 095ea7b3
115	function approve(address approved, uint256 tokenId) external;171	function approve(address approved, uint256 tokenId) external;
116172
117	// Not implemented173	// @dev Not implemented
118	//174	//
119	// Selector: setApprovalForAll(address,bool) a22cb465175	// Selector: setApprovalForAll(address,bool) a22cb465
120	function setApprovalForAll(address operator, bool approved) external;176	function setApprovalForAll(address operator, bool approved) external;
121177
122	// Not implemented178	// @dev Not implemented
123	//179	//
124	// Selector: getApproved(uint256) 081812fc180	// Selector: getApproved(uint256) 081812fc
125	function getApproved(uint256 tokenId) external view returns (address);181	function getApproved(uint256 tokenId) external view returns (address);
126182
127	// Not implemented183	// @dev Not implemented
128	//184	//
129	// Selector: isApprovedForAll(address,address) e985e9c5185	// Selector: isApprovedForAll(address,address) e985e9c5
130	function isApprovedForAll(address owner, address operator)186	function isApprovedForAll(address owner, address operator)
135191
136// Selector: 5b5e139f192// Selector: 5b5e139f
137interface ERC721Metadata is Dummy, ERC165 {193interface ERC721Metadata is Dummy, ERC165 {
194	// @notice A descriptive name for a collection of NFTs in this contract
195	//
138	// Selector: name() 06fdde03196	// Selector: name() 06fdde03
139	function name() external view returns (string memory);197	function name() external view returns (string memory);
140198
199	// @notice An abbreviated name for NFTs in this contract
200	//
141	// Selector: symbol() 95d89b41201	// Selector: symbol() 95d89b41
142	function symbol() external view returns (string memory);202	function symbol() external view returns (string memory);
143203
204	// @notice A distinct Uniform Resource Identifier (URI) for a given asset.
205	// @dev Throws if `tokenId` is not a valid NFT. URIs are defined in RFC
206	//  3986. The URI may point to a JSON file that conforms to the "ERC721
207	//  Metadata JSON Schema".
144	// Returns token's const_metadata208	// @return token's const_metadata
145	//209	//
146	// Selector: tokenURI(uint256) c87b56dd210	// Selector: tokenURI(uint256) c87b56dd
147	function tokenURI(uint256 tokenId) external view returns (string memory);211	function tokenURI(uint256 tokenId) external view returns (string memory);
152	// Selector: mintingFinished() 05d2035b216	// Selector: mintingFinished() 05d2035b
153	function mintingFinished() external view returns (bool);217	function mintingFinished() external view returns (bool);
154218
219	// @notice Function to mint token.
155	// `token_id` should be obtained with `next_token_id` method,220	// @dev `tokenId` should be obtained with `nextTokenId` method,
156	// unlike standard, you can't specify it manually221	//  unlike standard, you can't specify it manually
222	// @param to The new owner
223	// @param tokenId ID of the minted NFT
157	//224	//
158	// Selector: mint(address,uint256) 40c10f19225	// Selector: mint(address,uint256) 40c10f19
159	function mint(address to, uint256 tokenId) external returns (bool);226	function mint(address to, uint256 tokenId) external returns (bool);
160227
228	// @notice Function to mint token with the given tokenUri.
161	// `token_id` should be obtained with `next_token_id` method,229	// @dev `tokenId` should be obtained with `nextTokenId` method,
162	// unlike standard, you can't specify it manually230	//  unlike standard, you can't specify it manually
231	// @param to The new owner
232	// @param tokenId ID of the minted NFT
233	// @param tokenUri Token URI that would be stored in the NFT properties
163	//234	//
164	// Selector: mintWithTokenURI(address,uint256,string) 50bb4e7f235	// Selector: mintWithTokenURI(address,uint256,string) 50bb4e7f
165	function mintWithTokenURI(236	function mintWithTokenURI(
168		string memory tokenUri239		string memory tokenUri
169	) external returns (bool);240	) external returns (bool);
170241
171	// Not implemented242	// @dev Not implemented
172	//243	//
173	// Selector: finishMinting() 7d64bcb4244	// Selector: finishMinting() 7d64bcb4
174	function finishMinting() external returns (bool);245	function finishMinting() external returns (bool);
175}246}
176247
177// Selector: 780e9d63248// Selector: 780e9d63
178interface ERC721Enumerable is Dummy, ERC165 {249interface ERC721Enumerable is Dummy, ERC165 {
250	// @notice Enumerate valid NFTs
251	// @dev Throws if `index` >= `totalSupply()`.
252	// @param index A counter less than `totalSupply()`
253	// @return The token identifier for the `index`th NFT,
254	//  (sort order not specified)
255	//
179	// Selector: tokenByIndex(uint256) 4f6ccce7256	// Selector: tokenByIndex(uint256) 4f6ccce7
180	function tokenByIndex(uint256 index) external view returns (uint256);257	function tokenByIndex(uint256 index) external view returns (uint256);
181258
182	// Not implemented259	// @dev Not implemented
183	//260	//
184	// Selector: tokenOfOwnerByIndex(address,uint256) 2f745c59261	// Selector: tokenOfOwnerByIndex(address,uint256) 2f745c59
185	function tokenOfOwnerByIndex(address owner, uint256 index)262	function tokenOfOwnerByIndex(address owner, uint256 index)
186		external263		external
187		view264		view
188		returns (uint256);265		returns (uint256);
189266
267	// @notice Count NFTs tracked by this contract
268	// @return A count of valid NFTs tracked by this contract, where each one of
269	//  them has an assigned and queryable owner not equal to the zero address
270	//
190	// Selector: totalSupply() 18160ddd271	// Selector: totalSupply() 18160ddd
191	function totalSupply() external view returns (uint256);272	function totalSupply() external view returns (uint256);
192}273}
257338
258// Selector: d74d154f339// Selector: d74d154f
259interface ERC721UniqueExtensions is Dummy, ERC165 {340interface ERC721UniqueExtensions is Dummy, ERC165 {
341	// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE
342	//  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE
343	//  THEY MAY BE PERMANENTLY LOST
344	// @dev Throws unless `msg.sender` is the current owner. Throws if `to`
345	//  is the zero address. Throws if `tokenId` is not a valid NFT.
346	// @param to The new owner
347	// @param tokenId The NFT to transfer
348	// @param _value Not used for an NFT
349	//
260	// Selector: transfer(address,uint256) a9059cbb350	// Selector: transfer(address,uint256) a9059cbb
261	function transfer(address to, uint256 tokenId) external;351	function transfer(address to, uint256 tokenId) external;
262352
353	// @notice Burns a specific ERC721 token.
354	// @dev Throws unless `msg.sender` is the current owner or an authorized
355	//  operator for this NFT. Throws if `from` is not the current owner. Throws
356	//  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.
357	// @param from The current owner of the NFT
358	// @param tokenId The NFT to transfer
359	// @param _value Not used for an NFT
360	//
263	// Selector: burnFrom(address,uint256) 79cc6790361	// Selector: burnFrom(address,uint256) 79cc6790
264	function burnFrom(address from, uint256 tokenId) external;362	function burnFrom(address from, uint256 tokenId) external;
265363
364	// @notice Returns next free NFT ID.
365	//
266	// Selector: nextTokenId() 75794a3c366	// Selector: nextTokenId() 75794a3c
267	function nextTokenId() external view returns (uint256);367	function nextTokenId() external view returns (uint256);
268368
369	// @notice Function to mint multiple tokens.
370	// @dev `tokenIds` should be an array of consecutive numbers and first number
371	//  should be obtained with `nextTokenId` method
372	// @param to The new owner
373	// @param tokenIds IDs of the minted NFTs
374	//
269	// Selector: mintBulk(address,uint256[]) 44a9945e375	// Selector: mintBulk(address,uint256[]) 44a9945e
270	function mintBulk(address to, uint256[] memory tokenIds)376	function mintBulk(address to, uint256[] memory tokenIds)
271		external377		external
272		returns (bool);378		returns (bool);
273379
380	// @notice Function to mint multiple tokens with the given tokenUris.
381	// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive
382	//  numbers and first number should be obtained with `nextTokenId` method
383	// @param to The new owner
384	// @param tokens array of pairs of token ID and token URI for minted tokens
385	//
274	// Selector: mintBulkWithTokenURI(address,(uint256,string)[]) 36543006386	// Selector: mintBulkWithTokenURI(address,(uint256,string)[]) 36543006
275	function mintBulkWithTokenURI(address to, Tuple0[] memory tokens)387	function mintBulkWithTokenURI(address to, Tuple0[] memory tokens)
276		external388		external