difftreelog
refactor rewrite nft pallet to evm helpers
in: master
7 files changed
pallets/nft/Cargo.tomldiffbeforeafterboth--- a/pallets/nft/Cargo.toml
+++ b/pallets/nft/Cargo.toml
@@ -39,7 +39,7 @@
'primitive-types/std',
'evm-coder/std',
- 'evm-coder-substrate/std',
+ 'pallet-evm-coder-substrate/std',
]
################################################################################
@@ -144,10 +144,12 @@
sp-api = { default-features = false, version = '3.0.0', git = "https://github.com/paritytech/substrate.git", branch = "polkadot-v0.9.8" }
evm-coder = { default-features = false, path = "../../crates/evm-coder" }
-evm-coder-substrate = { default-features = false, path = "../../crates/evm-coder-substrate" }
-primitive-types = { version = "0.9.0", default-features = false, features = ["serde_no_std"] }
+pallet-evm-coder-substrate = { default-features = false, path = "../../pallets/evm-coder-substrate" }
+primitive-types = { version = "0.9.0", default-features = false, features = [
+ "serde_no_std",
+] }
pallet-evm = { default-features = false, version = "5.0.0-dev", git = "https://github.com/uniquenetwork/frontier.git", branch = "injected-transactions-parachain" }
pallet-ethereum = { default-features = false, version = "3.0.0-dev", git = "https://github.com/uniquenetwork/frontier.git", branch = "injected-transactions-parachain" }
fp-evm = { default-features = false, version = '2.0.0', git = "https://github.com/uniquenetwork/frontier.git", branch = "injected-transactions-parachain" }
-hex-literal = "0.3.1"
\ No newline at end of file
+hex-literal = "0.3.1"
pallets/nft/src/eth/erc.rsdiffbeforeafterboth--- a/pallets/nft/src/eth/erc.rs
+++ b/pallets/nft/src/eth/erc.rs
@@ -1,46 +1,63 @@
-use evm_coder::{solidity_interface, solidity, types::*, ToLog};
+use core::char::{decode_utf16, REPLACEMENT_CHARACTER};
+use evm_coder::{ToLog, execution::Result, solidity, solidity_interface, types::*};
+use core::convert::TryInto;
+use alloc::format;
+use crate::{Allowances, Module, Balance, CollectionHandle, CollectionMode, Config, NftItemList};
+use frame_support::storage::StorageDoubleMap;
+use pallet_evm::AddressMapping;
+use super::account::CrossAccountId;
use sp_std::vec::Vec;
-#[solidity_interface]
-pub trait InlineNameSymbol {
- type Error;
-
- fn name(&self) -> Result<string, Self::Error>;
- fn symbol(&self) -> Result<string, Self::Error>;
+#[solidity_interface(name = "ERC165")]
+impl<T: Config> CollectionHandle<T> {
+ fn supports_interface(&self, interface_id: bytes4) -> Result<bool> {
+ Ok(match self.mode {
+ CollectionMode::Fungible(_) => UniqueFungibleCall::supports_interface(interface_id),
+ CollectionMode::NFT => UniqueNFTCall::supports_interface(interface_id),
+ _ => false,
+ })
+ }
}
-#[solidity_interface]
-pub trait InlineTotalSupply {
- type Error;
+#[solidity_interface(name = "InlineNameSymbol")]
+impl<T: Config> CollectionHandle<T> {
+ fn name(&self) -> Result<string> {
+ Ok(decode_utf16(self.name.iter().copied())
+ .map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))
+ .collect::<string>())
+ }
- fn total_supply(&self) -> Result<uint256, Self::Error>;
+ fn symbol(&self) -> Result<string> {
+ Ok(string::from_utf8_lossy(&self.token_prefix).into())
+ }
}
-#[solidity_interface]
-pub trait ERC165 {
- type Error;
-
- fn supports_interface(&self, interface_id: bytes4) -> Result<bool, Self::Error>;
+#[solidity_interface(name = "InlineTotalSupply")]
+impl<T: Config> CollectionHandle<T> {
+ fn total_supply(&self) -> Result<uint256> {
+ // TODO: we do not track total amount of all tokens
+ Ok(0.into())
+ }
}
-#[solidity_interface(inline_is(InlineNameSymbol))]
-pub trait ERC721Metadata {
- type Error;
-
- #[solidity(rename_selector = "tokenURI")]
- fn token_uri(&self, token_id: uint256) -> Result<string, Self::Error>;
+#[solidity_interface(name = "ERC721Metadata", inline_is(InlineNameSymbol))]
+impl<T: Config> CollectionHandle<T> {
+ fn token_uri(&self, token_id: uint256) -> Result<string> {
+ // TODO: We should standartize url prefix, maybe via offchain schema?
+ Ok(format!("unique.network/{}/{}", self.id, token_id))
+ }
}
-#[solidity_interface(inline_is(InlineTotalSupply))]
-pub trait ERC721Enumerable {
- type Error;
+#[solidity_interface(name = "ERC721Enumerable", inline_is(InlineTotalSupply))]
+impl<T: Config> CollectionHandle<T> {
+ fn token_by_index(&self, index: uint256) -> Result<uint256> {
+ Ok(index)
+ }
- fn token_by_index(&self, index: uint256) -> Result<uint256, Self::Error>;
- fn token_of_owner_by_index(
- &self,
- owner: address,
- index: uint256,
- ) -> Result<uint256, Self::Error>;
+ fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {
+ // TODO: Not implemetable
+ Err("not implemented".into())
+ }
}
#[derive(ToLog)]
@@ -71,29 +88,40 @@
},
}
-#[solidity_interface(is(ERC165), events(ERC721Events))]
-pub trait ERC721 {
- type Error;
-
- fn balance_of(&self, owner: address) -> Result<uint256, Self::Error>;
- fn owner_of(&self, token_id: uint256) -> Result<address, Self::Error>;
-
- #[solidity(rename_selector = "safeTransferFrom")]
+#[solidity_interface(name = "ERC721", is(ERC165), events(ERC721Events))]
+impl<T: Config> CollectionHandle<T> {
+ #[solidity(rename_selector = "balanceOf")]
+ fn balance_of_nft(&self, owner: address) -> Result<uint256> {
+ let owner = T::EvmAddressMapping::into_account_id(owner);
+ let balance = <Balance<T>>::get(self.id, owner);
+ Ok(balance.into())
+ }
+ fn owner_of(&self, token_id: uint256) -> Result<address> {
+ let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
+ let token = <NftItemList<T>>::get(self.id, token_id).ok_or("unknown token")?;
+ Ok(*token.owner.as_eth())
+ }
fn safe_transfer_from_with_data(
&mut self,
- from: address,
- to: address,
- token_id: uint256,
- data: bytes,
- value: value,
- ) -> Result<void, Self::Error>;
+ _from: address,
+ _to: address,
+ _token_id: uint256,
+ _data: bytes,
+ _value: value,
+ ) -> Result<void> {
+ // TODO: Not implemetable
+ Err("not implemented".into())
+ }
fn safe_transfer_from(
&mut self,
- from: address,
- to: address,
- token_id: uint256,
- value: value,
- ) -> Result<void, Self::Error>;
+ _from: address,
+ _to: address,
+ _token_id: uint256,
+ _value: value,
+ ) -> Result<void> {
+ // TODO: Not implemetable
+ Err("not implemented".into())
+ }
fn transfer_from(
&mut self,
@@ -101,53 +129,86 @@
from: address,
to: address,
token_id: uint256,
- value: value,
- ) -> Result<void, Self::Error>;
+ _value: value,
+ ) -> Result<void> {
+ let caller = T::CrossAccountId::from_eth(caller);
+ let from = T::CrossAccountId::from_eth(from);
+ let to = T::CrossAccountId::from_eth(to);
+ let token_id = token_id.try_into().map_err(|_| "token_id overflow")?;
+
+ <Module<T>>::transfer_from_internal(&caller, &from, &to, self, token_id, 1)
+ .map_err(|_| "transferFrom error")?;
+ Ok(())
+ }
+
fn approve(
&mut self,
caller: caller,
approved: address,
token_id: uint256,
- value: value,
- ) -> Result<void, Self::Error>;
+ _value: value,
+ ) -> Result<void> {
+ let caller = T::CrossAccountId::from_eth(caller);
+ let approved = T::CrossAccountId::from_eth(approved);
+ let token_id = token_id.try_into().map_err(|_| "token_id overflow")?;
+
+ <Module<T>>::approve_internal(&caller, &approved, self, token_id, 1)
+ .map_err(|_| "approve internal")?;
+ Ok(())
+ }
+
fn set_approval_for_all(
&mut self,
- caller: caller,
- operator: address,
- approved: bool,
- ) -> Result<void, Self::Error>;
+ _caller: caller,
+ _operator: address,
+ _approved: bool,
+ ) -> Result<void> {
+ // TODO: Not implemetable
+ Err("not implemented".into())
+ }
+
+ fn get_approved(&self, _token_id: uint256) -> Result<address> {
+ // TODO: Not implemetable
+ Err("not implemented".into())
+ }
- fn get_approved(&self, token_id: uint256) -> Result<address, Self::Error>;
- fn is_approved_for_all(
- &self,
- owner: address,
- operator: address,
- ) -> Result<address, Self::Error>;
+ fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {
+ // TODO: Not implemetable
+ Err("not implemented".into())
+ }
}
-#[solidity_interface]
-pub trait ERC721UniqueExtensions {
- type Error;
-
- fn transfer(
+#[solidity_interface(name = "ERC721UniqueExtensions")]
+impl<T: Config> CollectionHandle<T> {
+ #[solidity(rename_selector = "transfer")]
+ fn transfer_nft(
&mut self,
caller: caller,
to: address,
token_id: uint256,
- value: value,
- ) -> Result<void, Self::Error>;
+ _value: value,
+ ) -> Result<void> {
+ let caller = T::CrossAccountId::from_eth(caller);
+ let to = T::CrossAccountId::from_eth(to);
+ let token_id = token_id.try_into().map_err(|_| "amount overflow")?;
+
+ <Module<T>>::transfer_internal(&caller, &to, self, token_id, 1)
+ .map_err(|_| "transfer error")?;
+ Ok(())
+ }
}
-#[solidity_interface(is(
- ERC165,
- ERC721,
- ERC721Metadata,
- ERC721Enumerable,
- ERC721UniqueExtensions
-))]
-pub trait UniqueNFT {
- type Error;
-}
+#[solidity_interface(
+ name = "UniqueNFT",
+ is(
+ ERC165,
+ ERC721,
+ ERC721Metadata,
+ ERC721Enumerable,
+ ERC721UniqueExtensions
+ )
+)]
+impl<T: Config> CollectionHandle<T> {}
#[derive(ToLog)]
pub enum ERC20Events {
@@ -167,35 +228,72 @@
},
}
-#[solidity_interface(inline_is(InlineNameSymbol, InlineTotalSupply), events(ERC20Events))]
-pub trait ERC20 {
- type Error;
+#[solidity_interface(
+ name = "ERC20",
+ inline_is(InlineNameSymbol, InlineTotalSupply),
+ events(ERC20Events)
+)]
+impl<T: Config> CollectionHandle<T> {
+ fn decimals(&self) -> Result<uint8> {
+ Ok(if let CollectionMode::Fungible(decimals) = &self.mode {
+ *decimals
+ } else {
+ unreachable!()
+ })
+ }
+ fn balance_of(&self, owner: address) -> Result<uint256> {
+ let owner = T::EvmAddressMapping::into_account_id(owner);
+ let balance = <Balance<T>>::get(self.id, owner);
+ Ok(balance.into())
+ }
+ fn transfer(&mut self, caller: caller, to: address, amount: uint256) -> Result<bool> {
+ let caller = T::CrossAccountId::from_eth(caller);
+ let to = T::CrossAccountId::from_eth(to);
+ let amount = amount.try_into().map_err(|_| "amount overflow")?;
- fn decimals(&self) -> Result<uint8, Self::Error>;
- fn balance_of(&self, owner: address) -> Result<uint256, Self::Error>;
- fn transfer(
- &mut self,
- caller: caller,
- to: address,
- value: uint256,
- ) -> Result<bool, Self::Error>;
- fn transfer_from(
+ <Module<T>>::transfer_internal(&caller, &to, self, 1, amount)
+ .map_err(|_| "transfer error")?;
+ Ok(true)
+ }
+ #[solidity(rename_selector = "transferFrom")]
+ fn transfer_from_fungible(
&mut self,
caller: caller,
from: address,
to: address,
- value: uint256,
- ) -> Result<bool, Self::Error>;
- fn approve(
+ amount: uint256,
+ ) -> Result<bool> {
+ let caller = T::CrossAccountId::from_eth(caller);
+ let from = T::CrossAccountId::from_eth(from);
+ let to = T::CrossAccountId::from_eth(to);
+ let amount = amount.try_into().map_err(|_| "amount overflow")?;
+
+ <Module<T>>::transfer_from_internal(&caller, &from, &to, self, 1, amount)
+ .map_err(|_| "transferFrom error")?;
+ Ok(true)
+ }
+ #[solidity(rename_selector = "approve")]
+ fn approve_fungible(
&mut self,
caller: caller,
spender: address,
- value: uint256,
- ) -> Result<bool, Self::Error>;
- fn allowance(&self, owner: address, spender: address) -> Result<uint256, Self::Error>;
-}
+ amount: uint256,
+ ) -> Result<bool> {
+ let caller = T::CrossAccountId::from_eth(caller);
+ let spender = T::CrossAccountId::from_eth(spender);
+ let amount = amount.try_into().map_err(|_| "amount overflow")?;
+
+ <Module<T>>::approve_internal(&caller, &spender, self, 1, amount)
+ .map_err(|_| "approve internal")?;
+ Ok(true)
+ }
+ fn allowance(&self, owner: address, spender: address) -> Result<uint256> {
+ let owner = T::CrossAccountId::from_eth(owner);
+ let spender = T::CrossAccountId::from_eth(spender);
-#[solidity_interface(is(ERC165, ERC20))]
-pub trait UniqueFungible {
- type Error;
+ Ok(<Allowances<T>>::get(self.id, (1, owner.as_sub(), spender.as_sub())).into())
+ }
}
+
+#[solidity_interface(name = "UniqueFungible", is(ERC165, ERC20))]
+impl<T: Config> CollectionHandle<T> {}
pallets/nft/src/eth/erc_impl.rsdiffbeforeafterboth--- a/pallets/nft/src/eth/erc_impl.rs
+++ /dev/null
@@ -1,283 +0,0 @@
-use core::char::{decode_utf16, REPLACEMENT_CHARACTER};
-use evm_coder::{
- abi::{AbiWriter, StringError},
- types::*,
-};
-use core::convert::TryInto;
-use alloc::format;
-use crate::{Allowances, Module, Balance, CollectionHandle, CollectionMode, Config, NftItemList};
-use frame_support::storage::StorageDoubleMap;
-use pallet_evm::AddressMapping;
-use super::erc::*;
-use super::account::CrossAccountId;
-
-type Result<T> = core::result::Result<T, StringError>;
-
-impl<T: Config> InlineNameSymbol for CollectionHandle<T> {
- type Error = StringError;
-
- fn name(&self) -> Result<string> {
- Ok(decode_utf16(self.name.iter().copied())
- .map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))
- .collect::<string>())
- }
-
- fn symbol(&self) -> Result<string> {
- Ok(string::from_utf8_lossy(&self.token_prefix).into())
- }
-}
-
-impl<T: Config> InlineTotalSupply for CollectionHandle<T> {
- type Error = StringError;
-
- fn total_supply(&self) -> Result<uint256> {
- // TODO: we do not track total amount of all tokens
- Ok(0.into())
- }
-}
-
-impl<T: Config> ERC721Metadata for CollectionHandle<T> {
- type Error = StringError;
-
- fn token_uri(&self, token_id: uint256) -> Result<string> {
- // TODO: We should standartize url prefix, maybe via offchain schema?
- Ok(format!("unique.network/{}/{}", self.id, token_id))
- }
-
- fn call_inline_name_symbol(&mut self, c: Msg<InlineNameSymbolCall>) -> Result<AbiWriter> {
- <Self as InlineNameSymbol>::call(self, c)
- }
-}
-
-impl<T: Config> ERC721Enumerable for CollectionHandle<T> {
- type Error = StringError;
-
- fn token_by_index(&self, index: uint256) -> Result<uint256> {
- Ok(index)
- }
-
- fn token_of_owner_by_index(&self, _owner: address, _index: uint256) -> Result<uint256> {
- // TODO: Not implemetable
- Err("not implemented".into())
- }
-
- fn call_inline_total_supply(&mut self, c: Msg<InlineTotalSupplyCall>) -> Result<AbiWriter> {
- <Self as InlineTotalSupply>::call(self, c)
- }
-}
-
-impl<T: Config> ERC721 for CollectionHandle<T> {
- type Error = StringError;
-
- fn balance_of(&self, owner: address) -> Result<uint256> {
- let owner = T::EvmAddressMapping::into_account_id(owner);
- let balance = <Balance<T>>::get(self.id, owner);
- Ok(balance.into())
- }
- fn owner_of(&self, token_id: uint256) -> Result<address> {
- let token_id: u32 = token_id.try_into().map_err(|_| "token id overflow")?;
- let token = <NftItemList<T>>::get(self.id, token_id).ok_or("unknown token")?;
- Ok(*token.owner.as_eth())
- }
- fn safe_transfer_from_with_data(
- &mut self,
- _from: address,
- _to: address,
- _token_id: uint256,
- _data: bytes,
- _value: value,
- ) -> Result<void> {
- // TODO: Not implemetable
- Err("not implemented".into())
- }
- fn safe_transfer_from(
- &mut self,
- _from: address,
- _to: address,
- _token_id: uint256,
- _value: value,
- ) -> Result<void> {
- // TODO: Not implemetable
- Err("not implemented".into())
- }
-
- fn transfer_from(
- &mut self,
- caller: caller,
- from: address,
- to: address,
- token_id: uint256,
- _value: value,
- ) -> Result<void> {
- let caller = T::CrossAccountId::from_eth(caller);
- let from = T::CrossAccountId::from_eth(from);
- let to = T::CrossAccountId::from_eth(to);
- let token_id = token_id.try_into().map_err(|_| "token_id overflow")?;
-
- <Module<T>>::transfer_from_internal(&caller, &from, &to, self, token_id, 1)
- .map_err(|_| "transferFrom error")?;
- Ok(())
- }
-
- fn approve(
- &mut self,
- caller: caller,
- approved: address,
- token_id: uint256,
- _value: value,
- ) -> Result<void> {
- let caller = T::CrossAccountId::from_eth(caller);
- let approved = T::CrossAccountId::from_eth(approved);
- let token_id = token_id.try_into().map_err(|_| "token_id overflow")?;
-
- <Module<T>>::approve_internal(&caller, &approved, self, token_id, 1)
- .map_err(|_| "approve internal")?;
- Ok(())
- }
-
- fn set_approval_for_all(
- &mut self,
- _caller: caller,
- _operator: address,
- _approved: bool,
- ) -> Result<void> {
- // TODO: Not implemetable
- Err("not implemented".into())
- }
-
- fn get_approved(&self, _token_id: uint256) -> Result<address> {
- // TODO: Not implemetable
- Err("not implemented".into())
- }
-
- fn is_approved_for_all(&self, _owner: address, _operator: address) -> Result<address> {
- // TODO: Not implemetable
- Err("not implemented".into())
- }
-
- fn call_erc165(&mut self, c: Msg<ERC165Call>) -> Result<AbiWriter> {
- let ERC165Call::SupportsInterface { interface_id } = c.call;
- Ok(evm_coder::abi_encode!(bool(
- &ERC721Call::supports_interface(interface_id)
- )))
- }
-}
-
-impl<T: Config> ERC721UniqueExtensions for CollectionHandle<T> {
- type Error = StringError;
- fn transfer(
- &mut self,
- caller: caller,
- to: address,
- token_id: uint256,
- _value: value,
- ) -> Result<void> {
- let caller = T::CrossAccountId::from_eth(caller);
- let to = T::CrossAccountId::from_eth(to);
- let token_id = token_id.try_into().map_err(|_| "amount overflow")?;
-
- <Module<T>>::transfer_internal(&caller, &to, self, token_id, 1)
- .map_err(|_| "transfer error")?;
- Ok(())
- }
-}
-
-impl<T: Config> UniqueNFT for CollectionHandle<T> {
- type Error = StringError;
- fn call_erc165(&mut self, c: Msg<ERC165Call>) -> Result<AbiWriter> {
- let ERC165Call::SupportsInterface { interface_id } = c.call;
- Ok(evm_coder::abi_encode!(bool(
- &UniqueNFTCall::supports_interface(interface_id)
- )))
- }
- fn call_erc721(&mut self, c: Msg<ERC721Call>) -> Result<AbiWriter> {
- <Self as ERC721>::call(self, c)
- }
- fn call_erc721_metadata(&mut self, c: Msg<ERC721MetadataCall>) -> Result<AbiWriter> {
- <Self as ERC721Metadata>::call(self, c)
- }
- fn call_erc721_enumerable(&mut self, c: Msg<ERC721EnumerableCall>) -> Result<AbiWriter> {
- <Self as ERC721Enumerable>::call(self, c)
- }
- fn call_erc721_unique_extensions(
- &mut self,
- c: Msg<ERC721UniqueExtensionsCall>,
- ) -> Result<AbiWriter> {
- <Self as ERC721UniqueExtensions>::call(self, c)
- }
-}
-
-impl<T: Config> ERC20 for CollectionHandle<T> {
- type Error = StringError;
- fn decimals(&self) -> Result<uint8> {
- Ok(if let CollectionMode::Fungible(decimals) = &self.mode {
- *decimals
- } else {
- unreachable!()
- })
- }
- fn balance_of(&self, owner: address) -> Result<uint256> {
- let owner = T::EvmAddressMapping::into_account_id(owner);
- let balance = <Balance<T>>::get(self.id, owner);
- Ok(balance.into())
- }
- fn transfer(&mut self, caller: caller, to: address, amount: uint256) -> Result<bool> {
- let caller = T::CrossAccountId::from_eth(caller);
- let to = T::CrossAccountId::from_eth(to);
- let amount = amount.try_into().map_err(|_| "amount overflow")?;
-
- <Module<T>>::transfer_internal(&caller, &to, self, 1, amount)
- .map_err(|_| "transfer error")?;
- Ok(true)
- }
- fn transfer_from(
- &mut self,
- caller: caller,
- from: address,
- to: address,
- amount: uint256,
- ) -> Result<bool> {
- let caller = T::CrossAccountId::from_eth(caller);
- let from = T::CrossAccountId::from_eth(from);
- let to = T::CrossAccountId::from_eth(to);
- let amount = amount.try_into().map_err(|_| "amount overflow")?;
-
- <Module<T>>::transfer_from_internal(&caller, &from, &to, self, 1, amount)
- .map_err(|_| "transferFrom error")?;
- Ok(true)
- }
- fn approve(&mut self, caller: caller, spender: address, amount: uint256) -> Result<bool> {
- let caller = T::CrossAccountId::from_eth(caller);
- let spender = T::CrossAccountId::from_eth(spender);
- let amount = amount.try_into().map_err(|_| "amount overflow")?;
-
- <Module<T>>::approve_internal(&caller, &spender, self, 1, amount)
- .map_err(|_| "approve internal")?;
- Ok(true)
- }
- fn allowance(&self, owner: address, spender: address) -> Result<uint256> {
- let owner = T::CrossAccountId::from_eth(owner);
- let spender = T::CrossAccountId::from_eth(spender);
-
- Ok(<Allowances<T>>::get(self.id, (1, owner.as_sub(), spender.as_sub())).into())
- }
- fn call_inline_name_symbol(&mut self, c: Msg<InlineNameSymbolCall>) -> Result<AbiWriter> {
- <Self as InlineNameSymbol>::call(self, c)
- }
- fn call_inline_total_supply(&mut self, c: Msg<InlineTotalSupplyCall>) -> Result<AbiWriter> {
- <Self as InlineTotalSupply>::call(self, c)
- }
-}
-
-impl<T: Config> UniqueFungible for CollectionHandle<T> {
- type Error = StringError;
- fn call_erc165(&mut self, c: Msg<ERC165Call>) -> Result<AbiWriter> {
- let ERC165Call::SupportsInterface { interface_id } = c.call;
- Ok(evm_coder::abi_encode!(bool(
- &UniqueNFTCall::supports_interface(interface_id)
- )))
- }
- fn call_erc20(&mut self, c: Msg<ERC20Call>) -> Result<AbiWriter> {
- <Self as ERC20>::call(self, c)
- }
-}
pallets/nft/src/eth/log.rsdiffbeforeafterboth--- a/pallets/nft/src/eth/log.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-use sp_std::cell::RefCell;
-use sp_std::vec::Vec;
-
-use ethereum::Log;
-
-#[derive(Default)]
-pub struct LogRecorder(RefCell<Vec<Log>>);
-
-impl LogRecorder {
- pub fn is_empty(&self) -> bool {
- self.0.borrow().is_empty()
- }
- pub fn log(&self, log: Log) {
- self.0.borrow_mut().push(log);
- }
- pub fn retrieve_logs(self) -> Vec<Log> {
- self.0.into_inner()
- }
-}
pallets/nft/src/eth/mod.rsdiffbeforeafterboth--- a/pallets/nft/src/eth/mod.rs
+++ b/pallets/nft/src/eth/mod.rs
@@ -1,23 +1,15 @@
pub mod account;
pub mod erc;
-mod erc_impl;
-pub mod log;
pub mod sponsoring;
-use evm_coder::abi::AbiWriter;
-use evm_coder::abi::StringError;
-use sp_std::prelude::*;
+use pallet_evm_coder_substrate::call_internal;
use sp_std::borrow::ToOwned;
use sp_std::vec::Vec;
-
-use pallet_evm::{PrecompileOutput, ExitReason, ExitRevert, ExitSucceed};
+use pallet_evm::{PrecompileOutput};
use sp_core::{H160, U256};
use frame_support::storage::StorageMap;
-
use crate::{Config, CollectionById, CollectionHandle, CollectionId, CollectionMode};
-
-use erc::{UniqueFungible, UniqueFungibleCall, UniqueNFT, UniqueNFTCall};
-use evm_coder::{types::*, abi::AbiReader};
+use erc::{UniqueFungibleCall, UniqueNFTCall};
pub struct NftErcSupport<T: Config>(core::marker::PhantomData<T>);
@@ -42,19 +34,17 @@
H160(out)
}
+/*
fn call_internal<T: Config>(
collection: &mut CollectionHandle<T>,
caller: caller,
method_id: u32,
mut input: AbiReader,
value: U256,
-) -> Result<Option<AbiWriter>, evm_coder::abi::StringError> {
+) -> Result<Option<AbiWriter>> {
match collection.mode.clone() {
CollectionMode::Fungible(_) => {
- #[cfg(feature = "std")]
- {
- println!("Parse fungible call {:x}", method_id);
- }
+ call_internal();
let call = match UniqueFungibleCall::parse(method_id, &mut input)? {
Some(v) => v,
None => {
@@ -65,10 +55,6 @@
return Ok(None);
}
};
- #[cfg(feature = "std")]
- {
- dbg!(&call);
- }
Ok(Some(<CollectionHandle<T> as UniqueFungible>::call(
collection,
Msg {
@@ -92,11 +78,9 @@
},
)?))
}
- _ => Err(StringError::from(
- "erc calls only supported to fungible and nft collections for now",
- )),
+ _ => Err("erc calls only supported to fungible and nft collections for now".into()),
}
-}
+}*/
impl<T: Config> pallet_evm::OnMethodCall<T> for NftErcSupport<T> {
fn is_reserved(target: &H160) -> bool {
@@ -129,56 +113,15 @@
) -> Option<PrecompileOutput> {
let mut collection = map_eth_to_id(target)
.and_then(|id| <CollectionHandle<T>>::get_with_gas_limit(id, gas_limit))?;
- let (method_id, input) = AbiReader::new_call(input).unwrap();
- let result = call_internal(&mut collection, *source, method_id, input, value);
- let cost = gas_limit - collection.gas_left();
- let logs = collection.logs.retrieve_logs();
- match result {
- Ok(Some(v)) => Some(PrecompileOutput {
- exit_status: ExitReason::Succeed(ExitSucceed::Returned),
- cost,
- logs,
- output: v.finish(),
- }),
- Ok(None) => None,
- Err(e) => Some(PrecompileOutput {
- exit_status: ExitReason::Revert(ExitRevert::Reverted),
- cost: 0,
- logs: Default::default(),
- output: AbiWriter::from(e).finish(),
- }),
- }
- }
-}
-
-// TODO: This function is slow, and output can be memoized
-pub fn generate_transaction(collection_id: u32, chain_id: u64) -> ethereum::Transaction {
- // FIXME: Can be done on wasm runtime with https://github.com/paritytech/substrate/pull/8728
- #[cfg(feature = "std")]
- {
- let contract = collection_id_to_address(collection_id);
- let signed = ethereum_tx_sign::RawTransaction {
- nonce: 0.into(),
- to: Some(contract.0.into()),
- value: 0.into(),
- gas_price: 0.into(),
- gas: 0.into(),
- // zero selector, this transaction always have same sender, so all data should be acquired from logs
- data: Vec::from([0, 0, 0, 0]),
- }
- .sign(
- // TODO: move to pallet config
- // 0xF70631E55faff9f3FD3681545aa6c724226a3853
- // 9dbaef9b3ebc00e53f67c6a77bcfbf2c4f2aebe4d70d94af4f2df01744b7a91a
- &hex_literal::hex!("9dbaef9b3ebc00e53f67c6a77bcfbf2c4f2aebe4d70d94af4f2df01744b7a91a")
- .into(),
- &chain_id,
- );
- rlp::decode::<ethereum::Transaction>(&signed)
- .expect("transaction is just created, it can't be broken")
- }
- #[cfg(not(feature = "std"))]
- {
- panic!("transaction generation not yet supported by wasm runtime while generating transaction for collection_id {}, chain_id {}", collection_id, chain_id)
+ let result = match collection.mode {
+ CollectionMode::NFT => {
+ call_internal::<UniqueNFTCall, _>(*source, &mut collection, value, input)
+ }
+ CollectionMode::Fungible(_) => {
+ call_internal::<UniqueFungibleCall, _>(*source, &mut collection, value, input)
+ }
+ _ => return None,
+ };
+ collection.recorder.evm_to_precompile_output(result)
}
}
pallets/nft/src/lib.rsdiffbeforeafterboth1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56#![recursion_limit = "1024"]7#![cfg_attr(not(feature = "std"), no_std)]8#![allow(9 clippy::too_many_arguments,10 clippy::unnecessary_mut_passed,11 clippy::unused_unit12)]1314extern crate alloc;1516pub use serde::{Serialize, Deserialize};1718pub use frame_support::{19 construct_runtime, decl_event, decl_module, decl_storage, decl_error,20 dispatch::DispatchResult,21 ensure, fail, parameter_types,22 traits::{23 Currency, ExistenceRequirement, Get, Imbalance, KeyOwnerProofSystem, OnUnbalanced,24 Randomness, IsSubType, WithdrawReasons,25 },26 weights::{27 constants::{BlockExecutionWeight, ExtrinsicBaseWeight, RocksDbWeight, WEIGHT_PER_SECOND},28 DispatchInfo, GetDispatchInfo, IdentityFee, Pays, PostDispatchInfo, Weight,29 WeightToFeePolynomial, DispatchClass,30 },31 StorageValue, transactional,32};3334use frame_system::{self as system, ensure_signed, ensure_root};35use sp_core::H160;36use sp_std::vec;37use sp_runtime::sp_std::prelude::Vec;38use core::ops::{Deref, DerefMut};39use nft_data_structs::{40 MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,41 AccessMode, ChainLimits, Collection, CreateItemData, CollectionLimits, CollectionId,42 CollectionMode, TokenId, SchemaVersion, SponsorshipState, Ownership, NftItemType,43 FungibleItemType, ReFungibleItemType,44};4546#[cfg(test)]47mod mock;4849#[cfg(test)]50mod tests;5152mod default_weights;53mod eth;54mod sponsorship;55pub use sponsorship::NftSponsorshipHandler;56pub use eth::sponsoring::NftEthSponsorshipHandler;5758pub use eth::NftErcSupport;59pub use eth::account::*;60use eth::erc::{ERC20Events, ERC721Events};6162#[cfg(feature = "runtime-benchmarks")]63mod benchmarking;6465pub trait WeightInfo {66 fn create_collection() -> Weight;67 fn destroy_collection() -> Weight;68 fn add_to_white_list() -> Weight;69 fn remove_from_white_list() -> Weight;70 fn set_public_access_mode() -> Weight;71 fn set_mint_permission() -> Weight;72 fn change_collection_owner() -> Weight;73 fn add_collection_admin() -> Weight;74 fn remove_collection_admin() -> Weight;75 fn set_collection_sponsor() -> Weight;76 fn confirm_sponsorship() -> Weight;77 fn remove_collection_sponsor() -> Weight;78 fn create_item(s: usize) -> Weight;79 fn burn_item() -> Weight;80 fn transfer() -> Weight;81 fn approve() -> Weight;82 fn transfer_from() -> Weight;83 fn set_offchain_schema() -> Weight;84 fn set_const_on_chain_schema() -> Weight;85 fn set_variable_on_chain_schema() -> Weight;86 fn set_variable_meta_data() -> Weight;87 fn enable_contract_sponsoring() -> Weight;88 fn set_schema_version() -> Weight;89 fn set_chain_limits() -> Weight;90 fn set_contract_sponsoring_rate_limit() -> Weight;91 fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;92 fn toggle_contract_white_list() -> Weight;93 fn add_to_contract_white_list() -> Weight;94 fn remove_from_contract_white_list() -> Weight;95 fn set_collection_limits() -> Weight;96}9798decl_error! {99 /// Error for non-fungible-token module.100 pub enum Error for Module<T: Config> {101 /// Total collections bound exceeded.102 TotalCollectionsLimitExceeded,103 /// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.104 CollectionDecimalPointLimitExceeded,105 /// Collection name can not be longer than 63 char.106 CollectionNameLimitExceeded,107 /// Collection description can not be longer than 255 char.108 CollectionDescriptionLimitExceeded,109 /// Token prefix can not be longer than 15 char.110 CollectionTokenPrefixLimitExceeded,111 /// This collection does not exist.112 CollectionNotFound,113 /// Item not exists.114 TokenNotFound,115 /// Admin not found116 AdminNotFound,117 /// Arithmetic calculation overflow.118 NumOverflow,119 /// Account already has admin role.120 AlreadyAdmin,121 /// You do not own this collection.122 NoPermission,123 /// This address is not set as sponsor, use setCollectionSponsor first.124 ConfirmUnsetSponsorFail,125 /// Collection is not in mint mode.126 PublicMintingNotAllowed,127 /// Sender parameter and item owner must be equal.128 MustBeTokenOwner,129 /// Item balance not enough.130 TokenValueTooLow,131 /// Size of item is too large.132 NftSizeLimitExceeded,133 /// No approve found134 ApproveNotFound,135 /// Requested value more than approved.136 TokenValueNotEnough,137 /// Only approved addresses can call this method.138 ApproveRequired,139 /// Address is not in white list.140 AddresNotInWhiteList,141 /// Number of collection admins bound exceeded.142 CollectionAdminsLimitExceeded,143 /// Owned tokens by a single address bound exceeded.144 AddressOwnershipLimitExceeded,145 /// Length of items properties must be greater than 0.146 EmptyArgument,147 /// const_data exceeded data limit.148 TokenConstDataLimitExceeded,149 /// variable_data exceeded data limit.150 TokenVariableDataLimitExceeded,151 /// Not NFT item data used to mint in NFT collection.152 NotNftDataUsedToMintNftCollectionToken,153 /// Not Fungible item data used to mint in Fungible collection.154 NotFungibleDataUsedToMintFungibleCollectionToken,155 /// Not Re Fungible item data used to mint in Re Fungible collection.156 NotReFungibleDataUsedToMintReFungibleCollectionToken,157 /// Unexpected collection type.158 UnexpectedCollectionType,159 /// Can't store metadata in fungible tokens.160 CantStoreMetadataInFungibleTokens,161 /// Collection token limit exceeded162 CollectionTokenLimitExceeded,163 /// Account token limit exceeded per collection164 AccountTokenLimitExceeded,165 /// Collection limit bounds per collection exceeded166 CollectionLimitBoundsExceeded,167 /// Tried to enable permissions which are only permitted to be disabled168 OwnerPermissionsCantBeReverted,169 /// Schema data size limit bound exceeded170 SchemaDataLimitExceeded,171 /// Maximum refungibility exceeded172 WrongRefungiblePieces,173 /// createRefungible should be called with one owner174 BadCreateRefungibleCall,175 /// Gas limit exceeded176 OutOfGas,177 }178}179180#[must_use = "Should call submit_logs or save, otherwise some data will be lost for evm side"]181pub struct CollectionHandle<T: Config> {182 pub id: CollectionId,183 collection: Collection<T>,184 recorder: pallet_evm_coder_substrate::SubstrateRecorder<T>,185}186impl<T: Config> CollectionHandle<T> {187 pub fn get_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {188 <CollectionById<T>>::get(id).map(|collection| Self {189 id,190 collection,191 recorder: pallet_evm_coder_substrate::SubstrateRecorder::new(192 eth::collection_id_to_address(id),193 gas_limit,194 ),195 })196 }197 pub fn get(id: CollectionId) -> Option<Self> {198 Self::get_with_gas_limit(id, u64::MAX)199 }200 pub fn log(&self, log: impl evm_coder::ToLog) -> DispatchResult {201 self.recorder.log_sub(log)202 }203 fn consume_gas(&self, gas: u64) -> DispatchResult {204 self.recorder.consume_gas_sub(gas)205 }206 pub fn submit_logs(self) -> DispatchResult {207 self.recorder.submit_logs()208 }209 pub fn save(self) -> DispatchResult {210 self.recorder.submit_logs()?;211 <CollectionById<T>>::insert(self.id, self.collection);212 Ok(())213 }214}215impl<T: Config> Deref for CollectionHandle<T> {216 type Target = Collection<T>;217218 fn deref(&self) -> &Self::Target {219 &self.collection220 }221}222223impl<T: Config> DerefMut for CollectionHandle<T> {224 fn deref_mut(&mut self) -> &mut Self::Target {225 &mut self.collection226 }227}228229pub trait Config: system::Config + pallet_evm_coder_substrate::Config + Sized {230 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;231232 /// Weight information for extrinsics in this pallet.233 type WeightInfo: WeightInfo;234235 type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;236 type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;237238 type CrossAccountId: CrossAccountId<Self::AccountId>;239 type Currency: Currency<Self::AccountId>;240 type CollectionCreationPrice: Get<241 <<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,242 >;243 type TreasuryAccountId: Get<Self::AccountId>;244}245246// # Used definitions247//248// ## User control levels249//250// chain-controlled - key is uncontrolled by user251// i.e autoincrementing index252// can use non-cryptographic hash253// real - key is controlled by user254// but it is hard to generate enough colliding values, i.e owner of signed txs255// can use non-cryptographic hash256// controlled - key is completly controlled by users257// i.e maps with mutable keys258// should use cryptographic hash259//260// ## User control level downgrade reasons261//262// ?1 - chain-controlled -> controlled263// collections/tokens can be destroyed, resulting in massive holes264// ?2 - chain-controlled -> controlled265// same as ?1, but can be only added, resulting in easier exploitation266// ?3 - real -> controlled267// no confirmation required, so addresses can be easily generated268decl_storage! {269 trait Store for Module<T: Config> as Nft {270271 //#region Private members272 /// Id of next collection273 CreatedCollectionCount: u32;274 /// Used for migrations275 ChainVersion: u64;276 /// Id of last collection token277 /// Collection id (controlled?1)278 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;279 //#endregion280281 //#region Chain limits struct282 pub ChainLimit get(fn chain_limit) config(): ChainLimits;283 //#endregion284285 //#region Bound counters286 /// Amount of collections destroyed, used for total amount tracking with287 /// CreatedCollectionCount288 DestroyedCollectionCount: u32;289 /// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)290 /// Account id (real)291 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;292 //#endregion293294 //#region Basic collections295 /// Collection info296 /// Collection id (controlled?1)297 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;298 /// List of collection admins299 /// Collection id (controlled?2)300 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;301 /// Whitelisted collection users302 /// Collection id (controlled?2), user id (controlled?3)303 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;304 //#endregion305306 /// How many of collection items user have307 /// Collection id (controlled?2), account id (real)308 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;309310 /// Amount of items which spender can transfer out of owners account (via transferFrom)311 /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))312 /// TODO: Off chain worker should remove from this map when token gets removed313 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;314315 //#region Item collections316 /// Collection id (controlled?2), token id (controlled?1)317 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;318 /// Collection id (controlled?2), owner (controlled?2)319 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;320 /// Collection id (controlled?2), token id (controlled?1)321 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;322 //#endregion323324 //#region Index list325 /// Collection id (controlled?2), tokens owner (controlled?2)326 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;327 //#endregion328329 //#region Tokens transfer rate limit baskets330 /// (Collection id (controlled?2), who created (real))331 /// TODO: Off chain worker should remove from this map when collection gets removed332 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;333 /// Collection id (controlled?2), token id (controlled?2)334 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;335 /// Collection id (controlled?2), owning user (real)336 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;337 /// Collection id (controlled?2), token id (controlled?2)338 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;339 //#endregion340341 /// Variable metadata sponsoring342 /// Collection id (controlled?2), token id (controlled?2)343 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;344 }345 add_extra_genesis {346 build(|config: &GenesisConfig<T>| {347 // Modification of storage348 for (_num, _c) in &config.collection_id {349 <Module<T>>::init_collection(_c);350 }351352 for (_num, _c, _i) in &config.nft_item_id {353 <Module<T>>::init_nft_token(*_c, _i);354 }355356 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {357 <Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);358 }359360 for (_num, _c, _i) in &config.refungible_item_id {361 <Module<T>>::init_refungible_token(*_c, _i);362 }363 })364 }365}366367decl_event!(368 pub enum Event<T>369 where370 AccountId = <T as frame_system::Config>::AccountId,371 CrossAccountId = <T as Config>::CrossAccountId,372 {373 /// New collection was created374 ///375 /// # Arguments376 ///377 /// * collection_id: Globally unique identifier of newly created collection.378 ///379 /// * mode: [CollectionMode] converted into u8.380 ///381 /// * account_id: Collection owner.382 CollectionCreated(CollectionId, u8, AccountId),383384 /// New item was created.385 ///386 /// # Arguments387 ///388 /// * collection_id: Id of the collection where item was created.389 ///390 /// * item_id: Id of an item. Unique within the collection.391 ///392 /// * recipient: Owner of newly created item393 ItemCreated(CollectionId, TokenId, CrossAccountId),394395 /// Collection item was burned.396 ///397 /// # Arguments398 ///399 /// collection_id.400 ///401 /// item_id: Identifier of burned NFT.402 ItemDestroyed(CollectionId, TokenId),403404 /// Item was transferred405 ///406 /// * collection_id: Id of collection to which item is belong407 ///408 /// * item_id: Id of an item409 ///410 /// * sender: Original owner of item411 ///412 /// * recipient: New owner of item413 ///414 /// * amount: Always 1 for NFT415 Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),416417 /// * collection_id418 ///419 /// * item_id420 ///421 /// * sender422 ///423 /// * spender424 ///425 /// * amount426 Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),427 }428);429430decl_module! {431 pub struct Module<T: Config> for enum Call432 where433 origin: T::Origin434 {435 fn deposit_event() = default;436 type Error = Error<T>;437438 fn on_initialize(_now: T::BlockNumber) -> Weight {439 0440 }441442 /// This method creates a Collection of NFTs. Each Token may have multiple properties encoded as an array of bytes of certain length. The initial owner and admin of the collection are set to the address that signed the transaction. Both addresses can be changed later.443 ///444 /// # Permissions445 ///446 /// * Anyone.447 ///448 /// # Arguments449 ///450 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.451 ///452 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.453 ///454 /// * token_prefix: UTF-8 string with token prefix.455 ///456 /// * mode: [CollectionMode] collection type and type dependent data.457 // returns collection ID458 #[weight = <T as Config>::WeightInfo::create_collection()]459 #[transactional]460 pub fn create_collection(origin,461 collection_name: Vec<u16>,462 collection_description: Vec<u16>,463 token_prefix: Vec<u8>,464 mode: CollectionMode) -> DispatchResult {465466 // Anyone can create a collection467 let who = ensure_signed(origin)?;468469 // Take a (non-refundable) deposit of collection creation470 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();471 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(472 &T::TreasuryAccountId::get(),473 T::CollectionCreationPrice::get(),474 ));475 <T as Config>::Currency::settle(476 &who,477 imbalance,478 WithdrawReasons::TRANSFER,479 ExistenceRequirement::KeepAlive,480 ).map_err(|_| Error::<T>::NoPermission)?;481482 let decimal_points = match mode {483 CollectionMode::Fungible(points) => points,484 _ => 0485 };486487 let chain_limit = ChainLimit::get();488489 let created_count = CreatedCollectionCount::get();490 let destroyed_count = DestroyedCollectionCount::get();491492 // bound Total number of collections493 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);494495 // check params496 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);497 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);498 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);499 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);500501 // Generate next collection ID502 let next_id = created_count503 .checked_add(1)504 .ok_or(Error::<T>::NumOverflow)?;505506 CreatedCollectionCount::put(next_id);507508 let limits = CollectionLimits {509 sponsored_data_size: chain_limit.custom_data_limit,510 ..Default::default()511 };512513 // Create new collection514 let new_collection = Collection {515 owner: who.clone(),516 name: collection_name,517 mode: mode.clone(),518 mint_mode: false,519 access: AccessMode::Normal,520 description: collection_description,521 decimal_points,522 token_prefix,523 offchain_schema: Vec::new(),524 schema_version: SchemaVersion::ImageURL,525 sponsorship: SponsorshipState::Disabled,526 variable_on_chain_schema: Vec::new(),527 const_on_chain_schema: Vec::new(),528 limits,529 };530531 // Add new collection to map532 <CollectionById<T>>::insert(next_id, new_collection);533534 // call event535 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));536537 Ok(())538 }539540 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.541 ///542 /// # Permissions543 ///544 /// * Collection Owner.545 ///546 /// # Arguments547 ///548 /// * collection_id: collection to destroy.549 #[weight = <T as Config>::WeightInfo::destroy_collection()]550 #[transactional]551 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {552553 let sender = ensure_signed(origin)?;554 let collection = Self::get_collection(collection_id)?;555 Self::check_owner_permissions(&collection, &sender)?;556 if !collection.limits.owner_can_destroy {557 fail!(Error::<T>::NoPermission);558 }559560 <AddressTokens<T>>::remove_prefix(collection_id, None);561 <Allowances<T>>::remove_prefix(collection_id, None);562 <Balance<T>>::remove_prefix(collection_id, None);563 <ItemListIndex>::remove(collection_id);564 <AdminList<T>>::remove(collection_id);565 <CollectionById<T>>::remove(collection_id);566 <WhiteList<T>>::remove_prefix(collection_id, None);567568 <NftItemList<T>>::remove_prefix(collection_id, None);569 <FungibleItemList<T>>::remove_prefix(collection_id, None);570 <ReFungibleItemList<T>>::remove_prefix(collection_id, None);571572 <NftTransferBasket<T>>::remove_prefix(collection_id, None);573 <FungibleTransferBasket<T>>::remove_prefix(collection_id, None);574 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id, None);575576 <VariableMetaDataBasket<T>>::remove_prefix(collection_id, None);577578 DestroyedCollectionCount::put(DestroyedCollectionCount::get()579 .checked_add(1)580 .ok_or(Error::<T>::NumOverflow)?);581582 Ok(())583 }584585 /// Add an address to white list.586 ///587 /// # Permissions588 ///589 /// * Collection Owner590 /// * Collection Admin591 ///592 /// # Arguments593 ///594 /// * collection_id.595 ///596 /// * address.597 #[weight = <T as Config>::WeightInfo::add_to_white_list()]598 #[transactional]599 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{600601 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);602 let collection = Self::get_collection(collection_id)?;603604 Self::toggle_white_list_internal(605 &sender,606 &collection,607 &address,608 true,609 )?;610611 Ok(())612 }613614 /// Remove an address from white list.615 ///616 /// # Permissions617 ///618 /// * Collection Owner619 /// * Collection Admin620 ///621 /// # Arguments622 ///623 /// * collection_id.624 ///625 /// * address.626 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]627 #[transactional]628 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{629630 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);631 let collection = Self::get_collection(collection_id)?;632633 Self::toggle_white_list_internal(634 &sender,635 &collection,636 &address,637 false,638 )?;639640 Ok(())641 }642643 /// Toggle between normal and white list access for the methods with access for `Anyone`.644 ///645 /// # Permissions646 ///647 /// * Collection Owner.648 ///649 /// # Arguments650 ///651 /// * collection_id.652 ///653 /// * mode: [AccessMode]654 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]655 #[transactional]656 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult657 {658 let sender = ensure_signed(origin)?;659660 let mut target_collection = Self::get_collection(collection_id)?;661 Self::check_owner_permissions(&target_collection, &sender)?;662 target_collection.access = mode;663 target_collection.save()664 }665666 /// Allows Anyone to create tokens if:667 /// * White List is enabled, and668 /// * Address is added to white list, and669 /// * This method was called with True parameter670 ///671 /// # Permissions672 /// * Collection Owner673 ///674 /// # Arguments675 ///676 /// * collection_id.677 ///678 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.679 #[weight = <T as Config>::WeightInfo::set_mint_permission()]680 #[transactional]681 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult682 {683 let sender = ensure_signed(origin)?;684685 let mut target_collection = Self::get_collection(collection_id)?;686 Self::check_owner_permissions(&target_collection, &sender)?;687 target_collection.mint_mode = mint_permission;688 target_collection.save()689 }690691 /// Change the owner of the collection.692 ///693 /// # Permissions694 ///695 /// * Collection Owner.696 ///697 /// # Arguments698 ///699 /// * collection_id.700 ///701 /// * new_owner.702 #[weight = <T as Config>::WeightInfo::change_collection_owner()]703 #[transactional]704 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {705706 let sender = ensure_signed(origin)?;707 let mut target_collection = Self::get_collection(collection_id)?;708 Self::check_owner_permissions(&target_collection, &sender)?;709 target_collection.owner = new_owner;710 target_collection.save()711 }712713 /// Adds an admin of the Collection.714 /// NFT Collection can be controlled by multiple admin addresses (some which can also be servers, for example). Admins can issue and burn NFTs, as well as add and remove other admins, but cannot change NFT or Collection ownership.715 ///716 /// # Permissions717 ///718 /// * Collection Owner.719 /// * Collection Admin.720 ///721 /// # Arguments722 ///723 /// * collection_id: ID of the Collection to add admin for.724 ///725 /// * new_admin_id: Address of new admin to add.726 #[weight = <T as Config>::WeightInfo::add_collection_admin()]727 #[transactional]728 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {729 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);730 let collection = Self::get_collection(collection_id)?;731 Self::check_owner_or_admin_permissions(&collection, &sender)?;732 let mut admin_arr = <AdminList<T>>::get(collection_id);733734 match admin_arr.binary_search(&new_admin_id) {735 Ok(_) => {},736 Err(idx) => {737 let limits = ChainLimit::get();738 ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);739 admin_arr.insert(idx, new_admin_id);740 <AdminList<T>>::insert(collection_id, admin_arr);741 }742 }743 Ok(())744 }745746 /// Remove admin address of the Collection. An admin address can remove itself. List of admins may become empty, in which case only Collection Owner will be able to add an Admin.747 ///748 /// # Permissions749 ///750 /// * Collection Owner.751 /// * Collection Admin.752 ///753 /// # Arguments754 ///755 /// * collection_id: ID of the Collection to remove admin for.756 ///757 /// * account_id: Address of admin to remove.758 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]759 #[transactional]760 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {761 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);762 let collection = Self::get_collection(collection_id)?;763 Self::check_owner_or_admin_permissions(&collection, &sender)?;764 let mut admin_arr = <AdminList<T>>::get(collection_id);765766 if let Ok(idx) = admin_arr.binary_search(&account_id) {767 admin_arr.remove(idx);768 <AdminList<T>>::insert(collection_id, admin_arr);769 }770 Ok(())771 }772773 /// # Permissions774 ///775 /// * Collection Owner776 ///777 /// # Arguments778 ///779 /// * collection_id.780 ///781 /// * new_sponsor.782 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]783 #[transactional]784 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {785 let sender = ensure_signed(origin)?;786 let mut target_collection = Self::get_collection(collection_id)?;787 Self::check_owner_permissions(&target_collection, &sender)?;788789 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);790 target_collection.save()791 }792793 /// # Permissions794 ///795 /// * Sponsor.796 ///797 /// # Arguments798 ///799 /// * collection_id.800 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]801 #[transactional]802 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {803 let sender = ensure_signed(origin)?;804805 let mut target_collection = Self::get_collection(collection_id)?;806 ensure!(807 target_collection.sponsorship.pending_sponsor() == Some(&sender),808 Error::<T>::ConfirmUnsetSponsorFail809 );810811 target_collection.sponsorship = SponsorshipState::Confirmed(sender);812 target_collection.save()813 }814815 /// Switch back to pay-per-own-transaction model.816 ///817 /// # Permissions818 ///819 /// * Collection owner.820 ///821 /// # Arguments822 ///823 /// * collection_id.824 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]825 #[transactional]826 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {827 let sender = ensure_signed(origin)?;828829 let mut target_collection = Self::get_collection(collection_id)?;830 Self::check_owner_permissions(&target_collection, &sender)?;831832 target_collection.sponsorship = SponsorshipState::Disabled;833 target_collection.save()834 }835836 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.837 ///838 /// # Permissions839 ///840 /// * Collection Owner.841 /// * Collection Admin.842 /// * Anyone if843 /// * White List is enabled, and844 /// * Address is added to white list, and845 /// * MintPermission is enabled (see SetMintPermission method)846 ///847 /// # Arguments848 ///849 /// * collection_id: ID of the collection.850 ///851 /// * owner: Address, initial owner of the NFT.852 ///853 /// * data: Token data to store on chain.854 // #[weight =855 // (130_000_000 as Weight)856 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))857 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))858 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]859860 #[weight = <T as Config>::WeightInfo::create_item(data.data_size())]861 #[transactional]862 pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {863 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);864 let collection = Self::get_collection(collection_id)?;865866 Self::create_item_internal(&sender, &collection, &owner, data)?;867868 collection.submit_logs()869 }870871 /// This method creates multiple items in a collection created with CreateCollection method.872 ///873 /// # Permissions874 ///875 /// * Collection Owner.876 /// * Collection Admin.877 /// * Anyone if878 /// * White List is enabled, and879 /// * Address is added to white list, and880 /// * MintPermission is enabled (see SetMintPermission method)881 ///882 /// # Arguments883 ///884 /// * collection_id: ID of the collection.885 ///886 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].887 ///888 /// * owner: Address, initial owner of the NFT.889 #[weight = <T as Config>::WeightInfo::create_item(items_data.iter()890 .map(|data| { data.data_size() })891 .sum())]892 #[transactional]893 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {894895 ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);896 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);897 let collection = Self::get_collection(collection_id)?;898899 Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;900901 collection.submit_logs()902 }903904 /// Destroys a concrete instance of NFT.905 ///906 /// # Permissions907 ///908 /// * Collection Owner.909 /// * Collection Admin.910 /// * Current NFT Owner.911 ///912 /// # Arguments913 ///914 /// * collection_id: ID of the collection.915 ///916 /// * item_id: ID of NFT to burn.917 #[weight = <T as Config>::WeightInfo::burn_item()]918 #[transactional]919 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {920921 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);922 let target_collection = Self::get_collection(collection_id)?;923924 Self::burn_item_internal(&sender, &target_collection, item_id, value)?;925926 target_collection.submit_logs()927 }928929 /// Change ownership of the token.930 ///931 /// # Permissions932 ///933 /// * Collection Owner934 /// * Collection Admin935 /// * Current NFT owner936 ///937 /// # Arguments938 ///939 /// * recipient: Address of token recipient.940 ///941 /// * collection_id.942 ///943 /// * item_id: ID of the item944 /// * Non-Fungible Mode: Required.945 /// * Fungible Mode: Ignored.946 /// * Re-Fungible Mode: Required.947 ///948 /// * value: Amount to transfer.949 /// * Non-Fungible Mode: Ignored950 /// * Fungible Mode: Must specify transferred amount951 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)952 #[weight = <T as Config>::WeightInfo::transfer()]953 #[transactional]954 pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {955 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);956 let collection = Self::get_collection(collection_id)?;957958 Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;959960 collection.submit_logs()961 }962963 /// Set, change, or remove approved address to transfer the ownership of the NFT.964 ///965 /// # Permissions966 ///967 /// * Collection Owner968 /// * Collection Admin969 /// * Current NFT owner970 ///971 /// # Arguments972 ///973 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).974 ///975 /// * collection_id.976 ///977 /// * item_id: ID of the item.978 #[weight = <T as Config>::WeightInfo::approve()]979 #[transactional]980 pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {981 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);982 let collection = Self::get_collection(collection_id)?;983984 Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;985986 collection.submit_logs()987 }988989 /// Change ownership of a NFT on behalf of the owner. See Approve method for additional information. After this method executes, the approval is removed so that the approved address will not be able to transfer this NFT again from this owner.990 ///991 /// # Permissions992 /// * Collection Owner993 /// * Collection Admin994 /// * Current NFT owner995 /// * Address approved by current NFT owner996 ///997 /// # Arguments998 ///999 /// * from: Address that owns token.1000 ///1001 /// * recipient: Address of token recipient.1002 ///1003 /// * collection_id.1004 ///1005 /// * item_id: ID of the item.1006 ///1007 /// * value: Amount to transfer.1008 #[weight = <T as Config>::WeightInfo::transfer_from()]1009 #[transactional]1010 pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1011 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1012 let collection = Self::get_collection(collection_id)?;10131014 Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;10151016 collection.submit_logs()1017 }1018 // #[weight = 0]1019 // // let no_perm_mes = "You do not have permissions to modify this collection";1020 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1021 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1022 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);10231024 // // // on_nft_received call10251026 // // Self::transfer(origin, collection_id, item_id, new_owner)?;10271028 // Ok(())1029 // }10301031 /// Set off-chain data schema.1032 ///1033 /// # Permissions1034 ///1035 /// * Collection Owner1036 /// * Collection Admin1037 ///1038 /// # Arguments1039 ///1040 /// * collection_id.1041 ///1042 /// * schema: String representing the offchain data schema.1043 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1044 #[transactional]1045 pub fn set_variable_meta_data (1046 origin,1047 collection_id: CollectionId,1048 item_id: TokenId,1049 data: Vec<u8>1050 ) -> DispatchResult {1051 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);10521053 let collection = Self::get_collection(collection_id)?;10541055 Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;10561057 Ok(())1058 }10591060 /// Set schema standard1061 /// ImageURL1062 /// Unique1063 ///1064 /// # Permissions1065 ///1066 /// * Collection Owner1067 /// * Collection Admin1068 ///1069 /// # Arguments1070 ///1071 /// * collection_id.1072 ///1073 /// * schema: SchemaVersion: enum1074 #[weight = <T as Config>::WeightInfo::set_schema_version()]1075 #[transactional]1076 pub fn set_schema_version(1077 origin,1078 collection_id: CollectionId,1079 version: SchemaVersion1080 ) -> DispatchResult {1081 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1082 let mut target_collection = Self::get_collection(collection_id)?;1083 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1084 target_collection.schema_version = version;1085 target_collection.save()1086 }10871088 /// Set off-chain data schema.1089 ///1090 /// # Permissions1091 ///1092 /// * Collection Owner1093 /// * Collection Admin1094 ///1095 /// # Arguments1096 ///1097 /// * collection_id.1098 ///1099 /// * schema: String representing the offchain data schema.1100 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1101 #[transactional]1102 pub fn set_offchain_schema(1103 origin,1104 collection_id: CollectionId,1105 schema: Vec<u8>1106 ) -> DispatchResult {1107 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1108 let mut target_collection = Self::get_collection(collection_id)?;1109 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11101111 // check schema limit1112 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");11131114 target_collection.offchain_schema = schema;1115 target_collection.save()1116 }11171118 /// Set const on-chain data schema.1119 ///1120 /// # Permissions1121 ///1122 /// * Collection Owner1123 /// * Collection Admin1124 ///1125 /// # Arguments1126 ///1127 /// * collection_id.1128 ///1129 /// * schema: String representing the const on-chain data schema.1130 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1131 #[transactional]1132 pub fn set_const_on_chain_schema (1133 origin,1134 collection_id: CollectionId,1135 schema: Vec<u8>1136 ) -> DispatchResult {1137 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1138 let mut target_collection = Self::get_collection(collection_id)?;1139 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11401141 // check schema limit1142 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");11431144 target_collection.const_on_chain_schema = schema;1145 target_collection.save()1146 }11471148 /// Set variable on-chain data schema.1149 ///1150 /// # Permissions1151 ///1152 /// * Collection Owner1153 /// * Collection Admin1154 ///1155 /// # Arguments1156 ///1157 /// * collection_id.1158 ///1159 /// * schema: String representing the variable on-chain data schema.1160 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1161 #[transactional]1162 pub fn set_variable_on_chain_schema (1163 origin,1164 collection_id: CollectionId,1165 schema: Vec<u8>1166 ) -> DispatchResult {1167 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1168 let mut target_collection = Self::get_collection(collection_id)?;1169 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11701171 // check schema limit1172 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");11731174 target_collection.variable_on_chain_schema = schema;1175 target_collection.save()1176 }11771178 // Sudo permissions function1179 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1180 #[transactional]1181 pub fn set_chain_limits(1182 origin,1183 limits: ChainLimits1184 ) -> DispatchResult {11851186 #[cfg(not(feature = "runtime-benchmarks"))]1187 ensure_root(origin)?;11881189 <ChainLimit>::put(limits);1190 Ok(())1191 }11921193 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1194 #[transactional]1195 pub fn set_collection_limits(1196 origin,1197 collection_id: u32,1198 new_limits: CollectionLimits<T::BlockNumber>,1199 ) -> DispatchResult {1200 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1201 let mut target_collection = Self::get_collection(collection_id)?;1202 Self::check_owner_permissions(&target_collection, sender.as_sub())?;1203 let old_limits = &target_collection.limits;1204 let chain_limits = ChainLimit::get();12051206 // collection bounds1207 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1208 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1209 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1210 Error::<T>::CollectionLimitBoundsExceeded);12111212 // token_limit check prev1213 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1214 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12151216 ensure!(1217 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1218 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1219 Error::<T>::OwnerPermissionsCantBeReverted,1220 );12211222 target_collection.limits = new_limits;12231224 target_collection.save()1225 }1226 }1227}12281229impl<T: Config> Module<T> {1230 pub fn create_item_internal(1231 sender: &T::CrossAccountId,1232 collection: &CollectionHandle<T>,1233 owner: &T::CrossAccountId,1234 data: CreateItemData,1235 ) -> DispatchResult {1236 Self::can_create_items_in_collection(collection, sender, owner, 1)?;1237 Self::validate_create_item_args(collection, &data)?;1238 Self::create_item_no_validation(collection, owner, data)?;12391240 Ok(())1241 }12421243 pub fn transfer_internal(1244 sender: &T::CrossAccountId,1245 recipient: &T::CrossAccountId,1246 target_collection: &CollectionHandle<T>,1247 item_id: TokenId,1248 value: u128,1249 ) -> DispatchResult {1250 target_collection.consume_gas(2000000)?;1251 // Limits check1252 Self::is_correct_transfer(target_collection, recipient)?;12531254 // Transfer permissions check1255 ensure!(1256 Self::is_item_owner(sender, target_collection, item_id)1257 || Self::is_owner_or_admin_permissions(target_collection, sender),1258 Error::<T>::NoPermission1259 );12601261 if target_collection.access == AccessMode::WhiteList {1262 Self::check_white_list(target_collection, sender)?;1263 Self::check_white_list(target_collection, recipient)?;1264 }12651266 match target_collection.mode {1267 CollectionMode::NFT => Self::transfer_nft(1268 target_collection,1269 item_id,1270 sender.clone(),1271 recipient.clone(),1272 )?,1273 CollectionMode::Fungible(_) => {1274 Self::transfer_fungible(target_collection, value, sender, recipient)?1275 }1276 CollectionMode::ReFungible => Self::transfer_refungible(1277 target_collection,1278 item_id,1279 value,1280 sender.clone(),1281 recipient.clone(),1282 )?,1283 _ => (),1284 };12851286 Self::deposit_event(RawEvent::Transfer(1287 target_collection.id,1288 item_id,1289 sender.clone(),1290 recipient.clone(),1291 value,1292 ));12931294 Ok(())1295 }12961297 pub fn approve_internal(1298 sender: &T::CrossAccountId,1299 spender: &T::CrossAccountId,1300 collection: &CollectionHandle<T>,1301 item_id: TokenId,1302 amount: u128,1303 ) -> DispatchResult {1304 collection.consume_gas(2000000)?;1305 Self::token_exists(collection, item_id)?;13061307 // Transfer permissions check1308 let bypasses_limits = collection.limits.owner_can_transfer1309 && Self::is_owner_or_admin_permissions(collection, sender);13101311 let allowance_limit = if bypasses_limits {1312 None1313 } else if let Some(amount) = Self::owned_amount(sender, collection, item_id) {1314 Some(amount)1315 } else {1316 fail!(Error::<T>::NoPermission);1317 };13181319 if collection.access == AccessMode::WhiteList {1320 Self::check_white_list(collection, sender)?;1321 Self::check_white_list(collection, spender)?;1322 }13231324 let allowance: u128 = amount1325 .checked_add(<Allowances<T>>::get(1326 collection.id,1327 (item_id, sender.as_sub(), spender.as_sub()),1328 ))1329 .ok_or(Error::<T>::NumOverflow)?;1330 if let Some(limit) = allowance_limit {1331 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1332 }1333 <Allowances<T>>::insert(1334 collection.id,1335 (item_id, sender.as_sub(), spender.as_sub()),1336 allowance,1337 );13381339 if matches!(collection.mode, CollectionMode::NFT) {1340 // TODO: NFT: only one owner may exist for token in ERC7211341 collection.log(ERC721Events::Approval {1342 owner: *sender.as_eth(),1343 approved: *spender.as_eth(),1344 token_id: item_id.into(),1345 })?;1346 }13471348 if matches!(collection.mode, CollectionMode::Fungible(_)) {1349 // TODO: NFT: only one owner may exist for token in ERC201350 collection.log(ERC20Events::Approval {1351 owner: *sender.as_eth(),1352 spender: *spender.as_eth(),1353 value: allowance.into(),1354 })?;1355 }13561357 Self::deposit_event(RawEvent::Approved(1358 collection.id,1359 item_id,1360 sender.clone(),1361 spender.clone(),1362 allowance,1363 ));1364 Ok(())1365 }13661367 pub fn transfer_from_internal(1368 sender: &T::CrossAccountId,1369 from: &T::CrossAccountId,1370 recipient: &T::CrossAccountId,1371 collection: &CollectionHandle<T>,1372 item_id: TokenId,1373 amount: u128,1374 ) -> DispatchResult {1375 collection.consume_gas(2000000)?;1376 // Check approval1377 let approval: u128 =1378 <Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));13791380 // Limits check1381 Self::is_correct_transfer(collection, recipient)?;13821383 // Transfer permissions check1384 ensure!(1385 approval >= amount1386 || (collection.limits.owner_can_transfer1387 && Self::is_owner_or_admin_permissions(collection, sender)),1388 Error::<T>::NoPermission1389 );13901391 if collection.access == AccessMode::WhiteList {1392 Self::check_white_list(collection, sender)?;1393 Self::check_white_list(collection, recipient)?;1394 }13951396 // Reduce approval by transferred amount or remove if remaining approval drops to 01397 let allowance = approval.saturating_sub(amount);1398 if allowance > 0 {1399 <Allowances<T>>::insert(1400 collection.id,1401 (item_id, from.as_sub(), sender.as_sub()),1402 allowance,1403 );1404 } else {1405 <Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1406 }14071408 match collection.mode {1409 CollectionMode::NFT => {1410 Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1411 }1412 CollectionMode::Fungible(_) => {1413 Self::transfer_fungible(collection, amount, from, recipient)?1414 }1415 CollectionMode::ReFungible => Self::transfer_refungible(1416 collection,1417 item_id,1418 amount,1419 from.clone(),1420 recipient.clone(),1421 )?,1422 _ => (),1423 };14241425 if matches!(collection.mode, CollectionMode::Fungible(_)) {1426 collection.log(ERC20Events::Approval {1427 owner: *from.as_eth(),1428 spender: *sender.as_eth(),1429 value: allowance.into(),1430 })?;1431 }14321433 Ok(())1434 }14351436 pub fn set_variable_meta_data_internal(1437 sender: &T::CrossAccountId,1438 collection: &CollectionHandle<T>,1439 item_id: TokenId,1440 data: Vec<u8>,1441 ) -> DispatchResult {1442 Self::token_exists(collection, item_id)?;14431444 ensure!(1445 ChainLimit::get().custom_data_limit >= data.len() as u32,1446 Error::<T>::TokenVariableDataLimitExceeded1447 );14481449 // Modify permissions check1450 ensure!(1451 Self::is_item_owner(sender, collection, item_id)1452 || Self::is_owner_or_admin_permissions(collection, sender),1453 Error::<T>::NoPermission1454 );14551456 match collection.mode {1457 CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1458 CollectionMode::ReFungible => {1459 Self::set_re_fungible_variable_data(collection, item_id, data)?1460 }1461 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1462 _ => fail!(Error::<T>::UnexpectedCollectionType),1463 };14641465 Ok(())1466 }14671468 pub fn create_multiple_items_internal(1469 sender: &T::CrossAccountId,1470 collection: &CollectionHandle<T>,1471 owner: &T::CrossAccountId,1472 items_data: Vec<CreateItemData>,1473 ) -> DispatchResult {1474 Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;14751476 for data in &items_data {1477 Self::validate_create_item_args(collection, data)?;1478 }1479 for data in &items_data {1480 Self::create_item_no_validation(collection, owner, data.clone())?;1481 }14821483 Ok(())1484 }14851486 pub fn burn_item_internal(1487 sender: &T::CrossAccountId,1488 collection: &CollectionHandle<T>,1489 item_id: TokenId,1490 value: u128,1491 ) -> DispatchResult {1492 ensure!(1493 Self::is_item_owner(sender, collection, item_id)1494 || (collection.limits.owner_can_transfer1495 && Self::is_owner_or_admin_permissions(collection, sender)),1496 Error::<T>::NoPermission1497 );14981499 if collection.access == AccessMode::WhiteList {1500 Self::check_white_list(collection, sender)?;1501 }15021503 match collection.mode {1504 CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1505 CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,1506 CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,1507 _ => (),1508 };15091510 Ok(())1511 }15121513 pub fn toggle_white_list_internal(1514 sender: &T::CrossAccountId,1515 collection: &CollectionHandle<T>,1516 address: &T::CrossAccountId,1517 whitelisted: bool,1518 ) -> DispatchResult {1519 Self::check_owner_or_admin_permissions(collection, sender)?;15201521 if whitelisted {1522 <WhiteList<T>>::insert(collection.id, address.as_sub(), true);1523 } else {1524 <WhiteList<T>>::remove(collection.id, address.as_sub());1525 }15261527 Ok(())1528 }15291530 fn is_correct_transfer(1531 collection: &CollectionHandle<T>,1532 recipient: &T::CrossAccountId,1533 ) -> DispatchResult {1534 let collection_id = collection.id;15351536 // check token limit and account token limit1537 let account_items: u32 =1538 <AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;1539 ensure!(1540 collection.limits.account_token_ownership_limit > account_items,1541 Error::<T>::AccountTokenLimitExceeded1542 );15431544 Ok(())1545 }15461547 fn can_create_items_in_collection(1548 collection: &CollectionHandle<T>,1549 sender: &T::CrossAccountId,1550 owner: &T::CrossAccountId,1551 amount: u32,1552 ) -> DispatchResult {1553 let collection_id = collection.id;15541555 // check token limit and account token limit1556 let total_items: u32 = ItemListIndex::get(collection_id)1557 .checked_add(amount)1558 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1559 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1560 as u32)1561 .checked_add(amount)1562 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1563 ensure!(1564 collection.limits.token_limit >= total_items,1565 Error::<T>::CollectionTokenLimitExceeded1566 );1567 ensure!(1568 collection.limits.account_token_ownership_limit >= account_items,1569 Error::<T>::AccountTokenLimitExceeded1570 );15711572 if !Self::is_owner_or_admin_permissions(collection, sender) {1573 ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1574 Self::check_white_list(collection, owner)?;1575 Self::check_white_list(collection, sender)?;1576 }15771578 Ok(())1579 }15801581 fn validate_create_item_args(1582 target_collection: &CollectionHandle<T>,1583 data: &CreateItemData,1584 ) -> DispatchResult {1585 match target_collection.mode {1586 CollectionMode::NFT => {1587 if let CreateItemData::NFT(data) = data {1588 // check sizes1589 ensure!(1590 ChainLimit::get().custom_data_limit >= data.const_data.len() as u32,1591 Error::<T>::TokenConstDataLimitExceeded1592 );1593 ensure!(1594 ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32,1595 Error::<T>::TokenVariableDataLimitExceeded1596 );1597 } else {1598 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1599 }1600 }1601 CollectionMode::Fungible(_) => {1602 if let CreateItemData::Fungible(_) = data {1603 } else {1604 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1605 }1606 }1607 CollectionMode::ReFungible => {1608 if let CreateItemData::ReFungible(data) = data {1609 // check sizes1610 ensure!(1611 ChainLimit::get().custom_data_limit >= data.const_data.len() as u32,1612 Error::<T>::TokenConstDataLimitExceeded1613 );1614 ensure!(1615 ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32,1616 Error::<T>::TokenVariableDataLimitExceeded1617 );16181619 // Check refungibility limits1620 ensure!(1621 data.pieces <= MAX_REFUNGIBLE_PIECES,1622 Error::<T>::WrongRefungiblePieces1623 );1624 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1625 } else {1626 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1627 }1628 }1629 _ => {1630 fail!(Error::<T>::UnexpectedCollectionType);1631 }1632 };16331634 Ok(())1635 }16361637 fn create_item_no_validation(1638 collection: &CollectionHandle<T>,1639 owner: &T::CrossAccountId,1640 data: CreateItemData,1641 ) -> DispatchResult {1642 match data {1643 CreateItemData::NFT(data) => {1644 let item = NftItemType {1645 owner: owner.clone(),1646 const_data: data.const_data,1647 variable_data: data.variable_data,1648 };16491650 Self::add_nft_item(collection, item)?;1651 }1652 CreateItemData::Fungible(data) => {1653 Self::add_fungible_item(collection, owner, data.value)?;1654 }1655 CreateItemData::ReFungible(data) => {1656 let owner_list = vec![Ownership {1657 owner: owner.clone(),1658 fraction: data.pieces,1659 }];16601661 let item = ReFungibleItemType {1662 owner: owner_list,1663 const_data: data.const_data,1664 variable_data: data.variable_data,1665 };16661667 Self::add_refungible_item(collection, item)?;1668 }1669 };16701671 Ok(())1672 }16731674 fn add_fungible_item(1675 collection: &CollectionHandle<T>,1676 owner: &T::CrossAccountId,1677 value: u128,1678 ) -> DispatchResult {1679 let collection_id = collection.id;16801681 // Does new owner already have an account?1682 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;16831684 // Mint1685 let item = FungibleItemType {1686 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1687 };1688 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);16891690 // Update balance1691 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1692 .checked_add(value)1693 .ok_or(Error::<T>::NumOverflow)?;1694 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);16951696 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1697 Ok(())1698 }16991700 fn add_refungible_item(1701 collection: &CollectionHandle<T>,1702 item: ReFungibleItemType<T::CrossAccountId>,1703 ) -> DispatchResult {1704 let collection_id = collection.id;17051706 let current_index = <ItemListIndex>::get(collection_id)1707 .checked_add(1)1708 .ok_or(Error::<T>::NumOverflow)?;1709 let itemcopy = item.clone();17101711 ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1712 let item_owner = item.owner.first().expect("only one owner is defined");17131714 let value = item_owner.fraction;1715 let owner = item_owner.owner.clone();17161717 Self::add_token_index(collection_id, current_index, &owner)?;17181719 <ItemListIndex>::insert(collection_id, current_index);1720 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);17211722 // Update balance1723 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1724 .checked_add(value)1725 .ok_or(Error::<T>::NumOverflow)?;1726 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17271728 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1729 Ok(())1730 }17311732 fn add_nft_item(1733 collection: &CollectionHandle<T>,1734 item: NftItemType<T::CrossAccountId>,1735 ) -> DispatchResult {1736 let collection_id = collection.id;17371738 let current_index = <ItemListIndex>::get(collection_id)1739 .checked_add(1)1740 .ok_or(Error::<T>::NumOverflow)?;17411742 let item_owner = item.owner.clone();1743 Self::add_token_index(collection_id, current_index, &item.owner)?;17441745 <ItemListIndex>::insert(collection_id, current_index);1746 <NftItemList<T>>::insert(collection_id, current_index, item);17471748 // Update balance1749 let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1750 .checked_add(1)1751 .ok_or(Error::<T>::NumOverflow)?;1752 <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);17531754 collection.log(ERC721Events::Transfer {1755 from: H160::default(),1756 to: *item_owner.as_eth(),1757 token_id: current_index.into(),1758 })?;1759 Self::deposit_event(RawEvent::ItemCreated(1760 collection_id,1761 current_index,1762 item_owner,1763 ));1764 Ok(())1765 }17661767 fn burn_refungible_item(1768 collection: &CollectionHandle<T>,1769 item_id: TokenId,1770 owner: &T::CrossAccountId,1771 ) -> DispatchResult {1772 let collection_id = collection.id;17731774 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1775 .ok_or(Error::<T>::TokenNotFound)?;1776 let rft_balance = token1777 .owner1778 .iter()1779 .find(|&i| i.owner == *owner)1780 .ok_or(Error::<T>::TokenNotFound)?;1781 Self::remove_token_index(collection_id, item_id, owner)?;17821783 // update balance1784 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1785 .checked_sub(rft_balance.fraction)1786 .ok_or(Error::<T>::NumOverflow)?;1787 <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);17881789 // Re-create owners list with sender removed1790 let index = token1791 .owner1792 .iter()1793 .position(|i| i.owner == *owner)1794 .expect("owned item is exists");1795 token.owner.remove(index);1796 let owner_count = token.owner.len();17971798 // Burn the token completely if this was the last (only) owner1799 if owner_count == 0 {1800 <ReFungibleItemList<T>>::remove(collection_id, item_id);1801 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);1802 } else {1803 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1804 }18051806 Ok(())1807 }18081809 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1810 let collection_id = collection.id;18111812 let item =1813 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1814 Self::remove_token_index(collection_id, item_id, &item.owner)?;18151816 // update balance1817 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1818 .checked_sub(1)1819 .ok_or(Error::<T>::NumOverflow)?;1820 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1821 <NftItemList<T>>::remove(collection_id, item_id);1822 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);18231824 Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1825 Ok(())1826 }18271828 fn burn_fungible_item(1829 owner: &T::CrossAccountId,1830 collection: &CollectionHandle<T>,1831 value: u128,1832 ) -> DispatchResult {1833 let collection_id = collection.id;18341835 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1836 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);18371838 // update balance1839 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1840 .checked_sub(value)1841 .ok_or(Error::<T>::NumOverflow)?;1842 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18431844 if balance.value - value > 0 {1845 balance.value -= value;1846 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1847 } else {1848 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());1849 }18501851 collection.log(ERC20Events::Transfer {1852 from: *owner.as_eth(),1853 to: H160::default(),1854 value: value.into(),1855 })?;1856 Ok(())1857 }18581859 pub fn get_collection(1860 collection_id: CollectionId,1861 ) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1862 Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1863 }18641865 fn check_owner_permissions(1866 target_collection: &CollectionHandle<T>,1867 subject: &T::AccountId,1868 ) -> DispatchResult {1869 ensure!(1870 *subject == target_collection.owner,1871 Error::<T>::NoPermission1872 );18731874 Ok(())1875 }18761877 fn is_owner_or_admin_permissions(1878 collection: &CollectionHandle<T>,1879 subject: &T::CrossAccountId,1880 ) -> bool {1881 *subject.as_sub() == collection.owner1882 || <AdminList<T>>::get(collection.id).contains(subject)1883 }18841885 fn check_owner_or_admin_permissions(1886 collection: &CollectionHandle<T>,1887 subject: &T::CrossAccountId,1888 ) -> DispatchResult {1889 ensure!(1890 Self::is_owner_or_admin_permissions(collection, subject),1891 Error::<T>::NoPermission1892 );18931894 Ok(())1895 }18961897 fn owned_amount(1898 subject: &T::CrossAccountId,1899 target_collection: &CollectionHandle<T>,1900 item_id: TokenId,1901 ) -> Option<u128> {1902 let collection_id = target_collection.id;19031904 match target_collection.mode {1905 CollectionMode::NFT => {1906 (<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)1907 }1908 CollectionMode::Fungible(_) => {1909 Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)1910 }1911 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?1912 .owner1913 .iter()1914 .find(|i| i.owner == *subject)1915 .map(|i| i.fraction),1916 CollectionMode::Invalid => None,1917 }1918 }19191920 fn is_item_owner(1921 subject: &T::CrossAccountId,1922 target_collection: &CollectionHandle<T>,1923 item_id: TokenId,1924 ) -> bool {1925 match target_collection.mode {1926 CollectionMode::Fungible(_) => true,1927 _ => Self::owned_amount(subject, target_collection, item_id).is_some(),1928 }1929 }19301931 fn check_white_list(1932 collection: &CollectionHandle<T>,1933 address: &T::CrossAccountId,1934 ) -> DispatchResult {1935 let collection_id = collection.id;19361937 let mes = Error::<T>::AddresNotInWhiteList;1938 ensure!(1939 <WhiteList<T>>::contains_key(collection_id, address.as_sub()),1940 mes1941 );19421943 Ok(())1944 }19451946 /// Check if token exists. In case of Fungible, check if there is an entry for1947 /// the owner in fungible balances double map1948 fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1949 let collection_id = target_collection.id;1950 let exists = match target_collection.mode {1951 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),1952 CollectionMode::Fungible(_) => true,1953 CollectionMode::ReFungible => {1954 <ReFungibleItemList<T>>::contains_key(collection_id, item_id)1955 }1956 _ => false,1957 };19581959 ensure!(exists, Error::<T>::TokenNotFound);1960 Ok(())1961 }19621963 fn transfer_fungible(1964 collection: &CollectionHandle<T>,1965 value: u128,1966 owner: &T::CrossAccountId,1967 recipient: &T::CrossAccountId,1968 ) -> DispatchResult {1969 let collection_id = collection.id;19701971 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1972 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);19731974 // Send balance to recipient (updates balanceOf of recipient)1975 Self::add_fungible_item(collection, recipient, value)?;19761977 // update balanceOf of sender1978 <Balance<T>>::insert(collection_id, owner.as_sub(), balance.value - value);19791980 // Reduce or remove sender1981 if balance.value == value {1982 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());1983 } else {1984 balance.value -= value;1985 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1986 }19871988 collection.log(ERC20Events::Transfer {1989 from: *owner.as_eth(),1990 to: *recipient.as_eth(),1991 value: value.into(),1992 })?;1993 Self::deposit_event(RawEvent::Transfer(1994 collection.id,1995 1,1996 owner.clone(),1997 recipient.clone(),1998 value,1999 ));20002001 Ok(())2002 }20032004 fn transfer_refungible(2005 collection: &CollectionHandle<T>,2006 item_id: TokenId,2007 value: u128,2008 owner: T::CrossAccountId,2009 new_owner: T::CrossAccountId,2010 ) -> DispatchResult {2011 let collection_id = collection.id;2012 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2013 .ok_or(Error::<T>::TokenNotFound)?;20142015 let item = full_item2016 .owner2017 .iter()2018 .find(|i| i.owner == owner)2019 .ok_or(Error::<T>::TokenNotFound)?;2020 let amount = item.fraction;20212022 ensure!(amount >= value, Error::<T>::TokenValueTooLow);20232024 // update balance2025 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2026 .checked_sub(value)2027 .ok_or(Error::<T>::NumOverflow)?;2028 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);20292030 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2031 .checked_add(value)2032 .ok_or(Error::<T>::NumOverflow)?;2033 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);20342035 let old_owner = item.owner.clone();2036 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);20372038 let mut new_full_item = full_item.clone();2039 // transfer2040 if amount == value && !new_owner_has_account {2041 // change owner2042 // new owner do not have account2043 new_full_item2044 .owner2045 .iter_mut()2046 .find(|i| i.owner == owner)2047 .expect("old owner does present in refungible")2048 .owner = new_owner.clone();2049 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);20502051 // update index collection2052 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2053 } else {2054 new_full_item2055 .owner2056 .iter_mut()2057 .find(|i| i.owner == owner)2058 .expect("old owner does present in refungible")2059 .fraction -= value;20602061 // separate amount2062 if new_owner_has_account {2063 // new owner has account2064 new_full_item2065 .owner2066 .iter_mut()2067 .find(|i| i.owner == new_owner)2068 .expect("new owner has account")2069 .fraction += value;2070 } else {2071 // new owner do not have account2072 new_full_item.owner.push(Ownership {2073 owner: new_owner.clone(),2074 fraction: value,2075 });2076 Self::add_token_index(collection_id, item_id, &new_owner)?;2077 }20782079 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2080 }20812082 Self::deposit_event(RawEvent::Transfer(2083 collection.id,2084 item_id,2085 owner,2086 new_owner,2087 amount,2088 ));20892090 Ok(())2091 }20922093 fn transfer_nft(2094 collection: &CollectionHandle<T>,2095 item_id: TokenId,2096 sender: T::CrossAccountId,2097 new_owner: T::CrossAccountId,2098 ) -> DispatchResult {2099 let collection_id = collection.id;2100 let mut item =2101 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;21022103 ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);21042105 // update balance2106 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2107 .checked_sub(1)2108 .ok_or(Error::<T>::NumOverflow)?;2109 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21102111 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2112 .checked_add(1)2113 .ok_or(Error::<T>::NumOverflow)?;2114 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21152116 // change owner2117 let old_owner = item.owner.clone();2118 item.owner = new_owner.clone();2119 <NftItemList<T>>::insert(collection_id, item_id, item);21202121 // update index collection2122 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;21232124 collection.log(ERC721Events::Transfer {2125 from: *sender.as_eth(),2126 to: *new_owner.as_eth(),2127 token_id: item_id.into(),2128 })?;2129 Self::deposit_event(RawEvent::Transfer(2130 collection.id,2131 item_id,2132 sender,2133 new_owner,2134 1,2135 ));21362137 Ok(())2138 }21392140 fn set_re_fungible_variable_data(2141 collection: &CollectionHandle<T>,2142 item_id: TokenId,2143 data: Vec<u8>,2144 ) -> DispatchResult {2145 let collection_id = collection.id;2146 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2147 .ok_or(Error::<T>::TokenNotFound)?;21482149 item.variable_data = data;21502151 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);21522153 Ok(())2154 }21552156 fn set_nft_variable_data(2157 collection: &CollectionHandle<T>,2158 item_id: TokenId,2159 data: Vec<u8>,2160 ) -> DispatchResult {2161 let collection_id = collection.id;2162 let mut item =2163 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;21642165 item.variable_data = data;21662167 <NftItemList<T>>::insert(collection_id, item_id, item);21682169 Ok(())2170 }21712172 #[allow(dead_code)]2173 fn init_collection(item: &Collection<T>) {2174 // check params2175 assert!(2176 item.decimal_points <= MAX_DECIMAL_POINTS,2177 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2178 );2179 assert!(2180 item.name.len() <= 64,2181 "Collection name can not be longer than 63 char"2182 );2183 assert!(2184 item.name.len() <= 256,2185 "Collection description can not be longer than 255 char"2186 );2187 assert!(2188 item.token_prefix.len() <= 16,2189 "Token prefix can not be longer than 15 char"2190 );21912192 // Generate next collection ID2193 let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();21942195 CreatedCollectionCount::put(next_id);2196 }21972198 #[allow(dead_code)]2199 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2200 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22012202 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();22032204 <ItemListIndex>::insert(collection_id, current_index);22052206 // Update balance2207 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2208 .checked_add(1)2209 .unwrap();2210 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2211 }22122213 #[allow(dead_code)]2214 fn init_fungible_token(2215 collection_id: CollectionId,2216 owner: &T::CrossAccountId,2217 item: &FungibleItemType,2218 ) {2219 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22202221 Self::add_token_index(collection_id, current_index, owner).unwrap();22222223 <ItemListIndex>::insert(collection_id, current_index);22242225 // Update balance2226 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2227 .checked_add(item.value)2228 .unwrap();2229 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2230 }22312232 #[allow(dead_code)]2233 fn init_refungible_token(2234 collection_id: CollectionId,2235 item: &ReFungibleItemType<T::CrossAccountId>,2236 ) {2237 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22382239 let value = item.owner.first().unwrap().fraction;2240 let owner = item.owner.first().unwrap().owner.clone();22412242 Self::add_token_index(collection_id, current_index, &owner).unwrap();22432244 <ItemListIndex>::insert(collection_id, current_index);22452246 // Update balance2247 let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2248 .checked_add(value)2249 .unwrap();2250 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2251 }22522253 fn add_token_index(2254 collection_id: CollectionId,2255 item_index: TokenId,2256 owner: &T::CrossAccountId,2257 ) -> DispatchResult {2258 // add to account limit2259 if <AccountItemCount<T>>::contains_key(owner.as_sub()) {2260 // bound Owned tokens by a single address2261 let count = <AccountItemCount<T>>::get(owner.as_sub());2262 ensure!(2263 count < ChainLimit::get().account_token_ownership_limit,2264 Error::<T>::AddressOwnershipLimitExceeded2265 );22662267 <AccountItemCount<T>>::insert(2268 owner.as_sub(),2269 count.checked_add(1).ok_or(Error::<T>::NumOverflow)?,2270 );2271 } else {2272 <AccountItemCount<T>>::insert(owner.as_sub(), 1);2273 }22742275 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2276 if list_exists {2277 let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2278 let item_contains = list.contains(&item_index.clone());22792280 if !item_contains {2281 list.push(item_index);2282 }22832284 <AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2285 } else {2286 let itm = vec![item_index];2287 <AddressTokens<T>>::insert(collection_id, owner.as_sub(), itm);2288 }22892290 Ok(())2291 }22922293 fn remove_token_index(2294 collection_id: CollectionId,2295 item_index: TokenId,2296 owner: &T::CrossAccountId,2297 ) -> DispatchResult {2298 // update counter2299 <AccountItemCount<T>>::insert(2300 owner.as_sub(),2301 <AccountItemCount<T>>::get(owner.as_sub())2302 .checked_sub(1)2303 .ok_or(Error::<T>::NumOverflow)?,2304 );23052306 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2307 if list_exists {2308 let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2309 let item_contains = list.contains(&item_index.clone());23102311 if item_contains {2312 list.retain(|&item| item != item_index);2313 <AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2314 }2315 }23162317 Ok(())2318 }23192320 fn move_token_index(2321 collection_id: CollectionId,2322 item_index: TokenId,2323 old_owner: &T::CrossAccountId,2324 new_owner: &T::CrossAccountId,2325 ) -> DispatchResult {2326 Self::remove_token_index(collection_id, item_index, old_owner)?;2327 Self::add_token_index(collection_id, item_index, new_owner)?;23282329 Ok(())2330 }2331}23322333sp_api::decl_runtime_apis! {2334 pub trait NftApi {2335 /// Used for ethereum integration2336 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2337 }2338}pallets/nft/src/mock.rsdiffbeforeafterboth--- a/pallets/nft/src/mock.rs
+++ b/pallets/nft/src/mock.rs
@@ -193,7 +193,6 @@
type EvmAddressMapping = TestEvmAddressMapping;
type EvmBackwardsAddressMapping = TestEvmBackwardsAddressMapping;
type CrossAccountId = TestCrossAccountId;
- type EthereumChainId = EthereumChainId;
type EthereumTransactionSender = TestEtheremTransactionSender;
}