git.delta.rocks / unique-network / refs/commits / 44992fca8f8c

1use core::{2	char::{REPLACEMENT_CHARACTER, decode_utf16},3	convert::TryInto,4};5use evm_coder::{ToLog, execution::*, generate_stubgen, solidity, solidity_interface, types::*};6use frame_support::BoundedVec;7use nft_data_structs::TokenId;8use pallet_evm_coder_substrate::dispatch_to_evm;9use sp_core::{H160, U256};10use sp_std::{vec::Vec, vec};11use pallet_common::{account::CrossAccountId, erc::CommonEvmHandler};12use pallet_evm_coder_substrate::call_internal;13use pallet_common::erc::PrecompileOutput;1415use crate::{16	AccountBalance, Config, CreateItemData, NonfungibleHandle, Pallet, TokenData, TokensMinted,17};1819#[derive(ToLog)]20pub enum ERC721Events {21	Transfer {22		#[indexed]23		from: address,24		#[indexed]25		to: address,26		#[indexed]27		token_id: uint256,28	},29	Approval {30		#[indexed]31		owner: address,32		#[indexed]33		approved: address,34		#[indexed]35		token_id: uint256,36	},37	#[allow(dead_code)]38	ApprovalForAll {39		#[indexed]40		owner: address,41		#[indexed]42		operator: address,43		approved: bool,44	},45}4647#[derive(ToLog)]48pub enum ERC721MintableEvents {49	#[allow(dead_code)]50	MintingFinished {},51}5253#[solidity_interface(name = "ERC721Metadata")]54impl<T: Config> NonfungibleHandle<T> {55	fn name(&self) -> Result<string> {56		Ok(decode_utf16(self.name.iter().copied())57			.map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))58			.collect::<string>())59	}60	fn symbol(&self) -> Result<string> {61		Ok(string::from_utf8_lossy(&self.token_prefix).into())62	}6364	#[solidity(rename_selector = "tokenURI")]65	fn token_uri(&self, token_id: uint256) -> Result<string> {66		let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;67		Ok(string::from_utf8_lossy(68			&<TokenData<T>>::get((self.id, token_id))69				.ok_or("token not found")?70				.const_data,71		)72		.into())73	}74}7576#[solidity_interface(name = "ERC721Enumerable")]77impl<T: Config> NonfungibleHandle<T> {78	fn token_by_index(&self, index: uint256) -> Result<uint256> {79		Ok(index)80	}8182	fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {83		// TODO: Not implemetable84		Err("not implemented".into())85	}8687	fn total_supply(&self) -> Result<uint256> {88		Ok(<Pallet<T>>::total_supply(self).into())89	}90}9192#[solidity_interface(name = "ERC721", events(ERC721Events))]93impl<T: Config> NonfungibleHandle<T> {94	fn balance_of(&self, owner: address) -> Result<uint256> {95		let owner = T::CrossAccountId::from_eth(owner);96		let balance = <AccountBalance<T>>::get((self.id, owner.as_sub()));97		Ok(balance.into())98	}99	fn owner_of(&self, token_id: uint256) -> Result<address> {100		let token: TokenId = token_id.try_into()?;101		Ok(*<TokenData<T>>::get((self.id, token))102			.ok_or("token not found")?103			.owner104			.as_eth())105	}106	fn safe_transfer_from_with_data(107		&mut self,108		_from: address,109		_to: address,110		_token_id: uint256,111		_data: bytes,112		_value: value,113	) -> Result<void> {114		// TODO: Not implemetable115		Err("not implemented".into())116	}117	fn safe_transfer_from(118		&mut self,119		_from: address,120		_to: address,121		_token_id: uint256,122		_value: value,123	) -> Result<void> {124		// TODO: Not implemetable125		Err("not implemented".into())126	}127128	fn transfer_from(129		&mut self,130		caller: caller,131		from: address,132		to: address,133		token_id: uint256,134		_value: value,135	) -> Result<void> {136		let caller = T::CrossAccountId::from_eth(caller);137		let from = T::CrossAccountId::from_eth(from);138		let to = T::CrossAccountId::from_eth(to);139		let token = token_id.try_into()?;140141		<Pallet<T>>::transfer_from(self, &caller, &from, &to, token)142			.map_err(dispatch_to_evm::<T>)?;143		Ok(())144	}145146	fn approve(147		&mut self,148		caller: caller,149		approved: address,150		token_id: uint256,151		_value: value,152	) -> Result<void> {153		let caller = T::CrossAccountId::from_eth(caller);154		let approved = T::CrossAccountId::from_eth(approved);155		let token = token_id.try_into()?;156157		<Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))158			.map_err(dispatch_to_evm::<T>)?;159		Ok(())160	}161162	fn set_approval_for_all(163		&mut self,164		_caller: caller,165		_operator: address,166		_approved: bool,167	) -> Result<void> {168		// TODO: Not implemetable169		Err("not implemented".into())170	}171172	fn get_approved(&self, _token_id: uint256) -> Result<address> {173		// TODO: Not implemetable174		Err("not implemented".into())175	}176177	fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {178		// TODO: Not implemetable179		Err("not implemented".into())180	}181}182183#[solidity_interface(name = "ERC721Burnable")]184impl<T: Config> NonfungibleHandle<T> {185	fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {186		let caller = T::CrossAccountId::from_eth(caller);187		let token = token_id.try_into()?;188189		<Pallet<T>>::burn(self, &caller, token).map_err(dispatch_to_evm::<T>)?;190		Ok(())191	}192}193194#[solidity_interface(name = "ERC721Mintable", events(ERC721MintableEvents))]195impl<T: Config> NonfungibleHandle<T> {196	fn minting_finished(&self) -> Result<bool> {197		Ok(false)198	}199200	fn mint(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {201		let caller = T::CrossAccountId::from_eth(caller);202		let to = T::CrossAccountId::from_eth(to);203		let token_id: u32 = token_id.try_into()?;204		if <TokensMinted<T>>::get(self.id)205			.checked_add(1)206			.ok_or("item id overflow")?207			!= token_id208		{209			return Err("item id should be next".into());210		}211212		<Pallet<T>>::create_item(213			self,214			&caller,215			CreateItemData {216				const_data: BoundedVec::default(),217				variable_data: BoundedVec::default(),218				owner: to,219			},220		)221		.map_err(dispatch_to_evm::<T>)?;222223		Ok(true)224	}225226	#[solidity(rename_selector = "mintWithTokenURI")]227	fn mint_with_token_uri(228		&mut self,229		caller: caller,230		to: address,231		token_id: uint256,232		token_uri: string,233	) -> Result<bool> {234		let caller = T::CrossAccountId::from_eth(caller);235		let to = T::CrossAccountId::from_eth(to);236		let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;237		if <TokensMinted<T>>::get(self.id)238			.checked_add(1)239			.ok_or("item id overflow")?240			!= token_id241		{242			return Err("item id should be next".into());243		}244245		<Pallet<T>>::create_item(246			self,247			&caller,248			CreateItemData {249				const_data: Vec::<u8>::from(token_uri)250					.try_into()251					.map_err(|_| "token uri is too long")?,252				variable_data: BoundedVec::default(),253				owner: to,254			},255		)256		.map_err(dispatch_to_evm::<T>)?;257		Ok(true)258	}259260	fn finish_minting(&mut self, _caller: caller) -> Result<bool> {261		Err("not implementable".into())262	}263}264265#[solidity_interface(name = "ERC721UniqueExtensions")]266impl<T: Config> NonfungibleHandle<T> {267	fn transfer(268		&mut self,269		caller: caller,270		to: address,271		token_id: uint256,272		_value: value,273	) -> Result<void> {274		let caller = T::CrossAccountId::from_eth(caller);275		let to = T::CrossAccountId::from_eth(to);276		let token = token_id.try_into()?;277278		<Pallet<T>>::transfer(self, &caller, &to, token).map_err(dispatch_to_evm::<T>)?;279		Ok(())280	}281282	fn burn_from(283		&mut self,284		caller: caller,285		from: address,286		token_id: uint256,287		_value: value,288	) -> Result<void> {289		let caller = T::CrossAccountId::from_eth(caller);290		let from = T::CrossAccountId::from_eth(from);291		let token = token_id.try_into()?;292293		<Pallet<T>>::burn_from(self, &caller, &from, token).map_err(dispatch_to_evm::<T>)?;294		Ok(())295	}296297	fn next_token_id(&self) -> Result<uint256> {298		Ok(<TokensMinted<T>>::get(self.id)299			.checked_add(1)300			.ok_or("item id overflow")?301			.into())302	}303304	fn set_variable_metadata(305		&mut self,306		caller: caller,307		token_id: uint256,308		data: bytes,309	) -> Result<void> {310		let caller = T::CrossAccountId::from_eth(caller);311		let token = token_id.try_into()?;312313		<Pallet<T>>::set_variable_metadata(self, &caller, token, data)314			.map_err(dispatch_to_evm::<T>)?;315		Ok(())316	}317318	fn get_variable_metadata(&self, token_id: uint256) -> Result<bytes> {319		let token: TokenId = token_id.try_into()?;320321		Ok(<TokenData<T>>::get((self.id, token))322			.ok_or("token not found")?323			.variable_data)324	}325326	fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {327		let caller = T::CrossAccountId::from_eth(caller);328		let to = T::CrossAccountId::from_eth(to);329		let mut expected_index = <TokensMinted<T>>::get(self.id)330			.checked_add(1)331			.ok_or("item id overflow")?;332333		let total_tokens = token_ids.len();334		for id in token_ids.into_iter() {335			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;336			if id != expected_index {337				return Err("item id should be next".into());338			}339			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;340		}341		let data = (0..total_tokens)342			.map(|_| CreateItemData {343				const_data: BoundedVec::default(),344				variable_data: BoundedVec::default(),345				owner: to.clone(),346			})347			.collect();348349		<Pallet<T>>::create_multiple_items(self, &caller, data).map_err(dispatch_to_evm::<T>)?;350		Ok(true)351	}352353	#[solidity(rename_selector = "mintBulkWithTokenURI")]354	fn mint_bulk_with_token_uri(355		&mut self,356		caller: caller,357		to: address,358		tokens: Vec<(uint256, string)>,359	) -> Result<bool> {360		let caller = T::CrossAccountId::from_eth(caller);361		let to = T::CrossAccountId::from_eth(to);362		let mut expected_index = <TokensMinted<T>>::get(self.id)363			.checked_add(1)364			.ok_or("item id overflow")?;365366		let mut data = Vec::with_capacity(tokens.len());367		for (id, token_uri) in tokens {368			let id: u32 = id.try_into().map_err(|_| "token id overflow")?;369			if id != expected_index {370				panic!("item id should be next ({}) but got {}", expected_index, id);371			}372			expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;373374			data.push(CreateItemData {375				const_data: Vec::<u8>::from(token_uri)376					.try_into()377					.map_err(|_| "token uri is too long")?,378				variable_data: vec![].try_into().unwrap(),379				owner: to.clone(),380			});381		}382383		<Pallet<T>>::create_multiple_items(self, &caller, data).map_err(dispatch_to_evm::<T>)?;384		Ok(true)385	}386}387388#[solidity_interface(389	name = "UniqueNFT",390	is(391		ERC721,392		ERC721Metadata,393		ERC721Enumerable,394		ERC721UniqueExtensions,395		ERC721Mintable,396		ERC721Burnable,397	)398)]399impl<T: Config> NonfungibleHandle<T> {}400401// Not a tests, but code generators402generate_stubgen!(gen_impl, UniqueNFTCall, true);403generate_stubgen!(gen_iface, UniqueNFTCall, false);404405pub const CODE: &[u8] = include_bytes!("./stubs/UniqueNFT.raw");406407impl<T: Config> CommonEvmHandler for NonfungibleHandle<T> {408	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueNFT.raw");409410	fn call(mut self, source: &H160, input: &[u8], value: U256) -> Option<PrecompileOutput> {411		let result = call_internal::<UniqueNFTCall, _>(*source, &mut self, value, input);412		self.0.recorder.evm_to_precompile_output(result)413	}414}