`069b0ad95761`

4 files changed

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

14// You should have received a copy of the GNU General Public License14// You should have received a copy of the GNU General Public License
15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
16
17//! # Nonfungible Pallet EVM API
18//! 
19//! Provides ERC-721 standart support implementation and EVM API for unique extensions for Nonfungible Pallet.
20//! Method implementations are mostly doing parameter conversion and calling Nonfungible Pallet methods.
1621
17extern crate alloc;22extern crate alloc;
18use core::{23use core::{
40	SelfWeightOf, weights::WeightInfo, TokenProperties,45	SelfWeightOf, weights::WeightInfo, TokenProperties,
41};46};
4247
48/// @title A contract that allows to set and delete token properties and change token property permissions.
49/// 
43#[solidity_interface(name = "TokenProperties")]50#[solidity_interface(name = "TokenProperties")]
44impl<T: Config> NonfungibleHandle<T> {51impl<T: Config> NonfungibleHandle<T> {
52	/// @notice Set permissions for token property.
53	/// @dev Throws error if `msg.sender` is not admin or owner of the collection.
54	/// @param key Property key.
55	/// @param is_mutable Permission to mutate property.
56	/// @param collection_admin Permission to mutate property by collection admin if property is mutable.
57	/// @param token_owner Permission to mutate property by token owner if property is mutable.
45	fn set_token_property_permission(58	fn set_token_property_permission(
46		&mut self,59		&mut self,
47		caller: caller,60		caller: caller,
68		.map_err(dispatch_to_evm::<T>)81		.map_err(dispatch_to_evm::<T>)
69	}82	}
7083
84	/// @notice Set token property value.
85	/// @dev Throws error if `msg.sender` has no permission to edit the property.
86	/// @param tokenId ID of the token.
87	/// @param key Property key.
88	/// @param value Property value.
71	fn set_property(89	fn set_property(
72		&mut self,90		&mut self,
73		caller: caller,91		caller: caller,
96		.map_err(dispatch_to_evm::<T>)114		.map_err(dispatch_to_evm::<T>)
97	}115	}
98116
117	/// @notice Delete token property value.
118	/// @dev Throws error if `msg.sender` has no permission to edit the property.
119	/// @param tokenId ID of the token.
120	/// @param key Property key.
99	fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {121	fn delete_property(&mut self, token_id: uint256, caller: caller, key: string) -> Result<()> {
100		let caller = T::CrossAccountId::from_eth(caller);122		let caller = T::CrossAccountId::from_eth(caller);
101		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;123		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
111			.map_err(dispatch_to_evm::<T>)133			.map_err(dispatch_to_evm::<T>)
112	}134	}
113135
136	/// @notice Get token property value.
114	/// Throws error if key not found137	/// @dev Throws error if key not found
138	/// @param tokenId ID of the token.
139	/// @param key Property key.
115	fn property(&self, token_id: uint256, key: string) -> Result<bytes> {140	fn property(&self, token_id: uint256, key: string) -> Result<bytes> {
116		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;141		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
117		let key = <Vec<u8>>::from(key)142		let key = <Vec<u8>>::from(key)
127152
128#[derive(ToLog)]153#[derive(ToLog)]
129pub enum ERC721Events {154pub enum ERC721Events {
155	/// @dev This emits when ownership of any NFT changes by any mechanism.
156	///  This event emits when NFTs are created (`from` == 0) and destroyed
157	///  (`to` == 0). Exception: during contract creation, any number of NFTs
158	///  may be created and assigned without emitting Transfer. At the time of
159	///  any transfer, the approved address for that NFT (if any) is reset to none.
130	Transfer {160	Transfer {
131		#[indexed]161		#[indexed]
132		from: address,162		from: address,
135		#[indexed]165		#[indexed]
136		token_id: uint256,166		token_id: uint256,
137	},167	},
168	/// @dev This emits when the approved address for an NFT is changed or
169	///  reaffirmed. The zero address indicates there is no approved address.
170	///  When a Transfer event emits, this also indicates that the approved
171	///  address for that NFT (if any) is reset to none.
138	Approval {172	Approval {
139		#[indexed]173		#[indexed]
140		owner: address,174		owner: address,
143		#[indexed]177		#[indexed]
144		token_id: uint256,178		token_id: uint256,
145	},179	},
180	/// @dev This emits when an operator is enabled or disabled for an owner.
181	///  The operator can manage all NFTs of the owner.
146	#[allow(dead_code)]182	#[allow(dead_code)]
147	ApprovalForAll {183	ApprovalForAll {
148		#[indexed]184		#[indexed]
159	MintingFinished {},195	MintingFinished {},
160}196}
161197
198/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension
199/// @dev See https://eips.ethereum.org/EIPS/eip-721
162#[solidity_interface(name = "ERC721Metadata")]200#[solidity_interface(name = "ERC721Metadata")]
163impl<T: Config> NonfungibleHandle<T> {201impl<T: Config> NonfungibleHandle<T> {
202	/// @notice A descriptive name for a collection of NFTs in this contract
164	fn name(&self) -> Result<string> {203	fn name(&self) -> Result<string> {
165		Ok(decode_utf16(self.name.iter().copied())204		Ok(decode_utf16(self.name.iter().copied())
166			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))205			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))
167			.collect::<string>())206			.collect::<string>())
168	}207	}
169208
209	/// @notice An abbreviated name for NFTs in this contract
170	fn symbol(&self) -> Result<string> {210	fn symbol(&self) -> Result<string> {
171		Ok(string::from_utf8_lossy(&self.token_prefix).into())211		Ok(string::from_utf8_lossy(&self.token_prefix).into())
172	}212	}
173213
214	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.
215    /// @dev Throws if `tokenId` is not a valid NFT. URIs are defined in RFC
216    ///  3986. The URI may point to a JSON file that conforms to the "ERC721
217    ///  Metadata JSON Schema".
174	/// Returns token's const_metadata218	/// @return token's const_metadata
175	#[solidity(rename_selector = "tokenURI")]219	#[solidity(rename_selector = "tokenURI")]
176	fn token_uri(&self, token_id: uint256) -> Result<string> {220	fn token_uri(&self, token_id: uint256) -> Result<string> {
177		let key = token_uri_key();221		let key = token_uri_key();
192	}236	}
193}237}
194238
239/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
240/// @dev See https://eips.ethereum.org/EIPS/eip-721
195#[solidity_interface(name = "ERC721Enumerable")]241#[solidity_interface(name = "ERC721Enumerable")]
196impl<T: Config> NonfungibleHandle<T> {242impl<T: Config> NonfungibleHandle<T> {
243	/// @notice Enumerate valid NFTs
244    /// @param index A counter less than `totalSupply()`
245    /// @return The token identifier for the `index`th NFT,
246    ///  (sort order not specified)
197	fn token_by_index(&self, index: uint256) -> Result<uint256> {247	fn token_by_index(&self, index: uint256) -> Result<uint256> {
198		Ok(index)248		Ok(index)
199	}249	}
200250
201	/// Not implemented251	/// @dev Not implemented
202	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {252	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {
203		// TODO: Not implemetable253		// TODO: Not implemetable
204		Err("not implemented".into())254		Err("not implemented".into())
205	}255	}
206256
257	/// @notice Count NFTs tracked by this contract
258    /// @return A count of valid NFTs tracked by this contract, where each one of
259    ///  them has an assigned and queryable owner not equal to the zero address
207	fn total_supply(&self) -> Result<uint256> {260	fn total_supply(&self) -> Result<uint256> {
208		self.consume_store_reads(1)?;261		self.consume_store_reads(1)?;
209		Ok(<Pallet<T>>::total_supply(self).into())262		Ok(<Pallet<T>>::total_supply(self).into())
210	}263	}
211}264}
212265
266/// @title ERC-721 Non-Fungible Token Standard
267/// @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
213#[solidity_interface(name = "ERC721", events(ERC721Events))]268#[solidity_interface(name = "ERC721", events(ERC721Events))]
214impl<T: Config> NonfungibleHandle<T> {269impl<T: Config> NonfungibleHandle<T> {
270	/// @notice Count all NFTs assigned to an owner
271	/// @dev NFTs assigned to the zero address are considered invalid, and this
272	///  function throws for queries about the zero address.
273	/// @param owner An address for whom to query the balance
274	/// @return The number of NFTs owned by `owner`, possibly zero
215	fn balance_of(&self, owner: address) -> Result<uint256> {275	fn balance_of(&self, owner: address) -> Result<uint256> {
216		self.consume_store_reads(1)?;276		self.consume_store_reads(1)?;
217		let owner = T::CrossAccountId::from_eth(owner);277		let owner = T::CrossAccountId::from_eth(owner);
218		let balance = <AccountBalance<T>>::get((self.id, owner));278		let balance = <AccountBalance<T>>::get((self.id, owner));
219		Ok(balance.into())279		Ok(balance.into())
220	}280	}
281	/// @notice Find the owner of an NFT
282	/// @dev NFTs assigned to zero address are considered invalid, and queries
283	///  about them do throw.
284	/// @param tokenId The identifier for an NFT
285	/// @return The address of the owner of the NFT
221	fn owner_of(&self, token_id: uint256) -> Result<address> {286	fn owner_of(&self, token_id: uint256) -> Result<address> {
222		self.consume_store_reads(1)?;287		self.consume_store_reads(1)?;
223		let token: TokenId = token_id.try_into()?;288		let token: TokenId = token_id.try_into()?;
226			.owner291			.owner
227			.as_eth())292			.as_eth())
228	}293	}
229	/// Not implemented294	/// @dev Not implemented
230	fn safe_transfer_from_with_data(295	fn safe_transfer_from_with_data(
231		&mut self,296		&mut self,
232		_from: address,297		_from: address,
238		// TODO: Not implemetable303		// TODO: Not implemetable
239		Err("not implemented".into())304		Err("not implemented".into())
240	}305	}
241	/// Not implemented306	/// @dev Not implemented
242	fn safe_transfer_from(307	fn safe_transfer_from(
243		&mut self,308		&mut self,
244		_from: address,309		_from: address,
250		Err("not implemented".into())315		Err("not implemented".into())
251	}316	}
252317
318	/// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE
319	///  TO CONFIRM THAT `to` IS CAPABLE OF RECEIVING NFTS OR ELSE
320	///  THEY MAY BE PERMANENTLY LOST
321	/// @dev Throws unless `msg.sender` is the current owner or an authorized
322	///  operator for this NFT. Throws if `from` is not the current owner. Throws
323	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.
324	/// @param from The current owner of the NFT
325	/// @param to The new owner
326	/// @param tokenId The NFT to transfer
327	/// @param _value Not used for an NFT
253	#[weight(<SelfWeightOf<T>>::transfer_from())]328	#[weight(<SelfWeightOf<T>>::transfer_from())]
254	fn transfer_from(329	fn transfer_from(
255		&mut self,330		&mut self,
272		Ok(())347		Ok(())
273	}348	}
274349
350	/// @notice Set or reaffirm the approved address for an NFT
351	/// @dev The zero address indicates there is no approved address.
352	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized
353	///  operator of the current owner.
354	/// @param approved The new approved NFT controller
355	/// @param tokenId The NFT to approve
275	#[weight(<SelfWeightOf<T>>::approve())]356	#[weight(<SelfWeightOf<T>>::approve())]
276	fn approve(357	fn approve(
277		&mut self,358		&mut self,
289		Ok(())370		Ok(())
290	}371	}
291372
292	/// Not implemented373	/// @dev Not implemented
293	fn set_approval_for_all(374	fn set_approval_for_all(
294		&mut self,375		&mut self,
295		_caller: caller,376		_caller: caller,
300		Err("not implemented".into())381		Err("not implemented".into())
301	}382	}
302383
303	/// Not implemented384	/// @dev Not implemented
304	fn get_approved(&self, _token_id: uint256) -> Result<address> {385	fn get_approved(&self, _token_id: uint256) -> Result<address> {
305		// TODO: Not implemetable386		// TODO: Not implemetable
306		Err("not implemented".into())387		Err("not implemented".into())
307	}388	}
308389
309	/// Not implemented390	/// @dev Not implemented
310	fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {391	fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {
311		// TODO: Not implemetable392		// TODO: Not implemetable
312		Err("not implemented".into())393		Err("not implemented".into())
313	}394	}
314}395}
315396
397/// @title ERC721 Token that can be irreversibly burned (destroyed).
316#[solidity_interface(name = "ERC721Burnable")]398#[solidity_interface(name = "ERC721Burnable")]
317impl<T: Config> NonfungibleHandle<T> {399impl<T: Config> NonfungibleHandle<T> {
400	/// @notice Burns a specific ERC721 token.
401	/// @dev Throws unless `msg.sender` is the current NFT owner, or an authorized
402	///  operator of the current owner.
403	/// @param tokenId The NFT to approve
318	#[weight(<SelfWeightOf<T>>::burn_item())]404	#[weight(<SelfWeightOf<T>>::burn_item())]
319	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {405	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {
320		let caller = T::CrossAccountId::from_eth(caller);406		let caller = T::CrossAccountId::from_eth(caller);
325	}411	}
326}412}
327413
414/// @title ERC721 minting logic.
328#[solidity_interface(name = "ERC721Mintable", events(ERC721MintableEvents))]415#[solidity_interface(name = "ERC721Mintable", events(ERC721MintableEvents))]
329impl<T: Config> NonfungibleHandle<T> {416impl<T: Config> NonfungibleHandle<T> {
330	fn minting_finished(&self) -> Result<bool> {417	fn minting_finished(&self) -> Result<bool> {
331		Ok(false)418		Ok(false)
332	}419	}
333420
421	/// @notice Function to mint token.
334	/// `token_id` should be obtained with `next_token_id` method,422	/// @dev `tokenId` should be obtained with `nextTokenId` method,
335	/// unlike standard, you can't specify it manually423	///  unlike standard, you can't specify it manually
424	/// @param to The new owner
425	/// @param tokenId ID of the minted NFT
336	#[weight(<SelfWeightOf<T>>::create_item())]426	#[weight(<SelfWeightOf<T>>::create_item())]
337	fn mint(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {427	fn mint(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {
338		let caller = T::CrossAccountId::from_eth(caller);428		let caller = T::CrossAccountId::from_eth(caller);
364		Ok(true)454		Ok(true)
365	}455	}
366456
457	/// @notice Function to mint token with the given tokenUri.
367	/// `token_id` should be obtained with `next_token_id` method,458	/// @dev `tokenId` should be obtained with `nextTokenId` method,
368	/// unlike standard, you can't specify it manually459	///  unlike standard, you can't specify it manually
460	/// @param to The new owner
461	/// @param tokenId ID of the minted NFT
462	/// @param tokenUri Token URI that would be stored in the NFT properties
369	#[solidity(rename_selector = "mintWithTokenURI")]463	#[solidity(rename_selector = "mintWithTokenURI")]
370	#[weight(<SelfWeightOf<T>>::create_item())]464	#[weight(<SelfWeightOf<T>>::create_item())]
371	fn mint_with_token_uri(465	fn mint_with_token_uri(
420		Ok(true)514		Ok(true)
421	}515	}
422516
423	/// Not implemented517	/// @dev Not implemented
424	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {518	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {
425		Err("not implementable".into())519		Err("not implementable".into())
426	}520	}
449	false543	false
450}544}
451545
546/// @title Unique extensions for ERC721.
452#[solidity_interface(name = "ERC721UniqueExtensions")]547#[solidity_interface(name = "ERC721UniqueExtensions")]
453impl<T: Config> NonfungibleHandle<T> {548impl<T: Config> NonfungibleHandle<T> {
549	/// @notice Transfer ownership of an NFT
550	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`
551	///  is the zero address. Throws if `tokenId` is not a valid NFT.
552	/// @param to The new owner
553	/// @param tokenId The NFT to transfer
554	/// @param _value Not used for an NFT
454	#[weight(<SelfWeightOf<T>>::transfer())]555	#[weight(<SelfWeightOf<T>>::transfer())]
455	fn transfer(556	fn transfer(
456		&mut self,557		&mut self,
470		Ok(())571		Ok(())
471	}572	}
472573
574	/// @notice Burns a specific ERC721 token.
575	/// @dev Throws unless `msg.sender` is the current owner or an authorized
576	///  operator for this NFT. Throws if `from` is not the current owner. Throws
577	///  if `to` is the zero address. Throws if `tokenId` is not a valid NFT.
578	/// @param from The current owner of the NFT
579	/// @param tokenId The NFT to transfer
580	/// @param _value Not used for an NFT
473	#[weight(<SelfWeightOf<T>>::burn_from())]581	#[weight(<SelfWeightOf<T>>::burn_from())]
474	fn burn_from(582	fn burn_from(
475		&mut self,583		&mut self,
490		Ok(())598		Ok(())
491	}599	}
492600
601	/// @notice Returns next free NFT ID.
493	fn next_token_id(&self) -> Result<uint256> {602	fn next_token_id(&self) -> Result<uint256> {
494		self.consume_store_reads(1)?;603		self.consume_store_reads(1)?;
495		Ok(<TokensMinted<T>>::get(self.id)604		Ok(<TokensMinted<T>>::get(self.id)
498			.into())607			.into())
499	}608	}
500609
610	/// @notice Function to mint multiple tokens.
611	/// @dev `tokenIds` should be an array of consecutive numbers and first number
612	///  should be obtained with `nextTokenId` method
613	/// @param to The new owner
614	/// @param tokenIds IDs of the minted NFTs
501	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]615	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]
502	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {616	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {
503		let caller = T::CrossAccountId::from_eth(caller);617		let caller = T::CrossAccountId::from_eth(caller);
529		Ok(true)643		Ok(true)
530	}644	}
531645
646	/// @notice Function to mint multiple tokens with the given tokenUris.
647	/// @dev `tokenIds` is array of pairs of token ID and token URI. Token IDs should be consecutive
648	///  numbers and first number should be obtained with `nextTokenId` method
649	/// @param to The new owner
650	/// @param tokens array of pairs of token ID and token URI for minted tokens
532	#[solidity(rename_selector = "mintBulkWithTokenURI")]651	#[solidity(rename_selector = "mintBulkWithTokenURI")]
533	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]652	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]
534	fn mint_bulk_with_token_uri(653	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

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.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