1use core::{2 char::{REPLACEMENT_CHARACTER, decode_utf16},3 convert::TryInto,4};5use evm_coder::{ToLog, execution::*, generate_stubgen, solidity, solidity_interface, types::*, weight};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;13use pallet_common::erc::PrecompileOutput;1415use crate::{16 AccountBalance, Config, CreateItemData, NonfungibleHandle, Pallet, TokenData, TokensMinted,17 SelfWeightOf, weights::WeightInfo,18};1920#[derive(ToLog)]21pub enum ERC721Events {22 Transfer {23 #[indexed]24 from: address,25 #[indexed]26 to: address,27 #[indexed]28 token_id: uint256,29 },30 Approval {31 #[indexed]32 owner: address,33 #[indexed]34 approved: address,35 #[indexed]36 token_id: uint256,37 },38 #[allow(dead_code)]39 ApprovalForAll {40 #[indexed]41 owner: address,42 #[indexed]43 operator: address,44 approved: bool,45 },46}4748#[derive(ToLog)]49pub enum ERC721MintableEvents {50 #[allow(dead_code)]51 MintingFinished {},52}5354#[solidity_interface(name = "ERC721Metadata")]55impl<T: Config> NonfungibleHandle<T> {56 fn name(&self) -> Result<string> {57 Ok(decode_utf16(self.name.iter().copied())58 .map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))59 .collect::<string>())60 }61 fn symbol(&self) -> Result<string> {62 Ok(string::from_utf8_lossy(&self.token_prefix).into())63 }6465 66 #[solidity(rename_selector = "tokenURI")]67 fn token_uri(&self, token_id: uint256) -> Result<string> {68 self.consume_store_reads(1)?;69 let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;70 Ok(string::from_utf8_lossy(71 &<TokenData<T>>::get((self.id, token_id))72 .ok_or("token not found")?73 .const_data,74 )75 .into())76 }77}7879#[solidity_interface(name = "ERC721Enumerable")]80impl<T: Config> NonfungibleHandle<T> {81 fn token_by_index(&self, index: uint256) -> Result<uint256> {82 Ok(index)83 }8485 86 fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {87 88 Err("not implemented".into())89 }9091 fn total_supply(&self) -> Result<uint256> {92 self.consume_store_reads(1)?;93 Ok(<Pallet<T>>::total_supply(self).into())94 }95}9697#[solidity_interface(name = "ERC721", events(ERC721Events))]98impl<T: Config> NonfungibleHandle<T> {99 fn balance_of(&self, owner: address) -> Result<uint256> {100 self.consume_store_reads(1)?;101 let owner = T::CrossAccountId::from_eth(owner);102 let balance = <AccountBalance<T>>::get((self.id, owner));103 Ok(balance.into())104 }105 fn owner_of(&self, token_id: uint256) -> Result<address> {106 self.consume_store_reads(1)?;107 let token: TokenId = token_id.try_into()?;108 Ok(*<TokenData<T>>::get((self.id, token))109 .ok_or("token not found")?110 .owner111 .as_eth())112 }113 114 fn safe_transfer_from_with_data(115 &mut self,116 _from: address,117 _to: address,118 _token_id: uint256,119 _data: bytes,120 _value: value,121 ) -> Result<void> {122 123 Err("not implemented".into())124 }125 126 fn safe_transfer_from(127 &mut self,128 _from: address,129 _to: address,130 _token_id: uint256,131 _value: value,132 ) -> Result<void> {133 134 Err("not implemented".into())135 }136137 #[weight(<SelfWeightOf<T>>::transfer_from())]138 fn transfer_from(139 &mut self,140 caller: caller,141 from: address,142 to: address,143 token_id: uint256,144 _value: value,145 ) -> Result<void> {146 let caller = T::CrossAccountId::from_eth(caller);147 let from = T::CrossAccountId::from_eth(from);148 let to = T::CrossAccountId::from_eth(to);149 let token = token_id.try_into()?;150151 <Pallet<T>>::transfer_from(self, &caller, &from, &to, token)152 .map_err(dispatch_to_evm::<T>)?;153 Ok(())154 }155156 #[weight(<SelfWeightOf<T>>::approve())]157 fn approve(158 &mut self,159 caller: caller,160 approved: address,161 token_id: uint256,162 _value: value,163 ) -> Result<void> {164 let caller = T::CrossAccountId::from_eth(caller);165 let approved = T::CrossAccountId::from_eth(approved);166 let token = token_id.try_into()?;167168 <Pallet<T>>::set_allowance(self, &caller, token, Some(&approved))169 .map_err(dispatch_to_evm::<T>)?;170 Ok(())171 }172173 174 fn set_approval_for_all(175 &mut self,176 _caller: caller,177 _operator: address,178 _approved: bool,179 ) -> Result<void> {180 181 Err("not implemented".into())182 }183184 185 fn get_approved(&self, _token_id: uint256) -> Result<address> {186 187 Err("not implemented".into())188 }189190 191 fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {192 193 Err("not implemented".into())194 }195}196197#[solidity_interface(name = "ERC721Burnable")]198impl<T: Config> NonfungibleHandle<T> {199 #[weight(<SelfWeightOf<T>>::burn_item())]200 fn burn(&mut self, caller: caller, token_id: uint256) -> Result<void> {201 let caller = T::CrossAccountId::from_eth(caller);202 let token = token_id.try_into()?;203204 <Pallet<T>>::burn(self, &caller, token).map_err(dispatch_to_evm::<T>)?;205 Ok(())206 }207}208209#[solidity_interface(name = "ERC721Mintable", events(ERC721MintableEvents))]210impl<T: Config> NonfungibleHandle<T> {211 fn minting_finished(&self) -> Result<bool> {212 Ok(false)213 }214215 216 217 #[weight(<SelfWeightOf<T>>::create_item())]218 fn mint(&mut self, caller: caller, to: address, token_id: uint256) -> Result<bool> {219 let caller = T::CrossAccountId::from_eth(caller);220 let to = T::CrossAccountId::from_eth(to);221 let token_id: u32 = token_id.try_into()?;222 if <TokensMinted<T>>::get(self.id)223 .checked_add(1)224 .ok_or("item id overflow")?225 != token_id226 {227 return Err("item id should be next".into());228 }229230 <Pallet<T>>::create_item(231 self,232 &caller,233 CreateItemData {234 const_data: BoundedVec::default(),235 variable_data: BoundedVec::default(),236 owner: to,237 },238 )239 .map_err(dispatch_to_evm::<T>)?;240241 Ok(true)242 }243244 245 246 #[solidity(rename_selector = "mintWithTokenURI")]247 #[weight(<SelfWeightOf<T>>::create_item())]248 fn mint_with_token_uri(249 &mut self,250 caller: caller,251 to: address,252 token_id: uint256,253 token_uri: string,254 ) -> Result<bool> {255 let caller = T::CrossAccountId::from_eth(caller);256 let to = T::CrossAccountId::from_eth(to);257 let token_id: u32 = token_id.try_into().map_err(|_| "amount overflow")?;258 if <TokensMinted<T>>::get(self.id)259 .checked_add(1)260 .ok_or("item id overflow")?261 != token_id262 {263 return Err("item id should be next".into());264 }265266 <Pallet<T>>::create_item(267 self,268 &caller,269 CreateItemData {270 const_data: Vec::<u8>::from(token_uri)271 .try_into()272 .map_err(|_| "token uri is too long")?,273 variable_data: BoundedVec::default(),274 owner: to,275 },276 )277 .map_err(dispatch_to_evm::<T>)?;278 Ok(true)279 }280281 282 fn finish_minting(&mut self, _caller: caller) -> Result<bool> {283 Err("not implementable".into())284 }285}286287#[solidity_interface(name = "ERC721UniqueExtensions")]288impl<T: Config> NonfungibleHandle<T> {289 #[weight(<SelfWeightOf<T>>::transfer())]290 fn transfer(291 &mut self,292 caller: caller,293 to: address,294 token_id: uint256,295 _value: value,296 ) -> Result<void> {297 let caller = T::CrossAccountId::from_eth(caller);298 let to = T::CrossAccountId::from_eth(to);299 let token = token_id.try_into()?;300301 <Pallet<T>>::transfer(self, &caller, &to, token).map_err(dispatch_to_evm::<T>)?;302 Ok(())303 }304305 #[weight(<SelfWeightOf<T>>::burn_from())]306 fn burn_from(307 &mut self,308 caller: caller,309 from: address,310 token_id: uint256,311 _value: value,312 ) -> Result<void> {313 let caller = T::CrossAccountId::from_eth(caller);314 let from = T::CrossAccountId::from_eth(from);315 let token = token_id.try_into()?;316317 <Pallet<T>>::burn_from(self, &caller, &from, token).map_err(dispatch_to_evm::<T>)?;318 Ok(())319 }320321 fn next_token_id(&self) -> Result<uint256> {322 self.consume_store_reads(1)?;323 Ok(<TokensMinted<T>>::get(self.id)324 .checked_add(1)325 .ok_or("item id overflow")?326 .into())327 }328329 #[weight(<SelfWeightOf<T>>::set_variable_metadata(data.len() as u32))]330 fn set_variable_metadata(331 &mut self,332 caller: caller,333 token_id: uint256,334 data: bytes,335 ) -> Result<void> {336 let caller = T::CrossAccountId::from_eth(caller);337 let token = token_id.try_into()?;338339 <Pallet<T>>::set_variable_metadata(self, &caller, token, data)340 .map_err(dispatch_to_evm::<T>)?;341 Ok(())342 }343344 fn get_variable_metadata(&self, token_id: uint256) -> Result<bytes> {345 self.consume_store_reads(1)?;346 let token: TokenId = token_id.try_into()?;347348 Ok(<TokenData<T>>::get((self.id, token))349 .ok_or("token not found")?350 .variable_data)351 }352353 #[weight(<SelfWeightOf<T>>::create_multiple_items(token_ids.len() as u32))]354 fn mint_bulk(&mut self, caller: caller, to: address, token_ids: Vec<uint256>) -> Result<bool> {355 let caller = T::CrossAccountId::from_eth(caller);356 let to = T::CrossAccountId::from_eth(to);357 let mut expected_index = <TokensMinted<T>>::get(self.id)358 .checked_add(1)359 .ok_or("item id overflow")?;360361 let total_tokens = token_ids.len();362 for id in token_ids.into_iter() {363 let id: u32 = id.try_into().map_err(|_| "token id overflow")?;364 if id != expected_index {365 return Err("item id should be next".into());366 }367 expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;368 }369 let data = (0..total_tokens)370 .map(|_| CreateItemData {371 const_data: BoundedVec::default(),372 variable_data: BoundedVec::default(),373 owner: to.clone(),374 })375 .collect();376377 <Pallet<T>>::create_multiple_items(self, &caller, data).map_err(dispatch_to_evm::<T>)?;378 Ok(true)379 }380381 #[solidity(rename_selector = "mintBulkWithTokenURI")]382 #[weight(<SelfWeightOf<T>>::create_multiple_items(tokens.len() as u32))]383 fn mint_bulk_with_token_uri(384 &mut self,385 caller: caller,386 to: address,387 tokens: Vec<(uint256, string)>,388 ) -> Result<bool> {389 let caller = T::CrossAccountId::from_eth(caller);390 let to = T::CrossAccountId::from_eth(to);391 let mut expected_index = <TokensMinted<T>>::get(self.id)392 .checked_add(1)393 .ok_or("item id overflow")?;394395 let mut data = Vec::with_capacity(tokens.len());396 for (id, token_uri) in tokens {397 let id: u32 = id.try_into().map_err(|_| "token id overflow")?;398 if id != expected_index {399 panic!("item id should be next ({}) but got {}", expected_index, id);400 }401 expected_index = expected_index.checked_add(1).ok_or("item id overflow")?;402403 data.push(CreateItemData {404 const_data: Vec::<u8>::from(token_uri)405 .try_into()406 .map_err(|_| "token uri is too long")?,407 variable_data: vec![].try_into().unwrap(),408 owner: to.clone(),409 });410 }411412 <Pallet<T>>::create_multiple_items(self, &caller, data).map_err(dispatch_to_evm::<T>)?;413 Ok(true)414 }415}416417#[solidity_interface(418 name = "UniqueNFT",419 is(420 ERC721,421 ERC721Metadata,422 ERC721Enumerable,423 ERC721UniqueExtensions,424 ERC721Mintable,425 ERC721Burnable,426 )427)]428impl<T: Config> NonfungibleHandle<T> {}429430431generate_stubgen!(gen_impl, UniqueNFTCall<()>, true);432generate_stubgen!(gen_iface, UniqueNFTCall<()>, false);433434impl<T: Config> CommonEvmHandler for NonfungibleHandle<T> {435 const CODE: &'static [u8] = include_bytes!("./stubs/UniqueNFT.raw");436437 fn call(self, source: &H160, input: &[u8], value: U256) -> Option<PrecompileOutput> {438 call::<T, UniqueNFTCall<T>, _>(*source, self, value, input)439 }440}