git.delta.rocks / unique-network / refs/commits / 2e3c4de7682f

11formatted=$(mktemp)11formatted=$(mktemp)
12prettier --config $PRETTIER_CONFIG $raw > $formatted12prettier --config $PRETTIER_CONFIG $raw > $formatted
13
14sed -i -E -e "s/.+\/\/ FORMATTING: FORCE NEWLINE//g" $formatted
1315
14mv $formatted $OUTPUT16mv $formatted $OUTPUT
1517

291291
292struct MethodInfo {292struct MethodInfo {
293	rename_selector: Option<String>,293	rename_selector: Option<String>,
294	hide: bool,
294}295}
295impl Parse for MethodInfo {296impl Parse for MethodInfo {
296	fn parse(input: ParseStream) -> syn::Result<Self> {297	fn parse(input: ParseStream) -> syn::Result<Self> {
297		let mut rename_selector = None;298		let mut rename_selector = None;
299		let mut hide = false;
300		while !input.is_empty() {
298		let lookahead = input.lookahead1();301			let lookahead = input.lookahead1();
299		if lookahead.peek(kw::rename_selector) {302			if lookahead.peek(kw::rename_selector) {
300			let k = input.parse::<kw::rename_selector>()?;303				let k = input.parse::<kw::rename_selector>()?;
305			{308				{
306				return Err(syn::Error::new(k.span(), "rename_selector is already set"));309					return Err(syn::Error::new(k.span(), "rename_selector is already set"));
307			}310				}
308		}311			} else if lookahead.peek(kw::hide) {
312				input.parse::<kw::hide>()?;
313				hide = true;
314			} else {
315				return Err(lookahead.error());
316			}
317
318			if input.peek(Token![,]) {
319				input.parse::<Token![,]>()?;
320			} else if !input.is_empty() {
321				return Err(syn::Error::new(input.span(), "expected end"));
322			}
323		}
309		Ok(Self { rename_selector })324		Ok(Self {
325			rename_selector,
326			hide,
327		})
310	}328	}
311}329}
548	syn::custom_keyword!(expect_selector);566	syn::custom_keyword!(expect_selector);
549567
550	syn::custom_keyword!(rename_selector);568	syn::custom_keyword!(rename_selector);
569	syn::custom_keyword!(hide);
551}570}
552571
553/// Rust methods are parsed into this structure when Solidity code is generated572/// Rust methods are parsed into this structure when Solidity code is generated
558	screaming_name: Ident,577	screaming_name: Ident,
559	selector_str: String,578	selector_str: String,
560	selector: u32,579	selector: u32,
580	hide: bool,
561	args: Vec<MethodArg>,581	args: Vec<MethodArg>,
562	has_normal_args: bool,582	has_normal_args: bool,
563	has_value_args: bool,583	has_value_args: bool,
570	fn try_from(value: &ImplItemMethod) -> syn::Result<Self> {590	fn try_from(value: &ImplItemMethod) -> syn::Result<Self> {
571		let mut info = MethodInfo {591		let mut info = MethodInfo {
572			rename_selector: None,592			rename_selector: None,
593			hide: false,
573		};594		};
574		let mut docs = Vec::new();595		let mut docs = Vec::new();
575		let mut weight = None;596		let mut weight = None;
667			screaming_name: snake_ident_to_screaming(ident),688			screaming_name: snake_ident_to_screaming(ident),
668			selector_str,689			selector_str,
669			selector,690			selector,
691			hide: info.hide,
670			args,692			args,
671			has_normal_args,693			has_normal_args,
672			has_value_args,694			has_value_args,
826		let docs = &self.docs;848		let docs = &self.docs;
827		let selector_str = &self.selector_str;849		let selector_str = &self.selector_str;
828		let selector = self.selector;850		let selector = self.selector;
851		let hide = self.hide;
829		let is_payable = self.has_value_args;852		let is_payable = self.has_value_args;
830		quote! {853		quote! {
831			SolidityFunction {854			SolidityFunction {
832				docs: &[#(#docs),*],855				docs: &[#(#docs),*],
833				selector_str: #selector_str,856				selector_str: #selector_str,
834				selector: #selector,857				selector: #selector,
858				hide: #hide,
835				name: #camel_name,859				name: #camel_name,
836				mutability: #mutability,860				mutability: #mutability,
837				is_payable: #is_payable,861				is_payable: #is_payable,

225225
226pub trait SolidityArguments {226pub trait SolidityArguments {
227	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;227	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;
228	fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result;228	fn solidity_get(&self, prefix: &str, writer: &mut impl fmt::Write) -> fmt::Result;
229	fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;229	fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;
230	fn is_empty(&self) -> bool {230	fn is_empty(&self) -> bool {
231		self.len() == 0231		self.len() == 0
248			Ok(())248			Ok(())
249		}249		}
250	}250	}
251	fn solidity_get(&self, _writer: &mut impl fmt::Write) -> fmt::Result {251	fn solidity_get(&self, _prefix: &str, _writer: &mut impl fmt::Write) -> fmt::Result {
252		Ok(())252		Ok(())
253	}253	}
254	fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {254	fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
283			Ok(())283			Ok(())
284		}284		}
285	}285	}
286	fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result {286	fn solidity_get(&self, prefix: &str, writer: &mut impl fmt::Write) -> fmt::Result {
287		writeln!(writer, "\t\t{};", self.0)287		writeln!(writer, "\t{prefix}\t{};", self.0)
288	}288	}
289	fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {289	fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
290		T::solidity_default(writer, tc)290		T::solidity_default(writer, tc)
318			Ok(())318			Ok(())
319		}319		}
320	}320	}
321	fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result {321	fn solidity_get(&self, prefix: &str, writer: &mut impl fmt::Write) -> fmt::Result {
322		writeln!(writer, "\t\t{};", self.1)322		writeln!(writer, "\t{prefix}\t{};", self.1)
323	}323	}
324	fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {324	fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
325		T::solidity_default(writer, tc)325		T::solidity_default(writer, tc)
337	fn solidity_name(&self, _writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {337	fn solidity_name(&self, _writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {
338		Ok(())338		Ok(())
339	}339	}
340	fn solidity_get(&self, _writer: &mut impl fmt::Write) -> fmt::Result {340	fn solidity_get(&self, _prefix: &str, _writer: &mut impl fmt::Write) -> fmt::Result {
341		Ok(())341		Ok(())
342	}342	}
343	fn solidity_default(&self, _writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {343	fn solidity_default(&self, _writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {
365        )* );365        )* );
366		Ok(())366		Ok(())
367	}367	}
368	fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result {368	fn solidity_get(&self, prefix: &str, writer: &mut impl fmt::Write) -> fmt::Result {
369		for_tuples!( #(369		for_tuples!( #(
370            Tuple.solidity_get(writer)?;370            Tuple.solidity_get(prefix, writer)?;
371        )* );371        )* );
372		Ok(())372		Ok(())
373	}373	}
418	pub docs: &'static [&'static str],418	pub docs: &'static [&'static str],
419	pub selector_str: &'static str,419	pub selector_str: &'static str,
420	pub selector: u32,420	pub selector: u32,
421	pub hide: bool,
421	pub name: &'static str,422	pub name: &'static str,
422	pub args: A,423	pub args: A,
423	pub result: R,424	pub result: R,
431		writer: &mut impl fmt::Write,432		writer: &mut impl fmt::Write,
432		tc: &TypeCollector,433		tc: &TypeCollector,
433	) -> fmt::Result {434	) -> fmt::Result {
435		let hide_comment = self.hide.then(|| "// ").unwrap_or("");
434		for doc in self.docs {436		for doc in self.docs {
435			writeln!(writer, "\t///{}", doc)?;437			writeln!(writer, "\t{hide_comment}///{}", doc)?;
436		}438		}
437		writeln!(439		writeln!(
438			writer,440			writer,
439			"\t/// @dev EVM selector for this function is: 0x{:0>8x},",441			"\t{hide_comment}/// @dev EVM selector for this function is: 0x{:0>8x},",
440			self.selector442			self.selector
441		)?;443		)?;
442		writeln!(writer, "\t///  or in textual repr: {}", self.selector_str)?;444		writeln!(
445			writer,
446			"\t{hide_comment}///  or in textual repr: {}",
447			self.selector_str
448		)?;
443		write!(writer, "\tfunction {}(", self.name)?;449		write!(writer, "\t{hide_comment}function {}(", self.name)?;
444		self.args.solidity_name(writer, tc)?;450		self.args.solidity_name(writer, tc)?;
445		write!(writer, ")")?;451		write!(writer, ")")?;
446		if is_impl {452		if is_impl {
463		}469		}
464		if is_impl {470		if is_impl {
465			writeln!(writer, " {{")?;471			writeln!(writer, " {{")?;
466			writeln!(writer, "\t\trequire(false, stub_error);")?;472			writeln!(writer, "\t{hide_comment}\trequire(false, stub_error);")?;
467			self.args.solidity_get(writer)?;473			self.args.solidity_get(hide_comment, writer)?;
468			match &self.mutability {474			match &self.mutability {
469				SolidityMutability::Pure => {}475				SolidityMutability::Pure => {}
470				SolidityMutability::View => writeln!(writer, "\t\tdummy;")?,476				SolidityMutability::View => writeln!(writer, "\t{hide_comment}\tdummy;")?,
471				SolidityMutability::Mutable => writeln!(writer, "\t\tdummy = 0;")?,477				SolidityMutability::Mutable => writeln!(writer, "\t{hide_comment}\tdummy = 0;")?,
472			}478			}
473			if !self.result.is_empty() {479			if !self.result.is_empty() {
474				write!(writer, "\t\treturn ")?;480				write!(writer, "\t{hide_comment}\treturn ")?;
475				self.result.solidity_default(writer, tc)?;481				self.result.solidity_default(writer, tc)?;
476				writeln!(writer, ";")?;482				writeln!(writer, ";")?;
477			}483			}
478			writeln!(writer, "\t}}")?;484			writeln!(writer, "\t{hide_comment}}}")?;
479		} else {485		} else {
480			writeln!(writer, ";")?;486			writeln!(writer, ";")?;
481		}487		}
488		if self.hide {
489			writeln!(writer, "// FORMATTING: FORCE NEWLINE")?;
490		}
482		Ok(())491		Ok(())
483	}492	}
484}493}

