git.delta.rocks / unique-network / refs/commits / 069b0ad95761

difftreelog

doc: add documentstion for nonfungible EVM API

Grigoriy Simonov2022-07-21parent: #665fb9f.patch.diff
in: master

4 files changed

modifiedpallets/nonfungible/src/erc.rsdiffbeforeafterboth
--- 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.rawdiffbeforeafterboth

binary blob — no preview

modifiedpallets/nonfungible/src/stubs/UniqueNFT.soldiffbeforeafterboth
5353
54// Selector: 4136937754// Selector: 41369377
55contract TokenProperties is Dummy, ERC165 {55contract TokenProperties is Dummy, ERC165 {
56	// @notice Set permissions for token property.
57	// @dev Throws error if `msg.sender` is not admin or owner of the collection.
58	// @param key Property key.
59	// @param is_mutable Permission to mutate property.
60	// @param collection_admin Permission to mutate property by collection admin if property is mutable.
61	// @param token_owner Permission to mutate property by token owner if property is mutable.
62	//
56	// Selector: setTokenPropertyPermission(string,bool,bool,bool) 222d97fa63	// Selector: setTokenPropertyPermission(string,bool,bool,bool) 222d97fa
57	function setTokenPropertyPermission(64	function setTokenPropertyPermission(
58		string memory key,65		string memory key,
68		dummy = 0;75		dummy = 0;
69	}76	}
7077
78	// @notice Set token property value.
79	// @dev Throws error if `msg.sender` has no permission to edit the property.
80	// @param token_id ID of the token.
81	// @param key Property key.
82	// @param value Property value.
83	//
71	// Selector: setProperty(uint256,string,bytes) 1752d67b84	// Selector: setProperty(uint256,string,bytes) 1752d67b
72	function setProperty(85	function setProperty(
73		uint256 tokenId,86		uint256 tokenId,
81		dummy = 0;94		dummy = 0;
82	}95	}
8396
97	// @notice Delete token property value.
98	// @dev Throws error if `msg.sender` has no permission to edit the property.
99	// @param token_id ID of the token.
100	// @param key Property key.
101	//
84	// Selector: deleteProperty(uint256,string) 066111d1102	// Selector: deleteProperty(uint256,string) 066111d1
85	function deleteProperty(uint256 tokenId, string memory key) public {103	function deleteProperty(uint256 tokenId, string memory key) public {
86		require(false, stub_error);104		require(false, stub_error);
89		dummy = 0;107		dummy = 0;
90	}108	}
91109
110	// @notice Get token property value.
92	// Throws error if key not found111	// @dev Throws error if key not found
112	// @param token_id ID of the token.
113	// @param key Property key.
93	//114	//
94	// Selector: property(uint256,string) 7228c327115	// Selector: property(uint256,string) 7228c327
95	function property(uint256 tokenId, string memory key)116	function property(uint256 tokenId, string memory key)
107128
108// Selector: 42966c68129// Selector: 42966c68
109contract ERC721Burnable is Dummy, ERC165 {130contract ERC721Burnable is Dummy, ERC165 {
131	// @notice Burns a specific ERC721 token.
132	// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized
133	//  operator of the current owner.
134	// @param tokenId The NFT to approve
135	//
110	// Selector: burn(uint256) 42966c68136	// Selector: burn(uint256) 42966c68
111	function burn(uint256 tokenId) public {137	function burn(uint256 tokenId) public {
112		require(false, stub_error);138		require(false, stub_error);
117143
118// Selector: 58800161144// Selector: 58800161
119contract ERC721 is Dummy, ERC165, ERC721Events {145contract ERC721 is Dummy, ERC165, ERC721Events {
146	// @notice Count all NFTs assigned to an owner
147	// @dev NFTs assigned to the zero address are considered invalid, and this
148	//  function throws for queries about the zero address.
149	// @param _owner An address for whom to query the balance
150	// @return The number of NFTs owned by `_owner`, possibly zero
151	//
120	// Selector: balanceOf(address) 70a08231152	// Selector: balanceOf(address) 70a08231
121	function balanceOf(address owner) public view returns (uint256) {153	function balanceOf(address owner) public view returns (uint256) {
122		require(false, stub_error);154		require(false, stub_error);
125		return 0;157		return 0;
126	}158	}
127159
160	// @notice Find the owner of an NFT
161	// @dev NFTs assigned to zero address are considered invalid, and queries
162	//  about them do throw.
163	// @param _tokenId The identifier for an NFT
164	// @return The address of the owner of the NFT
165	//
128	// Selector: ownerOf(uint256) 6352211e166	// Selector: ownerOf(uint256) 6352211e
129	function ownerOf(uint256 tokenId) public view returns (address) {167	function ownerOf(uint256 tokenId) public view returns (address) {
130		require(false, stub_error);168		require(false, stub_error);
133		return 0x0000000000000000000000000000000000000000;171		return 0x0000000000000000000000000000000000000000;
134	}172	}
135173
136	// Not implemented174	// @dev Not implemented
137	//175	//
138	// Selector: safeTransferFromWithData(address,address,uint256,bytes) 60a11672176	// Selector: safeTransferFromWithData(address,address,uint256,bytes) 60a11672
139	function safeTransferFromWithData(177	function safeTransferFromWithData(
150		dummy = 0;188		dummy = 0;
151	}189	}
152190
153	// Not implemented191	// @dev Not implemented
154	//192	//
155	// Selector: safeTransferFrom(address,address,uint256) 42842e0e193	// Selector: safeTransferFrom(address,address,uint256) 42842e0e
156	function safeTransferFrom(194	function safeTransferFrom(
165		dummy = 0;203		dummy = 0;
166	}204	}
167205
206	// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE
207	//  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE
208	//  THEY MAY BE PERMANENTLY LOST
209	// @dev Throws unless `msg.sender` is the current owner or an authorized
210	//  operator for this NFT. Throws if `from` is not the current owner. Throws
211	//  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.
212	// @param from The current owner of the NFT
213	// @param to The new owner
214	// @param tokenId The NFT to transfer
215	// @param _value Not used for an NFT
216	//
168	// Selector: transferFrom(address,address,uint256) 23b872dd217	// Selector: transferFrom(address,address,uint256) 23b872dd
169	function transferFrom(218	function transferFrom(
170		address from,219		address from,
178		dummy = 0;227		dummy = 0;
179	}228	}
180229
230	// @notice Set or reaffirm the approved address for an NFT
231	// @dev The zero address indicates there is no approved address.
232	// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized
233	//  operator of the current owner.
234	// @param approved The new approved NFT controller
235	// @param tokenId The NFT to approve
236	//
181	// Selector: approve(address,uint256) 095ea7b3237	// Selector: approve(address,uint256) 095ea7b3
182	function approve(address approved, uint256 tokenId) public {238	function approve(address approved, uint256 tokenId) public {
183		require(false, stub_error);239		require(false, stub_error);
186		dummy = 0;242		dummy = 0;
187	}243	}
188244
189	// Not implemented245	// @dev Not implemented
190	//246	//
191	// Selector: setApprovalForAll(address,bool) a22cb465247	// Selector: setApprovalForAll(address,bool) a22cb465
192	function setApprovalForAll(address operator, bool approved) public {248	function setApprovalForAll(address operator, bool approved) public {
196		dummy = 0;252		dummy = 0;
197	}253	}
198254
199	// Not implemented255	// @dev Not implemented
200	//256	//
201	// Selector: getApproved(uint256) 081812fc257	// Selector: getApproved(uint256) 081812fc
202	function getApproved(uint256 tokenId) public view returns (address) {258	function getApproved(uint256 tokenId) public view returns (address) {
206		return 0x0000000000000000000000000000000000000000;262		return 0x0000000000000000000000000000000000000000;
207	}263	}
208264
209	// Not implemented265	// @dev Not implemented
210	//266	//
211	// Selector: isApprovedForAll(address,address) e985e9c5267	// Selector: isApprovedForAll(address,address) e985e9c5
212	function isApprovedForAll(address owner, address operator)268	function isApprovedForAll(address owner, address operator)
224280
225// Selector: 5b5e139f281// Selector: 5b5e139f
226contract ERC721Metadata is Dummy, ERC165 {282contract ERC721Metadata is Dummy, ERC165 {
283	// @notice A descriptive name for a collection of NFTs in this contract
284	//
227	// Selector: name() 06fdde03285	// Selector: name() 06fdde03
228	function name() public view returns (string memory) {286	function name() public view returns (string memory) {
229		require(false, stub_error);287		require(false, stub_error);
230		dummy;288		dummy;
231		return "";289		return "";
232	}290	}
233291
292	// @notice An abbreviated name for NFTs in this contract
293	//
234	// Selector: symbol() 95d89b41294	// Selector: symbol() 95d89b41
235	function symbol() public view returns (string memory) {295	function symbol() public view returns (string memory) {
236		require(false, stub_error);296		require(false, stub_error);
237		dummy;297		dummy;
238		return "";298		return "";
239	}299	}
240300
301	// @notice A distinct Uniform Resource Identifier (URI) for a given asset.
302	// @dev Throws if `tokenId` is not a valid NFT. URIs are defined in RFC
303	//  3986. The URI may point to a JSON file that conforms to the "ERC721
304	//  Metadata JSON Schema".
241	// Returns token's const_metadata305	// @return token's const_metadata
242	//306	//
243	// Selector: tokenURI(uint256) c87b56dd307	// Selector: tokenURI(uint256) c87b56dd
244	function tokenURI(uint256 tokenId) public view returns (string memory) {308	function tokenURI(uint256 tokenId) public view returns (string memory) {
258		return false;322		return false;
259	}323	}
260324
325	// @notice Function to mint token.
261	// `token_id` should be obtained with `next_token_id` method,326	// @dev `tokenId` should be obtained with `nextTokenId` method,
262	// unlike standard, you can't specify it manually327	//  unlike standard, you can't specify it manually
328	// @param to The new owner
329	// @param tokenId ID of the minted NFT
263	//330	//
264	// Selector: mint(address,uint256) 40c10f19331	// Selector: mint(address,uint256) 40c10f19
265	function mint(address to, uint256 tokenId) public returns (bool) {332	function mint(address to, uint256 tokenId) public returns (bool) {
270		return false;337		return false;
271	}338	}
272339
340	// @notice Function to mint token with the given tokenUri.
273	// `token_id` should be obtained with `next_token_id` method,341	// @dev `tokenId` should be obtained with `nextTokenId` method,
274	// unlike standard, you can't specify it manually342	//  unlike standard, you can't specify it manually
343	// @param to The new owner
344	// @param tokenId ID of the minted NFT
345	// @param tokenUri Token URI that would be stored in the NFT properties
275	//346	//
276	// Selector: mintWithTokenURI(address,uint256,string) 50bb4e7f347	// Selector: mintWithTokenURI(address,uint256,string) 50bb4e7f
277	function mintWithTokenURI(348	function mintWithTokenURI(
287		return false;358		return false;
288	}359	}
289360
290	// Not implemented361	// @dev Not implemented
291	//362	//
292	// Selector: finishMinting() 7d64bcb4363	// Selector: finishMinting() 7d64bcb4
293	function finishMinting() public returns (bool) {364	function finishMinting() public returns (bool) {
299370
300// Selector: 780e9d63371// Selector: 780e9d63
301contract ERC721Enumerable is Dummy, ERC165 {372contract ERC721Enumerable is Dummy, ERC165 {
373	// @notice Enumerate valid NFTs
374	// @dev Throws if `index` >= `totalSupply()`.
375	// @param index A counter less than `totalSupply()`
376	// @return The token identifier for the `index`th NFT,
377	//  (sort order not specified)
378	//
302	// Selector: tokenByIndex(uint256) 4f6ccce7379	// Selector: tokenByIndex(uint256) 4f6ccce7
303	function tokenByIndex(uint256 index) public view returns (uint256) {380	function tokenByIndex(uint256 index) public view returns (uint256) {
304		require(false, stub_error);381		require(false, stub_error);
307		return 0;384		return 0;
308	}385	}
309386
310	// Not implemented387	// @dev Not implemented
311	//388	//
312	// Selector: tokenOfOwnerByIndex(address,uint256) 2f745c59389	// Selector: tokenOfOwnerByIndex(address,uint256) 2f745c59
313	function tokenOfOwnerByIndex(address owner, uint256 index)390	function tokenOfOwnerByIndex(address owner, uint256 index)
322		return 0;399		return 0;
323	}400	}
324401
402	// @notice Count NFTs tracked by this contract
403	// @return A count of valid NFTs tracked by this contract, where each one of
404	//  them has an assigned and queryable owner not equal to the zero address
405	//
325	// Selector: totalSupply() 18160ddd406	// Selector: totalSupply() 18160ddd
326	function totalSupply() public view returns (uint256) {407	function totalSupply() public view returns (uint256) {
327		require(false, stub_error);408		require(false, stub_error);
475556
476// Selector: d74d154f557// Selector: d74d154f
477contract ERC721UniqueExtensions is Dummy, ERC165 {558contract ERC721UniqueExtensions is Dummy, ERC165 {
559	// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE
560	//  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE
561	//  THEY MAY BE PERMANENTLY LOST
562	// @dev Throws unless `msg.sender` is the current owner. Throws if `to`
563	//  is the zero address. Throws if `tokenId` is not a valid NFT.
564	// @param to The new owner
565	// @param tokenId The NFT to transfer
566	// @param _value Not used for an NFT
567	//
478	// Selector: transfer(address,uint256) a9059cbb568	// Selector: transfer(address,uint256) a9059cbb
479	function transfer(address to, uint256 tokenId) public {569	function transfer(address to, uint256 tokenId) public {
480		require(false, stub_error);570		require(false, stub_error);
483		dummy = 0;573		dummy = 0;
484	}574	}
485575
576	// @notice Burns a specific ERC721 token.
577	// @dev Throws unless `msg.sender` is the current owner or an authorized
578	//  operator for this NFT. Throws if `from` is not the current owner. Throws
579	//  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.
580	// @param from The current owner of the NFT
581	// @param tokenId The NFT to transfer
582	// @param _value Not used for an NFT
583	//
486	// Selector: burnFrom(address,uint256) 79cc6790584	// Selector: burnFrom(address,uint256) 79cc6790
487	function burnFrom(address from, uint256 tokenId) public {585	function burnFrom(address from, uint256 tokenId) public {
488		require(false, stub_error);586		require(false, stub_error);
491		dummy = 0;589		dummy = 0;
492	}590	}
493591
592	// @notice Returns next free NFT ID.
593	//
494	// Selector: nextTokenId() 75794a3c594	// Selector: nextTokenId() 75794a3c
495	function nextTokenId() public view returns (uint256) {595	function nextTokenId() public view returns (uint256) {
496		require(false, stub_error);596		require(false, stub_error);
497		dummy;597		dummy;
498		return 0;598		return 0;
499	}599	}
500600
601	// @notice Function to mint multiple tokens.
602	// @dev `tokenIds` should be an array of consecutive numbers and first number
603	//  should be obtained with `nextTokenId` method
604	// @param to The new owner
605	// @param tokenIds IDs of the minted NFTs
606	//
501	// Selector: mintBulk(address,uint256[]) 44a9945e607	// Selector: mintBulk(address,uint256[]) 44a9945e
502	function mintBulk(address to, uint256[] memory tokenIds)608	function mintBulk(address to, uint256[] memory tokenIds)
503		public609		public
510		return false;616		return false;
511	}617	}
512618
619	// @notice Function to mint multiple tokens with the given tokenUris.
620	// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive
621	//  numbers and first number should be obtained with `nextTokenId` method
622	// @param to The new owner
623	// @param tokens array of pairs of token ID and token URI for minted tokens
624	//
513	// Selector: mintBulkWithTokenURI(address,(uint256,string)[]) 36543006625	// Selector: mintBulkWithTokenURI(address,(uint256,string)[]) 36543006
514	function mintBulkWithTokenURI(address to, Tuple0[] memory tokens)626	function mintBulkWithTokenURI(address to, Tuple0[] memory tokens)
515		public627		public
modifiedtests/src/eth/api/UniqueNFT.soldiffbeforeafterboth
--- a/tests/src/eth/api/UniqueNFT.sol
+++ b/tests/src/eth/api/UniqueNFT.sol
@@ -44,6 +44,13 @@
 
 // Selector: 41369377
 interface TokenProperties is Dummy, ERC165 {
+	// @notice Set permissions for token property.
+	// @dev Throws error if `msg.sender` is not admin or owner of the collection.
+	// @param key Property key.
+	// @param 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,
@@ -52,6 +59,12 @@
 		bool tokenOwner
 	) external;
 
+	// @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,
@@ -59,10 +72,18 @@
 		bytes memory value
 	) external;
 
+	// @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) external;
 
-	// 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)
@@ -73,19 +94,36 @@
 
 // Selector: 42966c68
 interface 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) external;
 }
 
 // Selector: 58800161
 interface 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) external view returns (uint256);
 
+	// @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) external view returns (address);
 
-	// Not implemented
+	// @dev Not implemented
 	//
 	// Selector: safeTransferFromWithData(address,address,uint256,bytes) 60a11672
 	function safeTransferFromWithData(
@@ -95,7 +133,7 @@
 		bytes memory data
 	) external;
 
-	// Not implemented
+	// @dev Not implemented
 	//
 	// Selector: safeTransferFrom(address,address,uint256) 42842e0e
 	function safeTransferFrom(
@@ -104,6 +142,17 @@
 		uint256 tokenId
 	) external;
 
+	// @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,
@@ -111,20 +160,27 @@
 		uint256 tokenId
 	) external;
 
+	// @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) external;
 
-	// Not implemented
+	// @dev Not implemented
 	//
 	// Selector: setApprovalForAll(address,bool) a22cb465
 	function setApprovalForAll(address operator, bool approved) external;
 
-	// Not implemented
+	// @dev Not implemented
 	//
 	// Selector: getApproved(uint256) 081812fc
 	function getApproved(uint256 tokenId) external view returns (address);
 
-	// Not implemented
+	// @dev Not implemented
 	//
 	// Selector: isApprovedForAll(address,address) e985e9c5
 	function isApprovedForAll(address owner, address operator)
@@ -135,13 +191,21 @@
 
 // Selector: 5b5e139f
 interface ERC721Metadata is Dummy, ERC165 {
+	// @notice A descriptive name for a collection of NFTs in this contract
+	//
 	// Selector: name() 06fdde03
 	function name() external view returns (string memory);
 
+	// @notice An abbreviated name for NFTs in this contract
+	//
 	// Selector: symbol() 95d89b41
 	function symbol() external view returns (string memory);
 
-	// 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) external view returns (string memory);
@@ -152,14 +216,21 @@
 	// 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
+	// @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) external returns (bool);
 
-	// `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(
@@ -168,7 +239,7 @@
 		string memory tokenUri
 	) external returns (bool);
 
-	// Not implemented
+	// @dev Not implemented
 	//
 	// Selector: finishMinting() 7d64bcb4
 	function finishMinting() external returns (bool);
@@ -176,10 +247,16 @@
 
 // Selector: 780e9d63
 interface 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) external view returns (uint256);
 
-	// Not implemented
+	// @dev Not implemented
 	//
 	// Selector: tokenOfOwnerByIndex(address,uint256) 2f745c59
 	function tokenOfOwnerByIndex(address owner, uint256 index)
@@ -187,6 +264,10 @@
 		view
 		returns (uint256);
 
+	// @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() external view returns (uint256);
 }
@@ -257,20 +338,51 @@
 
 // Selector: d74d154f
 interface 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) external;
 
+	// @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) external;
 
+	// @notice Returns next free NFT ID.
+	//
 	// Selector: nextTokenId() 75794a3c
 	function nextTokenId() external view returns (uint256);
 
+	// @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)
 		external
 		returns (bool);
 
+	// @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)
 		external