9	traits::Get,9	traits::Get,
10};10};
11use sp_runtime::DispatchError;11use sp_runtime::DispatchError;
12use up_data_structs::{CollectionId, CreateCollectionData};12use up_data_structs::{CollectionId, CreateCollectionData, CollectionFlags};
1313
14use crate::{pallet::Config, CommonCollectionOperations, CollectionHandle};14use crate::{pallet::Config, CommonCollectionOperations, CollectionHandle};
1515
80		sender: T::CrossAccountId,80		sender: T::CrossAccountId,
81		payer: T::CrossAccountId,81		payer: T::CrossAccountId,
82		data: CreateCollectionData<T::AccountId>,82		data: CreateCollectionData<T::AccountId>,
83		flags: CollectionFlags,
83	) -> Result<CollectionId, DispatchError>;84	) -> Result<CollectionId, DispatchError>;
8485
85	/// Delete the collection.86	/// Delete the collection.

592	///592	///
593	/// @dev Owner can be changed only by current owner593	/// @dev Owner can be changed only by current owner
594	/// @param newOwner new owner account594	/// @param newOwner new owner account
595	#[solidity(rename_selector = "changeCollectionOwner")]
595	fn set_owner(&mut self, caller: caller, new_owner: address) -> Result<void> {596	fn set_owner(&mut self, caller: caller, new_owner: address) -> Result<void> {
596		self.consume_store_writes(1)?;597		self.consume_store_writes(1)?;
597598
660	pub mod key {661	pub mod key {
661		use super::*;662		use super::*;
662
663		/// Key "schemaName".
664		pub fn schema_name() -> up_data_structs::PropertyKey {
665			property_key_from_bytes(b"schemaName").expect(EXPECT_CONVERT_ERROR)
666		}
667663
668		/// Key "baseURI".664		/// Key "baseURI".
669		pub fn base_uri() -> up_data_structs::PropertyKey {665		pub fn base_uri() -> up_data_structs::PropertyKey {
672668
673		/// Key "url".669		/// Key "url".
674		pub fn url() -> up_data_structs::PropertyKey {670		pub fn url() -> up_data_structs::PropertyKey {
675			property_key_from_bytes(b"url").expect(EXPECT_CONVERT_ERROR)671			property_key_from_bytes(b"URI").expect(EXPECT_CONVERT_ERROR)
676		}672		}
677673
678		/// Key "suffix".674		/// Key "suffix".
679		pub fn suffix() -> up_data_structs::PropertyKey {675		pub fn suffix() -> up_data_structs::PropertyKey {
680			property_key_from_bytes(b"suffix").expect(EXPECT_CONVERT_ERROR)676			property_key_from_bytes(b"URISuffix").expect(EXPECT_CONVERT_ERROR)
681		}677		}
682678
683		/// Key "parentNft".679		/// Key "parentNft".
686		}682		}
687	}683	}
688
689	/// Values.
690	pub mod value {
691		use super::*;
692
693		/// Value "ERC721Metadata".
694		pub const ERC721_METADATA: &[u8] = b"ERC721Metadata";
695
696		/// Value for [`ERC721_METADATA`].
697		pub fn erc721() -> up_data_structs::PropertyValue {
698			property_value_from_bytes(ERC721_METADATA).expect(EXPECT_CONVERT_ERROR)
699		}
700	}
701684
702	/// Convert `byte` to [`PropertyKey`].685	/// Convert `byte` to [`PropertyKey`].
703	pub fn property_key_from_bytes(bytes: &[u8]) -> Result<up_data_structs::PropertyKey> {686	pub fn property_key_from_bytes(bytes: &[u8]) -> Result<up_data_structs::PropertyKey> {

71	Collection,71	Collection,
72	RpcCollection,72	RpcCollection,
73	CollectionFlags,73	CollectionFlags,
74	RpcCollectionFlags,
74	CollectionId,75	CollectionId,
75	CreateItemData,76	CreateItemData,
76	MAX_TOKEN_PREFIX_LENGTH,77	MAX_TOKEN_PREFIX_LENGTH,
825			properties,826			properties,
826			read_only: flags.external,827			read_only: flags.external,
828
829			flags: RpcCollectionFlags {
827			foreign: flags.foreign,830				foreign: flags.foreign,
831				erc721metadata: flags.erc721metadata,
832			},
828		})833		})
829	}834	}
830}835}

binary blob — no preview

212		owner: T::CrossAccountId,212		owner: T::CrossAccountId,
213		payer: T::CrossAccountId,213		payer: T::CrossAccountId,
214		data: CreateCollectionData<T::AccountId>,214		data: CreateCollectionData<T::AccountId>,
215		flags: CollectionFlags,
215	) -> Result<CollectionId, DispatchError> {216	) -> Result<CollectionId, DispatchError> {
216		<PalletCommon<T>>::init_collection(owner, payer, data, CollectionFlags::default())217		<PalletCommon<T>>::init_collection(owner, payer, data, flags)
217	}218	}
218219
219	/// Initializes the collection with ForeignCollection flag. Returns [CollectionId] on success, [DispatchError] otherwise.220	/// Initializes the collection with ForeignCollection flag. Returns [CollectionId] on success, [DispatchError] otherwise.

binary blob — no preview

18}18}
1919
20/// @title A contract that allows you to work with collections.20/// @title A contract that allows you to work with collections.
21/// @dev the ERC-165 identifier for this interface is 0x3e1e808321/// @dev the ERC-165 identifier for this interface is 0x62e22290
22contract Collection is Dummy, ERC165 {22contract Collection is Dummy, ERC165 {
23	/// Set collection property.23	/// Set collection property.
24	///24	///
296	///296	///
297	/// @dev Owner can be changed only by current owner297	/// @dev Owner can be changed only by current owner
298	/// @param newOwner new owner account298	/// @param newOwner new owner account
299	/// @dev EVM selector for this function is: 0x13af4035,299	/// @dev EVM selector for this function is: 0x4f53e226,
300	///  or in textual repr: setOwner(address)300	///  or in textual repr: changeCollectionOwner(address)
301	function setOwner(address newOwner) public {301	function changeCollectionOwner(address newOwner) public {
302		require(false, stub_error);302		require(false, stub_error);
303		newOwner;303		newOwner;
304		dummy = 0;304		dummy = 0;

55		owner,55		owner,
56		CollectionMode::NFT,56		CollectionMode::NFT,
57		|owner: T::CrossAccountId, data| {57		|owner: T::CrossAccountId, data| {
58			<Pallet<T>>::init_collection(owner.clone(), owner, data, true)58			<Pallet<T>>::init_collection(owner.clone(), owner, data, Default::default())
59		},59		},
60		NonfungibleHandle::cast,60		NonfungibleHandle::cast,
61	)61	)

35use pallet_common::{35use pallet_common::{
36	erc::{36	erc::{CommonEvmHandler, PrecompileResult, CollectionCall, static_property::key},
37		CommonEvmHandler, PrecompileResult, CollectionCall,
38		static_property::{key, value as property_value},
39	},
40	CollectionHandle, CollectionPropertyPermissions,37	CollectionHandle, CollectionPropertyPermissions,
41};38};
42use pallet_evm::{account::CrossAccountId, PrecompileHandle};39use pallet_evm::{account::CrossAccountId, PrecompileHandle};
43use pallet_evm_coder_substrate::call;40use pallet_evm_coder_substrate::call;
44use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};41use pallet_structure::{SelfWeightOf as StructureWeight, weights::WeightInfo as _};
45use alloc::string::ToString;
4642
47use crate::{43use crate::{
48	AccountBalance, Config, CreateItemData, NonfungibleHandle, Pallet, TokenData, TokensMinted,44	AccountBalance, Config, CreateItemData, NonfungibleHandle, Pallet, TokenData, TokensMinted,
194}190}
195191
196#[derive(ToLog)]192#[derive(ToLog)]
197pub enum ERC721MintableEvents {193pub enum ERC721UniqueMintableEvents {
198	#[allow(dead_code)]194	#[allow(dead_code)]
199	MintingFinished {},195	MintingFinished {},
200}196}
204#[solidity_interface(name = ERC721Metadata, expect_selector = 0x5b5e139f)]200#[solidity_interface(name = ERC721Metadata, expect_selector = 0x5b5e139f)]
205impl<T: Config> NonfungibleHandle<T> {201impl<T: Config> NonfungibleHandle<T> {
206	/// @notice A descriptive name for a collection of NFTs in this contract202	/// @notice A descriptive name for a collection of NFTs in this contract
203	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`
204	#[solidity(hide, rename_selector = "name")]
207	fn name(&self) -> Result<string> {205	fn name_proxy(&self) -> Result<string> {
208		Ok(decode_utf16(self.name.iter().copied())206		self.name()
209			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))
210			.collect::<string>())
211	}207	}
212208
213	/// @notice An abbreviated name for NFTs in this contract209	/// @notice An abbreviated name for NFTs in this contract
210	/// @dev real implementation of this function lies in `ERC721UniqueExtensions`
211	#[solidity(hide, rename_selector = "symbol")]
214	fn symbol(&self) -> Result<string> {212	fn symbol_proxy(&self) -> Result<string> {
215		Ok(string::from_utf8_lossy(&self.token_prefix).into())213		self.symbol()
216	}214	}
217215
218	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.216	/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.
228	fn token_uri(&self, token_id: uint256) -> Result<string> {226	fn token_uri(&self, token_id: uint256) -> Result<string> {
229		let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;227		let token_id_u32: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
230228
231		if let Ok(url) = get_token_property(self, token_id_u32, &key::url()) {229		match get_token_property(self, token_id_u32, &key::url()).as_deref() {
232			if !url.is_empty() {230			Err(_) | Ok("") => (),
233				return Ok(url);
234			}
235		} else if !is_erc721_metadata_compatible::<T>(self.id) {231			Ok(url) => {
236			return Err("tokenURI not set".into());232				return Ok(url.into());
237		}233			}
234		};
238235
239		if let Some(base_uri) =236		let base_uri =
240			pallet_common::Pallet::<T>::get_collection_property(self.id, &key::base_uri())237			pallet_common::Pallet::<T>::get_collection_property(self.id, &key::base_uri())
241		{
242			if !base_uri.is_empty() {238				.map(BoundedVec::into_inner)
243				let base_uri = string::from_utf8(base_uri.into_inner()).map_err(|e| {239				.map(string::from_utf8)
240				.transpose()
241				.map_err(|e| {
244					Error::Revert(alloc::format!(242					Error::Revert(alloc::format!(
245						"Can not convert value \"baseURI\" to string with error \"{}\"",243						"Can not convert value \"baseURI\" to string with error \"{}\"",
246						e244						e
247					))245					))
248				})?;246				})?;
249				if let Ok(suffix) = get_token_property(self, token_id_u32, &key::suffix()) {247
250					if !suffix.is_empty() {248		let base_uri = match base_uri.as_deref() {
251						return Ok(base_uri + suffix.as_str());249			None | Some("") => {
252					}
253				}
254
255				return Ok(base_uri + token_id.to_string().as_str());
256			}
257		}
258
259		Ok("".into())250				return Ok("".into());
251			}
252			Some(base_uri) => base_uri.into(),
253		};
254
255		Ok(
256			match get_token_property(self, token_id_u32, &key::suffix()).as_deref() {
257				Err(_) | Ok("") => base_uri,
258				Ok(suffix) => base_uri + suffix,
259			},
260		)
260	}261	}
261}262}
262263
427}428}
428429
429/// @title ERC721 minting logic.430/// @title ERC721 minting logic.
430#[solidity_interface(name = ERC721Mintable, events(ERC721MintableEvents))]431#[solidity_interface(name = ERC721UniqueMintable, events(ERC721UniqueMintableEvents))]
431impl<T: Config> NonfungibleHandle<T> {432impl<T: Config> NonfungibleHandle<T> {
432	fn minting_finished(&self) -> Result<bool> {433	fn minting_finished(&self) -> Result<bool> {
433		Ok(false)434		Ok(false)
434	}435	}
436
437	/// @notice Function to mint token.
438	/// @param to The new owner
439	/// @return uint256 The id of the newly minted token
440	#[weight(<SelfWeightOf<T>>::create_item())]
441	fn mint(&mut self, caller: caller, to: address) -> Result<uint256> {
442		let token_id: uint256 = <TokensMinted<T>>::get(self.id)
443			.checked_add(1)
444			.ok_or("item id overflow")?
445			.into();
446		self.mint_check_id(caller, to, token_id)?;
447		Ok(token_id)
448	}
435449
436	/// @notice Function to mint token.450	/// @notice Function to mint token.
437	/// @dev `tokenId` should be obtained with `nextTokenId` method,451	/// @dev `tokenId` should be obtained with `nextTokenId` method,
438	///  unlike standard, you can't specify it manually452	///  unlike standard, you can't specify it manually
439	/// @param to The new owner453	/// @param to The new owner
440	/// @param tokenId ID of the minted NFT454	/// @param tokenId ID of the minted NFT
455	#[solidity(hide, rename_selector = "mint")]
441	#[weight(<SelfWeightOf<T>>::create_item())]456	#[weight(<SelfWeightOf<T>>::create_item())]
442	fn mint(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {457	fn mint_check_id(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {
443		let caller = T::CrossAccountId::from_eth(caller);458		let caller = T::CrossAccountId::from_eth(caller);
444		let to = T::CrossAccountId::from_eth(to);459		let to = T::CrossAccountId::from_eth(to);
445		let token_id: u32 = token_id.try_into()?;460		let token_id: u32 = token_id.try_into()?;
469		Ok(true)484		Ok(true)
470	}485	}
486
487	/// @notice Function to mint token with the given tokenUri.
488	/// @param to The new owner
489	/// @param tokenUri Token URI that would be stored in the NFT properties
490	/// @return uint256 The id of the newly minted token
491	#[solidity(rename_selector = "mintWithTokenURI")]
492	#[weight(<SelfWeightOf<T>>::create_item())]
493	fn mint_with_token_uri(
494		&mut self,
495		caller: caller,
496		to: address,
497		token_uri: string,
498	) -> Result<uint256> {
499		let token_id: uint256 = <TokensMinted<T>>::get(self.id)
500			.checked_add(1)
501			.ok_or("item id overflow")?
502			.into();
503		self.mint_with_token_uri_check_id(caller, to, token_id, token_uri)?;
504		Ok(token_id)
505	}
471506
472	/// @notice Function to mint token with the given tokenUri.507	/// @notice Function to mint token with the given tokenUri.
473	/// @dev `tokenId` should be obtained with `nextTokenId` method,508	/// @dev `tokenId` should be obtained with `nextTokenId` method,
474	///  unlike standard, you can't specify it manually509	///  unlike standard, you can't specify it manually
475	/// @param to The new owner510	/// @param to The new owner
476	/// @param tokenId ID of the minted NFT511	/// @param tokenId ID of the minted NFT
477	/// @param tokenUri Token URI that would be stored in the NFT properties512	/// @param tokenUri Token URI that would be stored in the NFT properties
478	#[solidity(rename_selector = "mintWithTokenURI")]513	#[solidity(hide, rename_selector = "mintWithTokenURI")]
479	#[weight(<SelfWeightOf<T>>::create_item())]514	#[weight(<SelfWeightOf<T>>::create_item())]
480	fn mint_with_token_uri(515	fn mint_with_token_uri_check_id(
481		&mut self,516		&mut self,
482		caller: caller,517		caller: caller,
483		to: address,518		to: address,
550	Err("Property tokenURI not found".into())585	Err("Property tokenURI not found".into())
551}586}
552
553fn is_erc721_metadata_compatible<T: Config>(collection_id: CollectionId) -> bool {
554	if let Some(shema_name) =
555		pallet_common::Pallet::<T>::get_collection_property(collection_id, &key::schema_name())
556	{
557		let shema_name = shema_name.into_inner();
558		shema_name == property_value::ERC721_METADATA
559	} else {
560		false
561	}
562}
563587
564fn get_token_permission<T: Config>(588fn get_token_permission<T: Config>(
565	collection_id: CollectionId,589	collection_id: CollectionId,
577	Ok(a)601	Ok(a)
578}602}
579
580fn has_token_permission<T: Config>(collection_id: CollectionId, key: &PropertyKey) -> bool {
581	if let Ok(token_property_permissions) =
582		CollectionPropertyPermissions::<T>::try_get(collection_id)
583	{
584		return token_property_permissions.contains_key(key);
585	}
586
587	false
588}
589603
590/// @title Unique extensions for ERC721.604/// @title Unique extensions for ERC721.
591#[solidity_interface(name = ERC721UniqueExtensions)]605#[solidity_interface(name = ERC721UniqueExtensions)]
592impl<T: Config> NonfungibleHandle<T> {606impl<T: Config> NonfungibleHandle<T> {
607	/// @notice A descriptive name for a collection of NFTs in this contract
608	fn name(&self) -> Result<string> {
609		Ok(decode_utf16(self.name.iter().copied())
610			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))
611			.collect::<string>())
612	}
613
614	/// @notice An abbreviated name for NFTs in this contract
615	fn symbol(&self) -> Result<string> {
616		Ok(string::from_utf8_lossy(&self.token_prefix).into())
617	}
618
593	/// @notice Transfer ownership of an NFT619	/// @notice Transfer ownership of an NFT
594	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`620	/// @dev Throws unless `msg.sender` is the current owner. Throws if `to`
642	///  should be obtained with `nextTokenId` method668	///  should be obtained with `nextTokenId` method
643	/// @param to The new owner669	/// @param to The new owner
644	/// @param tokenIds IDs of the minted NFTs670	/// @param tokenIds IDs of the minted NFTs
671	// #[solidity(hide)]
645	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]672	#[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]
646	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {673	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {
647		let caller = T::CrossAccountId::from_eth(caller);674		let caller = T::CrossAccountId::from_eth(caller);
678	///  numbers and first number should be obtained with `nextTokenId` method705	///  numbers and first number should be obtained with `nextTokenId` method
679	/// @param to The new owner706	/// @param to The new owner
680	/// @param tokens array of pairs of token ID and token URI for minted tokens707	/// @param tokens array of pairs of token ID and token URI for minted tokens
681	#[solidity(rename_selector = "mintBulkWithTokenURI")]708	#[solidity(/*hide,*/ rename_selector = "mintBulkWithTokenURI")]
682	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]709	#[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]
683	fn mint_bulk_with_token_uri(710	fn mint_bulk_with_token_uri(
684		&mut self,711		&mut self,
731	name = UniqueNFT,758	name = UniqueNFT,
732	is(759	is(
733		ERC721,760		ERC721,
734		ERC721Metadata,
735		ERC721Enumerable,761		ERC721Enumerable,
736		ERC721UniqueExtensions,762		ERC721UniqueExtensions,
737		ERC721Mintable,763		ERC721UniqueMintable,
738		ERC721Burnable,764		ERC721Burnable,
765		ERC721Metadata(if(this.flags.erc721metadata)),
739		Collection(via(common_mut returns CollectionHandle<T>)),766		Collection(via(common_mut returns CollectionHandle<T>)),
740		TokenProperties,767		TokenProperties,
741	)768	)

407		owner: T::CrossAccountId,408		owner: T::CrossAccountId,
408		payer: T::CrossAccountId,409		payer: T::CrossAccountId,
409		data: CreateCollectionData<T::AccountId>,410		data: CreateCollectionData<T::AccountId>,
410		is_external: bool,411		flags: CollectionFlags,
411	) -> Result<CollectionId, DispatchError> {412	) -> Result<CollectionId, DispatchError> {
412		<PalletCommon<T>>::init_collection(413		<PalletCommon<T>>::init_collection(owner, payer, data, flags)
413			owner,
414			payer,
415			data,
416			CollectionFlags {
417				external: is_external,
418				..Default::default()
419			},
420		)
421	}414	}
422415