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 core::cell::RefCell;40use nft_data_structs::{41 MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,42 AccessMode, ChainLimits, Collection, CreateItemData, CollectionLimits, CollectionId,43 CollectionMode, TokenId, SchemaVersion, SponsorshipState, Ownership, NftItemType,44 FungibleItemType, ReFungibleItemType,45};46use pallet_ethereum::EthereumTransactionSender;4748#[cfg(test)]49mod mock;5051#[cfg(test)]52mod tests;5354mod default_weights;55mod eth;56mod sponsorship;57pub use sponsorship::NftSponsorshipHandler;5859pub use eth::NftErcSupport;60pub use eth::account::*;61use eth::erc::{ERC20Events, ERC721Events};6263#[cfg(feature = "runtime-benchmarks")]64mod benchmarking;6566pub trait WeightInfo {67 fn create_collection() -> Weight;68 fn destroy_collection() -> Weight;69 fn add_to_white_list() -> Weight;70 fn remove_from_white_list() -> Weight;71 fn set_public_access_mode() -> Weight;72 fn set_mint_permission() -> Weight;73 fn change_collection_owner() -> Weight;74 fn add_collection_admin() -> Weight;75 fn remove_collection_admin() -> Weight;76 fn set_collection_sponsor() -> Weight;77 fn confirm_sponsorship() -> Weight;78 fn remove_collection_sponsor() -> Weight;79 fn create_item(s: usize) -> Weight;80 fn burn_item() -> Weight;81 fn transfer() -> Weight;82 fn approve() -> Weight;83 fn transfer_from() -> Weight;84 fn set_offchain_schema() -> Weight;85 fn set_const_on_chain_schema() -> Weight;86 fn set_variable_on_chain_schema() -> Weight;87 fn set_variable_meta_data() -> Weight;88 fn enable_contract_sponsoring() -> Weight;89 fn set_schema_version() -> Weight;90 fn set_chain_limits() -> Weight;91 fn set_contract_sponsoring_rate_limit() -> Weight;92 fn set_variable_meta_data_sponsoring_rate_limit() -> Weight;93 fn toggle_contract_white_list() -> Weight;94 fn add_to_contract_white_list() -> Weight;95 fn remove_from_contract_white_list() -> Weight;96 fn set_collection_limits() -> Weight;97}9899decl_error! {100 /// Error for non-fungible-token module.101 pub enum Error for Module<T: Config> {102 /// Total collections bound exceeded.103 TotalCollectionsLimitExceeded,104 /// Decimal_points parameter must be lower than MAX_DECIMAL_POINTS constant, currently it is 30.105 CollectionDecimalPointLimitExceeded,106 /// Collection name can not be longer than 63 char.107 CollectionNameLimitExceeded,108 /// Collection description can not be longer than 255 char.109 CollectionDescriptionLimitExceeded,110 /// Token prefix can not be longer than 15 char.111 CollectionTokenPrefixLimitExceeded,112 /// This collection does not exist.113 CollectionNotFound,114 /// Item not exists.115 TokenNotFound,116 /// Admin not found117 AdminNotFound,118 /// Arithmetic calculation overflow.119 NumOverflow,120 /// Account already has admin role.121 AlreadyAdmin,122 /// You do not own this collection.123 NoPermission,124 /// This address is not set as sponsor, use setCollectionSponsor first.125 ConfirmUnsetSponsorFail,126 /// Collection is not in mint mode.127 PublicMintingNotAllowed,128 /// Sender parameter and item owner must be equal.129 MustBeTokenOwner,130 /// Item balance not enough.131 TokenValueTooLow,132 /// Size of item is too large.133 NftSizeLimitExceeded,134 /// No approve found135 ApproveNotFound,136 /// Requested value more than approved.137 TokenValueNotEnough,138 /// Only approved addresses can call this method.139 ApproveRequired,140 /// Address is not in white list.141 AddresNotInWhiteList,142 /// Number of collection admins bound exceeded.143 CollectionAdminsLimitExceeded,144 /// Owned tokens by a single address bound exceeded.145 AddressOwnershipLimitExceeded,146 /// Length of items properties must be greater than 0.147 EmptyArgument,148 /// const_data exceeded data limit.149 TokenConstDataLimitExceeded,150 /// variable_data exceeded data limit.151 TokenVariableDataLimitExceeded,152 /// Not NFT item data used to mint in NFT collection.153 NotNftDataUsedToMintNftCollectionToken,154 /// Not Fungible item data used to mint in Fungible collection.155 NotFungibleDataUsedToMintFungibleCollectionToken,156 /// Not Re Fungible item data used to mint in Re Fungible collection.157 NotReFungibleDataUsedToMintReFungibleCollectionToken,158 /// Unexpected collection type.159 UnexpectedCollectionType,160 /// Can't store metadata in fungible tokens.161 CantStoreMetadataInFungibleTokens,162 /// Collection token limit exceeded163 CollectionTokenLimitExceeded,164 /// Account token limit exceeded per collection165 AccountTokenLimitExceeded,166 /// Collection limit bounds per collection exceeded167 CollectionLimitBoundsExceeded,168 /// Tried to enable permissions which are only permitted to be disabled169 OwnerPermissionsCantBeReverted,170 /// Schema data size limit bound exceeded171 SchemaDataLimitExceeded,172 /// Maximum refungibility exceeded173 WrongRefungiblePieces,174 /// createRefungible should be called with one owner175 BadCreateRefungibleCall,176 /// Gas limit exceeded177 OutOfGas,178 }179}180181pub struct CollectionHandle<T: Config> {182 pub id: CollectionId,183 collection: Collection<T>,184 logs: eth::log::LogRecorder,185 evm_address: H160,186 gas_limit: RefCell<u64>,187}188impl<T: Config> CollectionHandle<T> {189 pub fn get_with_gas_limit(id: CollectionId, gas_limit: u64) -> Option<Self> {190 <CollectionById<T>>::get(id).map(|collection| Self {191 id,192 collection,193 logs: eth::log::LogRecorder::default(),194 evm_address: eth::collection_id_to_address(id),195 gas_limit: RefCell::new(gas_limit),196 })197 }198 pub fn get(id: CollectionId) -> Option<Self> {199 Self::get_with_gas_limit(id, u64::MAX)200 }201 pub fn gas_left(&self) -> u64 {202 *self.gas_limit.borrow()203 }204 pub fn consume_gas(&self, gas: u64) -> DispatchResult {205 let mut gas_limit = self.gas_limit.borrow_mut();206 if *gas_limit < gas {207 fail!(Error::<T>::OutOfGas);208 }209 *gas_limit -= gas;210 Ok(())211 }212 pub fn log(&self, log: impl evm_coder::ToLog) {213 self.logs.log(log.to_log(self.evm_address))214 }215 pub fn into_inner(self) -> Collection<T> {216 self.collection217 }218}219impl<T: Config> Deref for CollectionHandle<T> {220 type Target = Collection<T>;221222 fn deref(&self) -> &Self::Target {223 &self.collection224 }225}226227impl<T: Config> DerefMut for CollectionHandle<T> {228 fn deref_mut(&mut self) -> &mut Self::Target {229 &mut self.collection230 }231}232233pub trait Config: system::Config + Sized {234 type Event: From<Event<Self>> + Into<<Self as system::Config>::Event>;235236 /// Weight information for extrinsics in this pallet.237 type WeightInfo: WeightInfo;238239 type EvmAddressMapping: pallet_evm::AddressMapping<Self::AccountId>;240 type EvmBackwardsAddressMapping: EvmBackwardsAddressMapping<Self::AccountId>;241242 type CrossAccountId: CrossAccountId<Self::AccountId>;243 type Currency: Currency<Self::AccountId>;244 type CollectionCreationPrice: Get<245 <<Self as Config>::Currency as Currency<Self::AccountId>>::Balance,246 >;247 type TreasuryAccountId: Get<Self::AccountId>;248249 type EthereumChainId: Get<u64>;250 type EthereumTransactionSender: pallet_ethereum::EthereumTransactionSender;251}252253// # Used definitions254//255// ## User control levels256//257// chain-controlled - key is uncontrolled by user258// i.e autoincrementing index259// can use non-cryptographic hash260// real - key is controlled by user261// but it is hard to generate enough colliding values, i.e owner of signed txs262// can use non-cryptographic hash263// controlled - key is completly controlled by users264// i.e maps with mutable keys265// should use cryptographic hash266//267// ## User control level downgrade reasons268//269// ?1 - chain-controlled -> controlled270// collections/tokens can be destroyed, resulting in massive holes271// ?2 - chain-controlled -> controlled272// same as ?1, but can be only added, resulting in easier exploitation273// ?3 - real -> controlled274// no confirmation required, so addresses can be easily generated275decl_storage! {276 trait Store for Module<T: Config> as Nft {277278 //#region Private members279 /// Id of next collection280 CreatedCollectionCount: u32;281 /// Used for migrations282 ChainVersion: u64;283 /// Id of last collection token284 /// Collection id (controlled?1)285 ItemListIndex: map hasher(blake2_128_concat) CollectionId => TokenId;286 //#endregion287288 //#region Chain limits struct289 pub ChainLimit get(fn chain_limit) config(): ChainLimits;290 //#endregion291292 //#region Bound counters293 /// Amount of collections destroyed, used for total amount tracking with294 /// CreatedCollectionCount295 DestroyedCollectionCount: u32;296 /// Total amount of account owned tokens (NFTs + RFTs + unique fungibles)297 /// Account id (real)298 pub AccountItemCount get(fn account_item_count): map hasher(twox_64_concat) T::AccountId => u32;299 //#endregion300301 //#region Basic collections302 /// Collection info303 /// Collection id (controlled?1)304 pub CollectionById get(fn collection_id) config(): map hasher(blake2_128_concat) CollectionId => Option<Collection<T>> = None;305 /// List of collection admins306 /// Collection id (controlled?2)307 pub AdminList get(fn admin_list_collection): map hasher(blake2_128_concat) CollectionId => Vec<T::CrossAccountId>;308 /// Whitelisted collection users309 /// Collection id (controlled?2), user id (controlled?3)310 pub WhiteList get(fn white_list): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => bool;311 //#endregion312313 /// How many of collection items user have314 /// Collection id (controlled?2), account id (real)315 pub Balance get(fn balance_count): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => u128;316317 /// Amount of items which spender can transfer out of owners account (via transferFrom)318 /// Collection id (controlled?2), (token id (controlled ?2) + owner account id (real) + spender account id (controlled?3))319 /// TODO: Off chain worker should remove from this map when token gets removed320 pub Allowances get(fn approved): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) (TokenId, T::AccountId, T::AccountId) => u128;321322 //#region Item collections323 /// Collection id (controlled?2), token id (controlled?1)324 pub NftItemList get(fn nft_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<NftItemType<T::CrossAccountId>>;325 /// Collection id (controlled?2), owner (controlled?2)326 pub FungibleItemList get(fn fungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => FungibleItemType;327 /// Collection id (controlled?2), token id (controlled?1)328 pub ReFungibleItemList get(fn refungible_item_id) config(): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<ReFungibleItemType<T::CrossAccountId>>;329 //#endregion330331 //#region Index list332 /// Collection id (controlled?2), tokens owner (controlled?2)333 pub AddressTokens get(fn address_tokens): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) T::AccountId => Vec<TokenId>;334 //#endregion335336 //#region Tokens transfer rate limit baskets337 /// (Collection id (controlled?2), who created (real))338 /// TODO: Off chain worker should remove from this map when collection gets removed339 pub CreateItemBasket get(fn create_item_basket): map hasher(blake2_128_concat) (CollectionId, T::AccountId) => T::BlockNumber;340 /// Collection id (controlled?2), token id (controlled?2)341 pub NftTransferBasket get(fn nft_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;342 /// Collection id (controlled?2), owning user (real)343 pub FungibleTransferBasket get(fn fungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(twox_64_concat) T::AccountId => T::BlockNumber;344 /// Collection id (controlled?2), token id (controlled?2)345 pub ReFungibleTransferBasket get(fn refungible_transfer_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => T::BlockNumber;346 //#endregion347348 /// Variable metadata sponsoring349 /// Collection id (controlled?2), token id (controlled?2)350 pub VariableMetaDataBasket get(fn variable_meta_data_basket): double_map hasher(blake2_128_concat) CollectionId, hasher(blake2_128_concat) TokenId => Option<T::BlockNumber> = None;351 }352 add_extra_genesis {353 build(|config: &GenesisConfig<T>| {354 // Modification of storage355 for (_num, _c) in &config.collection_id {356 <Module<T>>::init_collection(_c);357 }358359 for (_num, _c, _i) in &config.nft_item_id {360 <Module<T>>::init_nft_token(*_c, _i);361 }362363 for (collection_id, account_id, fungible_item) in &config.fungible_item_id {364 <Module<T>>::init_fungible_token(*collection_id, &T::CrossAccountId::from_sub(account_id.clone()), fungible_item);365 }366367 for (_num, _c, _i) in &config.refungible_item_id {368 <Module<T>>::init_refungible_token(*_c, _i);369 }370 })371 }372}373374decl_event!(375 pub enum Event<T>376 where377 AccountId = <T as frame_system::Config>::AccountId,378 CrossAccountId = <T as Config>::CrossAccountId,379 {380 /// New collection was created381 ///382 /// # Arguments383 ///384 /// * collection_id: Globally unique identifier of newly created collection.385 ///386 /// * mode: [CollectionMode] converted into u8.387 ///388 /// * account_id: Collection owner.389 CollectionCreated(CollectionId, u8, AccountId),390391 /// New item was created.392 ///393 /// # Arguments394 ///395 /// * collection_id: Id of the collection where item was created.396 ///397 /// * item_id: Id of an item. Unique within the collection.398 ///399 /// * recipient: Owner of newly created item400 ItemCreated(CollectionId, TokenId, CrossAccountId),401402 /// Collection item was burned.403 ///404 /// # Arguments405 ///406 /// collection_id.407 ///408 /// item_id: Identifier of burned NFT.409 ItemDestroyed(CollectionId, TokenId),410411 /// Item was transferred412 ///413 /// * collection_id: Id of collection to which item is belong414 ///415 /// * item_id: Id of an item416 ///417 /// * sender: Original owner of item418 ///419 /// * recipient: New owner of item420 ///421 /// * amount: Always 1 for NFT422 Transfer(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),423424 /// * collection_id425 ///426 /// * item_id427 ///428 /// * sender429 ///430 /// * spender431 ///432 /// * amount433 Approved(CollectionId, TokenId, CrossAccountId, CrossAccountId, u128),434 }435);436437decl_module! {438 pub struct Module<T: Config> for enum Call439 where440 origin: T::Origin441 {442 fn deposit_event() = default;443 type Error = Error<T>;444445 fn on_initialize(_now: T::BlockNumber) -> Weight {446 0447 }448449 /// 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.450 ///451 /// # Permissions452 ///453 /// * Anyone.454 ///455 /// # Arguments456 ///457 /// * collection_name: UTF-16 string with collection name (limit 64 characters), will be stored as zero-terminated.458 ///459 /// * collection_description: UTF-16 string with collection description (limit 256 characters), will be stored as zero-terminated.460 ///461 /// * token_prefix: UTF-8 string with token prefix.462 ///463 /// * mode: [CollectionMode] collection type and type dependent data.464 // returns collection ID465 #[weight = <T as Config>::WeightInfo::create_collection()]466 #[transactional]467 pub fn create_collection(origin,468 collection_name: Vec<u16>,469 collection_description: Vec<u16>,470 token_prefix: Vec<u8>,471 mode: CollectionMode) -> DispatchResult {472473 // Anyone can create a collection474 let who = ensure_signed(origin)?;475476 // Take a (non-refundable) deposit of collection creation477 let mut imbalance = <<<T as Config>::Currency as Currency<T::AccountId>>::PositiveImbalance>::zero();478 imbalance.subsume(<<T as Config>::Currency as Currency<T::AccountId>>::deposit_creating(479 &T::TreasuryAccountId::get(),480 T::CollectionCreationPrice::get(),481 ));482 <T as Config>::Currency::settle(483 &who,484 imbalance,485 WithdrawReasons::TRANSFER,486 ExistenceRequirement::KeepAlive,487 ).map_err(|_| Error::<T>::NoPermission)?;488489 let decimal_points = match mode {490 CollectionMode::Fungible(points) => points,491 _ => 0492 };493494 let chain_limit = ChainLimit::get();495496 let created_count = CreatedCollectionCount::get();497 let destroyed_count = DestroyedCollectionCount::get();498499 // bound Total number of collections500 ensure!(created_count - destroyed_count < chain_limit.collection_numbers_limit, Error::<T>::TotalCollectionsLimitExceeded);501502 // check params503 ensure!(decimal_points <= MAX_DECIMAL_POINTS, Error::<T>::CollectionDecimalPointLimitExceeded);504 ensure!(collection_name.len() <= 64, Error::<T>::CollectionNameLimitExceeded);505 ensure!(collection_description.len() <= 256, Error::<T>::CollectionDescriptionLimitExceeded);506 ensure!(token_prefix.len() <= 16, Error::<T>::CollectionTokenPrefixLimitExceeded);507508 // Generate next collection ID509 let next_id = created_count510 .checked_add(1)511 .ok_or(Error::<T>::NumOverflow)?;512513 CreatedCollectionCount::put(next_id);514515 let limits = CollectionLimits {516 sponsored_data_size: chain_limit.custom_data_limit,517 ..Default::default()518 };519520 // Create new collection521 let new_collection = Collection {522 owner: who.clone(),523 name: collection_name,524 mode: mode.clone(),525 mint_mode: false,526 access: AccessMode::Normal,527 description: collection_description,528 decimal_points,529 token_prefix,530 offchain_schema: Vec::new(),531 schema_version: SchemaVersion::ImageURL,532 sponsorship: SponsorshipState::Disabled,533 variable_on_chain_schema: Vec::new(),534 const_on_chain_schema: Vec::new(),535 limits,536 };537538 // Add new collection to map539 <CollectionById<T>>::insert(next_id, new_collection);540541 // call event542 Self::deposit_event(RawEvent::CollectionCreated(next_id, mode.id(), who));543544 Ok(())545 }546547 /// **DANGEROUS**: Destroys collection and all NFTs within this collection. Users irrecoverably lose their assets and may lose real money.548 ///549 /// # Permissions550 ///551 /// * Collection Owner.552 ///553 /// # Arguments554 ///555 /// * collection_id: collection to destroy.556 #[weight = <T as Config>::WeightInfo::destroy_collection()]557 #[transactional]558 pub fn destroy_collection(origin, collection_id: CollectionId) -> DispatchResult {559560 let sender = ensure_signed(origin)?;561 let collection = Self::get_collection(collection_id)?;562 Self::check_owner_permissions(&collection, &sender)?;563 if !collection.limits.owner_can_destroy {564 fail!(Error::<T>::NoPermission);565 }566567 <AddressTokens<T>>::remove_prefix(collection_id);568 <Allowances<T>>::remove_prefix(collection_id);569 <Balance<T>>::remove_prefix(collection_id);570 <ItemListIndex>::remove(collection_id);571 <AdminList<T>>::remove(collection_id);572 <CollectionById<T>>::remove(collection_id);573 <WhiteList<T>>::remove_prefix(collection_id);574575 <NftItemList<T>>::remove_prefix(collection_id);576 <FungibleItemList<T>>::remove_prefix(collection_id);577 <ReFungibleItemList<T>>::remove_prefix(collection_id);578579 <NftTransferBasket<T>>::remove_prefix(collection_id);580 <FungibleTransferBasket<T>>::remove_prefix(collection_id);581 <ReFungibleTransferBasket<T>>::remove_prefix(collection_id);582583 <VariableMetaDataBasket<T>>::remove_prefix(collection_id);584585 DestroyedCollectionCount::put(DestroyedCollectionCount::get()586 .checked_add(1)587 .ok_or(Error::<T>::NumOverflow)?);588589 Ok(())590 }591592 /// Add an address to white list.593 ///594 /// # Permissions595 ///596 /// * Collection Owner597 /// * Collection Admin598 ///599 /// # Arguments600 ///601 /// * collection_id.602 ///603 /// * address.604 #[weight = <T as Config>::WeightInfo::add_to_white_list()]605 #[transactional]606 pub fn add_to_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{607608 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);609 let collection = Self::get_collection(collection_id)?;610611 Self::toggle_white_list_internal(612 &sender,613 &collection,614 &address,615 true,616 )?;617618 Ok(())619 }620621 /// Remove an address from white list.622 ///623 /// # Permissions624 ///625 /// * Collection Owner626 /// * Collection Admin627 ///628 /// # Arguments629 ///630 /// * collection_id.631 ///632 /// * address.633 #[weight = <T as Config>::WeightInfo::remove_from_white_list()]634 #[transactional]635 pub fn remove_from_white_list(origin, collection_id: CollectionId, address: T::CrossAccountId) -> DispatchResult{636637 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);638 let collection = Self::get_collection(collection_id)?;639640 Self::toggle_white_list_internal(641 &sender,642 &collection,643 &address,644 false,645 )?;646647 Ok(())648 }649650 /// Toggle between normal and white list access for the methods with access for `Anyone`.651 ///652 /// # Permissions653 ///654 /// * Collection Owner.655 ///656 /// # Arguments657 ///658 /// * collection_id.659 ///660 /// * mode: [AccessMode]661 #[weight = <T as Config>::WeightInfo::set_public_access_mode()]662 #[transactional]663 pub fn set_public_access_mode(origin, collection_id: CollectionId, mode: AccessMode) -> DispatchResult664 {665 let sender = ensure_signed(origin)?;666667 let mut target_collection = Self::get_collection(collection_id)?;668 Self::check_owner_permissions(&target_collection, &sender)?;669 target_collection.access = mode;670 Self::save_collection(target_collection);671672 Ok(())673 }674675 /// Allows Anyone to create tokens if:676 /// * White List is enabled, and677 /// * Address is added to white list, and678 /// * This method was called with True parameter679 ///680 /// # Permissions681 /// * Collection Owner682 ///683 /// # Arguments684 ///685 /// * collection_id.686 ///687 /// * mint_permission: Boolean parameter. If True, allows minting to Anyone with conditions above.688 #[weight = <T as Config>::WeightInfo::set_mint_permission()]689 #[transactional]690 pub fn set_mint_permission(origin, collection_id: CollectionId, mint_permission: bool) -> DispatchResult691 {692 let sender = ensure_signed(origin)?;693694 let mut target_collection = Self::get_collection(collection_id)?;695 Self::check_owner_permissions(&target_collection, &sender)?;696 target_collection.mint_mode = mint_permission;697 Self::save_collection(target_collection);698699 Ok(())700 }701702 /// Change the owner of the collection.703 ///704 /// # Permissions705 ///706 /// * Collection Owner.707 ///708 /// # Arguments709 ///710 /// * collection_id.711 ///712 /// * new_owner.713 #[weight = <T as Config>::WeightInfo::change_collection_owner()]714 #[transactional]715 pub fn change_collection_owner(origin, collection_id: CollectionId, new_owner: T::AccountId) -> DispatchResult {716717 let sender = ensure_signed(origin)?;718 let mut target_collection = Self::get_collection(collection_id)?;719 Self::check_owner_permissions(&target_collection, &sender)?;720 target_collection.owner = new_owner;721 Self::save_collection(target_collection);722723 Ok(())724 }725726 /// Adds an admin of the Collection.727 /// 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.728 ///729 /// # Permissions730 ///731 /// * Collection Owner.732 /// * Collection Admin.733 ///734 /// # Arguments735 ///736 /// * collection_id: ID of the Collection to add admin for.737 ///738 /// * new_admin_id: Address of new admin to add.739 #[weight = <T as Config>::WeightInfo::add_collection_admin()]740 #[transactional]741 pub fn add_collection_admin(origin, collection_id: CollectionId, new_admin_id: T::CrossAccountId) -> DispatchResult {742 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);743 let collection = Self::get_collection(collection_id)?;744 Self::check_owner_or_admin_permissions(&collection, &sender)?;745 let mut admin_arr = <AdminList<T>>::get(collection_id);746747 match admin_arr.binary_search(&new_admin_id) {748 Ok(_) => {},749 Err(idx) => {750 let limits = ChainLimit::get();751 ensure!(admin_arr.len() < limits.collections_admins_limit as usize, Error::<T>::CollectionAdminsLimitExceeded);752 admin_arr.insert(idx, new_admin_id);753 <AdminList<T>>::insert(collection_id, admin_arr);754 }755 }756 Ok(())757 }758759 /// 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.760 ///761 /// # Permissions762 ///763 /// * Collection Owner.764 /// * Collection Admin.765 ///766 /// # Arguments767 ///768 /// * collection_id: ID of the Collection to remove admin for.769 ///770 /// * account_id: Address of admin to remove.771 #[weight = <T as Config>::WeightInfo::remove_collection_admin()]772 #[transactional]773 pub fn remove_collection_admin(origin, collection_id: CollectionId, account_id: T::CrossAccountId) -> DispatchResult {774 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);775 let collection = Self::get_collection(collection_id)?;776 Self::check_owner_or_admin_permissions(&collection, &sender)?;777 let mut admin_arr = <AdminList<T>>::get(collection_id);778779 if let Ok(idx) = admin_arr.binary_search(&account_id) {780 admin_arr.remove(idx);781 <AdminList<T>>::insert(collection_id, admin_arr);782 }783 Ok(())784 }785786 /// # Permissions787 ///788 /// * Collection Owner789 ///790 /// # Arguments791 ///792 /// * collection_id.793 ///794 /// * new_sponsor.795 #[weight = <T as Config>::WeightInfo::set_collection_sponsor()]796 #[transactional]797 pub fn set_collection_sponsor(origin, collection_id: CollectionId, new_sponsor: T::AccountId) -> DispatchResult {798 let sender = ensure_signed(origin)?;799 let mut target_collection = Self::get_collection(collection_id)?;800 Self::check_owner_permissions(&target_collection, &sender)?;801802 target_collection.sponsorship = SponsorshipState::Unconfirmed(new_sponsor);803 Self::save_collection(target_collection);804805 Ok(())806 }807808 /// # Permissions809 ///810 /// * Sponsor.811 ///812 /// # Arguments813 ///814 /// * collection_id.815 #[weight = <T as Config>::WeightInfo::confirm_sponsorship()]816 #[transactional]817 pub fn confirm_sponsorship(origin, collection_id: CollectionId) -> DispatchResult {818 let sender = ensure_signed(origin)?;819820 let mut target_collection = Self::get_collection(collection_id)?;821 ensure!(822 target_collection.sponsorship.pending_sponsor() == Some(&sender),823 Error::<T>::ConfirmUnsetSponsorFail824 );825826 target_collection.sponsorship = SponsorshipState::Confirmed(sender);827 Self::save_collection(target_collection);828829 Ok(())830 }831832 /// Switch back to pay-per-own-transaction model.833 ///834 /// # Permissions835 ///836 /// * Collection owner.837 ///838 /// # Arguments839 ///840 /// * collection_id.841 #[weight = <T as Config>::WeightInfo::remove_collection_sponsor()]842 #[transactional]843 pub fn remove_collection_sponsor(origin, collection_id: CollectionId) -> DispatchResult {844 let sender = ensure_signed(origin)?;845846 let mut target_collection = Self::get_collection(collection_id)?;847 Self::check_owner_permissions(&target_collection, &sender)?;848849 target_collection.sponsorship = SponsorshipState::Disabled;850 Self::save_collection(target_collection);851852 Ok(())853 }854855 /// This method creates a concrete instance of NFT Collection created with CreateCollection method.856 ///857 /// # Permissions858 ///859 /// * Collection Owner.860 /// * Collection Admin.861 /// * Anyone if862 /// * White List is enabled, and863 /// * Address is added to white list, and864 /// * MintPermission is enabled (see SetMintPermission method)865 ///866 /// # Arguments867 ///868 /// * collection_id: ID of the collection.869 ///870 /// * owner: Address, initial owner of the NFT.871 ///872 /// * data: Token data to store on chain.873 // #[weight =874 // (130_000_000 as Weight)875 // .saturating_add((2135 as Weight).saturating_mul((properties.len() as u64) as Weight))876 // .saturating_add(RocksDbWeight::get().reads(10 as Weight))877 // .saturating_add(RocksDbWeight::get().writes(8 as Weight))]878879 #[weight = <T as Config>::WeightInfo::create_item(data.data_size())]880 #[transactional]881 pub fn create_item(origin, collection_id: CollectionId, owner: T::CrossAccountId, data: CreateItemData) -> DispatchResult {882 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);883 let collection = Self::get_collection(collection_id)?;884885 Self::create_item_internal(&sender, &collection, &owner, data)?;886887 Self::submit_logs(collection)?;888 Ok(())889 }890891 /// This method creates multiple items in a collection created with CreateCollection method.892 ///893 /// # Permissions894 ///895 /// * Collection Owner.896 /// * Collection Admin.897 /// * Anyone if898 /// * White List is enabled, and899 /// * Address is added to white list, and900 /// * MintPermission is enabled (see SetMintPermission method)901 ///902 /// # Arguments903 ///904 /// * collection_id: ID of the collection.905 ///906 /// * itemsData: Array items properties. Each property is an array of bytes itself, see [create_item].907 ///908 /// * owner: Address, initial owner of the NFT.909 #[weight = <T as Config>::WeightInfo::create_item(items_data.iter()910 .map(|data| { data.data_size() })911 .sum())]912 #[transactional]913 pub fn create_multiple_items(origin, collection_id: CollectionId, owner: T::CrossAccountId, items_data: Vec<CreateItemData>) -> DispatchResult {914915 ensure!(!items_data.is_empty(), Error::<T>::EmptyArgument);916 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);917 let collection = Self::get_collection(collection_id)?;918919 Self::create_multiple_items_internal(&sender, &collection, &owner, items_data)?;920921 Self::submit_logs(collection)?;922 Ok(())923 }924925 /// Destroys a concrete instance of NFT.926 ///927 /// # Permissions928 ///929 /// * Collection Owner.930 /// * Collection Admin.931 /// * Current NFT Owner.932 ///933 /// # Arguments934 ///935 /// * collection_id: ID of the collection.936 ///937 /// * item_id: ID of NFT to burn.938 #[weight = <T as Config>::WeightInfo::burn_item()]939 #[transactional]940 pub fn burn_item(origin, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {941942 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);943 let target_collection = Self::get_collection(collection_id)?;944945 Self::burn_item_internal(&sender, &target_collection, item_id, value)?;946947 Self::submit_logs(target_collection)?;948 Ok(())949 }950951 /// Change ownership of the token.952 ///953 /// # Permissions954 ///955 /// * Collection Owner956 /// * Collection Admin957 /// * Current NFT owner958 ///959 /// # Arguments960 ///961 /// * recipient: Address of token recipient.962 ///963 /// * collection_id.964 ///965 /// * item_id: ID of the item966 /// * Non-Fungible Mode: Required.967 /// * Fungible Mode: Ignored.968 /// * Re-Fungible Mode: Required.969 ///970 /// * value: Amount to transfer.971 /// * Non-Fungible Mode: Ignored972 /// * Fungible Mode: Must specify transferred amount973 /// * Re-Fungible Mode: Must specify transferred portion (between 0 and 1)974 #[weight = <T as Config>::WeightInfo::transfer()]975 #[transactional]976 pub fn transfer(origin, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128) -> DispatchResult {977 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);978 let collection = Self::get_collection(collection_id)?;979980 Self::transfer_internal(&sender, &recipient, &collection, item_id, value)?;981982 Self::submit_logs(collection)?;983 Ok(())984 }985986 /// Set, change, or remove approved address to transfer the ownership of the NFT.987 ///988 /// # Permissions989 ///990 /// * Collection Owner991 /// * Collection Admin992 /// * Current NFT owner993 ///994 /// # Arguments995 ///996 /// * approved: Address that is approved to transfer this NFT or zero (if needed to remove approval).997 ///998 /// * collection_id.999 ///1000 /// * item_id: ID of the item.1001 #[weight = <T as Config>::WeightInfo::approve()]1002 #[transactional]1003 pub fn approve(origin, spender: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResult {1004 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1005 let collection = Self::get_collection(collection_id)?;10061007 Self::approve_internal(&sender, &spender, &collection, item_id, amount)?;10081009 Self::submit_logs(collection)?;1010 Ok(())1011 }10121013 /// 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.1014 ///1015 /// # Permissions1016 /// * Collection Owner1017 /// * Collection Admin1018 /// * Current NFT owner1019 /// * Address approved by current NFT owner1020 ///1021 /// # Arguments1022 ///1023 /// * from: Address that owns token.1024 ///1025 /// * recipient: Address of token recipient.1026 ///1027 /// * collection_id.1028 ///1029 /// * item_id: ID of the item.1030 ///1031 /// * value: Amount to transfer.1032 #[weight = <T as Config>::WeightInfo::transfer_from()]1033 #[transactional]1034 pub fn transfer_from(origin, from: T::CrossAccountId, recipient: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, value: u128 ) -> DispatchResult {1035 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1036 let collection = Self::get_collection(collection_id)?;10371038 Self::transfer_from_internal(&sender, &from, &recipient, &collection, item_id, value)?;10391040 Self::submit_logs(collection)?;1041 Ok(())1042 }1043 // #[weight = 0]1044 // // let no_perm_mes = "You do not have permissions to modify this collection";1045 // // ensure!(<ApprovedList<T>>::contains_key((collection_id, item_id)), no_perm_mes);1046 // // let list_itm = <ApprovedList<T>>::get((collection_id, item_id));1047 // // ensure!(list_itm.contains(&new_owner.clone()), no_perm_mes);10481049 // // // on_nft_received call10501051 // // Self::transfer(origin, collection_id, item_id, new_owner)?;10521053 // Ok(())1054 // }10551056 /// Set off-chain data schema.1057 ///1058 /// # Permissions1059 ///1060 /// * Collection Owner1061 /// * Collection Admin1062 ///1063 /// # Arguments1064 ///1065 /// * collection_id.1066 ///1067 /// * schema: String representing the offchain data schema.1068 #[weight = <T as Config>::WeightInfo::set_variable_meta_data()]1069 #[transactional]1070 pub fn set_variable_meta_data (1071 origin,1072 collection_id: CollectionId,1073 item_id: TokenId,1074 data: Vec<u8>1075 ) -> DispatchResult {1076 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);10771078 let collection = Self::get_collection(collection_id)?;10791080 Self::set_variable_meta_data_internal(&sender, &collection, item_id, data)?;10811082 Ok(())1083 }10841085 /// Set schema standard1086 /// ImageURL1087 /// Unique1088 ///1089 /// # Permissions1090 ///1091 /// * Collection Owner1092 /// * Collection Admin1093 ///1094 /// # Arguments1095 ///1096 /// * collection_id.1097 ///1098 /// * schema: SchemaVersion: enum1099 #[weight = <T as Config>::WeightInfo::set_schema_version()]1100 #[transactional]1101 pub fn set_schema_version(1102 origin,1103 collection_id: CollectionId,1104 version: SchemaVersion1105 ) -> DispatchResult {1106 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1107 let mut target_collection = Self::get_collection(collection_id)?;1108 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;1109 target_collection.schema_version = version;1110 Self::save_collection(target_collection);11111112 Ok(())1113 }11141115 /// Set off-chain data schema.1116 ///1117 /// # Permissions1118 ///1119 /// * Collection Owner1120 /// * Collection Admin1121 ///1122 /// # Arguments1123 ///1124 /// * collection_id.1125 ///1126 /// * schema: String representing the offchain data schema.1127 #[weight = <T as Config>::WeightInfo::set_offchain_schema()]1128 #[transactional]1129 pub fn set_offchain_schema(1130 origin,1131 collection_id: CollectionId,1132 schema: Vec<u8>1133 ) -> DispatchResult {1134 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1135 let mut target_collection = Self::get_collection(collection_id)?;1136 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11371138 // check schema limit1139 ensure!(schema.len() as u32 <= ChainLimit::get().offchain_schema_limit, "");11401141 target_collection.offchain_schema = schema;1142 Self::save_collection(target_collection);11431144 Ok(())1145 }11461147 /// Set const on-chain data schema.1148 ///1149 /// # Permissions1150 ///1151 /// * Collection Owner1152 /// * Collection Admin1153 ///1154 /// # Arguments1155 ///1156 /// * collection_id.1157 ///1158 /// * schema: String representing the const on-chain data schema.1159 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1160 #[transactional]1161 pub fn set_const_on_chain_schema (1162 origin,1163 collection_id: CollectionId,1164 schema: Vec<u8>1165 ) -> DispatchResult {1166 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1167 let mut target_collection = Self::get_collection(collection_id)?;1168 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;11691170 // check schema limit1171 ensure!(schema.len() as u32 <= ChainLimit::get().const_on_chain_schema_limit, "");11721173 target_collection.const_on_chain_schema = schema;1174 Self::save_collection(target_collection);11751176 Ok(())1177 }11781179 /// Set variable on-chain data schema.1180 ///1181 /// # Permissions1182 ///1183 /// * Collection Owner1184 /// * Collection Admin1185 ///1186 /// # Arguments1187 ///1188 /// * collection_id.1189 ///1190 /// * schema: String representing the variable on-chain data schema.1191 #[weight = <T as Config>::WeightInfo::set_const_on_chain_schema()]1192 #[transactional]1193 pub fn set_variable_on_chain_schema (1194 origin,1195 collection_id: CollectionId,1196 schema: Vec<u8>1197 ) -> DispatchResult {1198 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1199 let mut target_collection = Self::get_collection(collection_id)?;1200 Self::check_owner_or_admin_permissions(&target_collection, &sender)?;12011202 // check schema limit1203 ensure!(schema.len() as u32 <= ChainLimit::get().variable_on_chain_schema_limit, "");12041205 target_collection.variable_on_chain_schema = schema;1206 Self::save_collection(target_collection);12071208 Ok(())1209 }12101211 // Sudo permissions function1212 #[weight = <T as Config>::WeightInfo::set_chain_limits()]1213 #[transactional]1214 pub fn set_chain_limits(1215 origin,1216 limits: ChainLimits1217 ) -> DispatchResult {12181219 #[cfg(not(feature = "runtime-benchmarks"))]1220 ensure_root(origin)?;12211222 <ChainLimit>::put(limits);1223 Ok(())1224 }12251226 #[weight = <T as Config>::WeightInfo::set_collection_limits()]1227 #[transactional]1228 pub fn set_collection_limits(1229 origin,1230 collection_id: u32,1231 new_limits: CollectionLimits<T::BlockNumber>,1232 ) -> DispatchResult {1233 let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?);1234 let mut target_collection = Self::get_collection(collection_id)?;1235 Self::check_owner_permissions(&target_collection, sender.as_sub())?;1236 let old_limits = &target_collection.limits;1237 let chain_limits = ChainLimit::get();12381239 // collection bounds1240 ensure!(new_limits.sponsor_transfer_timeout <= MAX_SPONSOR_TIMEOUT &&1241 new_limits.account_token_ownership_limit <= MAX_TOKEN_OWNERSHIP &&1242 new_limits.sponsored_data_size <= chain_limits.custom_data_limit,1243 Error::<T>::CollectionLimitBoundsExceeded);12441245 // token_limit check prev1246 ensure!(old_limits.token_limit >= new_limits.token_limit, Error::<T>::CollectionTokenLimitExceeded);1247 ensure!(new_limits.token_limit > 0, Error::<T>::CollectionTokenLimitExceeded);12481249 ensure!(1250 (old_limits.owner_can_transfer || !new_limits.owner_can_transfer) &&1251 (old_limits.owner_can_destroy || !new_limits.owner_can_destroy),1252 Error::<T>::OwnerPermissionsCantBeReverted,1253 );12541255 target_collection.limits = new_limits;1256 Self::save_collection(target_collection);12571258 Ok(())1259 }1260 }1261}12621263impl<T: Config> Module<T> {1264 pub fn create_item_internal(1265 sender: &T::CrossAccountId,1266 collection: &CollectionHandle<T>,1267 owner: &T::CrossAccountId,1268 data: CreateItemData,1269 ) -> DispatchResult {1270 Self::can_create_items_in_collection(collection, sender, owner, 1)?;1271 Self::validate_create_item_args(collection, &data)?;1272 Self::create_item_no_validation(collection, owner, data)?;12731274 Ok(())1275 }12761277 pub fn transfer_internal(1278 sender: &T::CrossAccountId,1279 recipient: &T::CrossAccountId,1280 target_collection: &CollectionHandle<T>,1281 item_id: TokenId,1282 value: u128,1283 ) -> DispatchResult {1284 target_collection.consume_gas(2000000)?;1285 // Limits check1286 Self::is_correct_transfer(target_collection, recipient)?;12871288 // Transfer permissions check1289 ensure!(1290 Self::is_item_owner(sender, target_collection, item_id)1291 || Self::is_owner_or_admin_permissions(target_collection, sender),1292 Error::<T>::NoPermission1293 );12941295 if target_collection.access == AccessMode::WhiteList {1296 Self::check_white_list(target_collection, sender)?;1297 Self::check_white_list(target_collection, recipient)?;1298 }12991300 match target_collection.mode {1301 CollectionMode::NFT => Self::transfer_nft(1302 target_collection,1303 item_id,1304 sender.clone(),1305 recipient.clone(),1306 )?,1307 CollectionMode::Fungible(_) => {1308 Self::transfer_fungible(target_collection, value, sender, recipient)?1309 }1310 CollectionMode::ReFungible => Self::transfer_refungible(1311 target_collection,1312 item_id,1313 value,1314 sender.clone(),1315 recipient.clone(),1316 )?,1317 _ => (),1318 };13191320 Self::deposit_event(RawEvent::Transfer(1321 target_collection.id,1322 item_id,1323 sender.clone(),1324 recipient.clone(),1325 value,1326 ));13271328 Ok(())1329 }13301331 pub fn approve_internal(1332 sender: &T::CrossAccountId,1333 spender: &T::CrossAccountId,1334 collection: &CollectionHandle<T>,1335 item_id: TokenId,1336 amount: u128,1337 ) -> DispatchResult {1338 collection.consume_gas(2000000)?;1339 Self::token_exists(collection, item_id)?;13401341 // Transfer permissions check1342 let bypasses_limits = collection.limits.owner_can_transfer1343 && Self::is_owner_or_admin_permissions(collection, sender);13441345 let allowance_limit = if bypasses_limits {1346 None1347 } else if let Some(amount) = Self::owned_amount(sender, collection, item_id) {1348 Some(amount)1349 } else {1350 fail!(Error::<T>::NoPermission);1351 };13521353 if collection.access == AccessMode::WhiteList {1354 Self::check_white_list(collection, sender)?;1355 Self::check_white_list(collection, spender)?;1356 }13571358 let allowance: u128 = amount1359 .checked_add(<Allowances<T>>::get(1360 collection.id,1361 (item_id, sender.as_sub(), spender.as_sub()),1362 ))1363 .ok_or(Error::<T>::NumOverflow)?;1364 if let Some(limit) = allowance_limit {1365 ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1366 }1367 <Allowances<T>>::insert(1368 collection.id,1369 (item_id, sender.as_sub(), spender.as_sub()),1370 allowance,1371 );13721373 if matches!(collection.mode, CollectionMode::NFT) {1374 // TODO: NFT: only one owner may exist for token in ERC7211375 collection.log(ERC721Events::Approval {1376 owner: *sender.as_eth(),1377 approved: *spender.as_eth(),1378 token_id: item_id.into(),1379 });1380 }13811382 if matches!(collection.mode, CollectionMode::Fungible(_)) {1383 // TODO: NFT: only one owner may exist for token in ERC201384 collection.log(ERC20Events::Approval {1385 owner: *sender.as_eth(),1386 spender: *spender.as_eth(),1387 value: allowance.into(),1388 });1389 }13901391 Self::deposit_event(RawEvent::Approved(1392 collection.id,1393 item_id,1394 sender.clone(),1395 spender.clone(),1396 allowance,1397 ));1398 Ok(())1399 }14001401 pub fn transfer_from_internal(1402 sender: &T::CrossAccountId,1403 from: &T::CrossAccountId,1404 recipient: &T::CrossAccountId,1405 collection: &CollectionHandle<T>,1406 item_id: TokenId,1407 amount: u128,1408 ) -> DispatchResult {1409 collection.consume_gas(2000000)?;1410 // Check approval1411 let approval: u128 =1412 <Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));14131414 // Limits check1415 Self::is_correct_transfer(collection, recipient)?;14161417 // Transfer permissions check1418 ensure!(1419 approval >= amount1420 || (collection.limits.owner_can_transfer1421 && Self::is_owner_or_admin_permissions(collection, sender)),1422 Error::<T>::NoPermission1423 );14241425 if collection.access == AccessMode::WhiteList {1426 Self::check_white_list(collection, sender)?;1427 Self::check_white_list(collection, recipient)?;1428 }14291430 // Reduce approval by transferred amount or remove if remaining approval drops to 01431 let allowance = approval.saturating_sub(amount);1432 if allowance > 0 {1433 <Allowances<T>>::insert(1434 collection.id,1435 (item_id, from.as_sub(), sender.as_sub()),1436 allowance,1437 );1438 } else {1439 <Allowances<T>>::remove(collection.id, (item_id, from.as_sub(), sender.as_sub()));1440 }14411442 match collection.mode {1443 CollectionMode::NFT => {1444 Self::transfer_nft(collection, item_id, from.clone(), recipient.clone())?1445 }1446 CollectionMode::Fungible(_) => {1447 Self::transfer_fungible(collection, amount, from, recipient)?1448 }1449 CollectionMode::ReFungible => Self::transfer_refungible(1450 collection,1451 item_id,1452 amount,1453 from.clone(),1454 recipient.clone(),1455 )?,1456 _ => (),1457 };14581459 if matches!(collection.mode, CollectionMode::Fungible(_)) {1460 collection.log(ERC20Events::Approval {1461 owner: *from.as_eth(),1462 spender: *sender.as_eth(),1463 value: allowance.into(),1464 });1465 }14661467 Ok(())1468 }14691470 pub fn set_variable_meta_data_internal(1471 sender: &T::CrossAccountId,1472 collection: &CollectionHandle<T>,1473 item_id: TokenId,1474 data: Vec<u8>,1475 ) -> DispatchResult {1476 Self::token_exists(collection, item_id)?;14771478 ensure!(1479 ChainLimit::get().custom_data_limit >= data.len() as u32,1480 Error::<T>::TokenVariableDataLimitExceeded1481 );14821483 // Modify permissions check1484 ensure!(1485 Self::is_item_owner(sender, collection, item_id)1486 || Self::is_owner_or_admin_permissions(collection, sender),1487 Error::<T>::NoPermission1488 );14891490 match collection.mode {1491 CollectionMode::NFT => Self::set_nft_variable_data(collection, item_id, data)?,1492 CollectionMode::ReFungible => {1493 Self::set_re_fungible_variable_data(collection, item_id, data)?1494 }1495 CollectionMode::Fungible(_) => fail!(Error::<T>::CantStoreMetadataInFungibleTokens),1496 _ => fail!(Error::<T>::UnexpectedCollectionType),1497 };14981499 Ok(())1500 }15011502 pub fn create_multiple_items_internal(1503 sender: &T::CrossAccountId,1504 collection: &CollectionHandle<T>,1505 owner: &T::CrossAccountId,1506 items_data: Vec<CreateItemData>,1507 ) -> DispatchResult {1508 Self::can_create_items_in_collection(collection, sender, owner, items_data.len() as u32)?;15091510 for data in &items_data {1511 Self::validate_create_item_args(collection, data)?;1512 }1513 for data in &items_data {1514 Self::create_item_no_validation(collection, owner, data.clone())?;1515 }15161517 Ok(())1518 }15191520 pub fn burn_item_internal(1521 sender: &T::CrossAccountId,1522 collection: &CollectionHandle<T>,1523 item_id: TokenId,1524 value: u128,1525 ) -> DispatchResult {1526 ensure!(1527 Self::is_item_owner(sender, collection, item_id)1528 || (collection.limits.owner_can_transfer1529 && Self::is_owner_or_admin_permissions(collection, sender)),1530 Error::<T>::NoPermission1531 );15321533 if collection.access == AccessMode::WhiteList {1534 Self::check_white_list(collection, sender)?;1535 }15361537 match collection.mode {1538 CollectionMode::NFT => Self::burn_nft_item(collection, item_id)?,1539 CollectionMode::Fungible(_) => Self::burn_fungible_item(sender, collection, value)?,1540 CollectionMode::ReFungible => Self::burn_refungible_item(collection, item_id, sender)?,1541 _ => (),1542 };15431544 Ok(())1545 }15461547 pub fn toggle_white_list_internal(1548 sender: &T::CrossAccountId,1549 collection: &CollectionHandle<T>,1550 address: &T::CrossAccountId,1551 whitelisted: bool,1552 ) -> DispatchResult {1553 Self::check_owner_or_admin_permissions(collection, sender)?;15541555 if whitelisted {1556 <WhiteList<T>>::insert(collection.id, address.as_sub(), true);1557 } else {1558 <WhiteList<T>>::remove(collection.id, address.as_sub());1559 }15601561 Ok(())1562 }15631564 fn is_correct_transfer(1565 collection: &CollectionHandle<T>,1566 recipient: &T::CrossAccountId,1567 ) -> DispatchResult {1568 let collection_id = collection.id;15691570 // check token limit and account token limit1571 let account_items: u32 =1572 <AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;1573 ensure!(1574 collection.limits.account_token_ownership_limit > account_items,1575 Error::<T>::AccountTokenLimitExceeded1576 );15771578 Ok(())1579 }15801581 fn can_create_items_in_collection(1582 collection: &CollectionHandle<T>,1583 sender: &T::CrossAccountId,1584 owner: &T::CrossAccountId,1585 amount: u32,1586 ) -> DispatchResult {1587 let collection_id = collection.id;15881589 // check token limit and account token limit1590 let total_items: u32 = ItemListIndex::get(collection_id)1591 .checked_add(amount)1592 .ok_or(Error::<T>::CollectionTokenLimitExceeded)?;1593 let account_items: u32 = (<AddressTokens<T>>::get(collection_id, owner.as_sub()).len()1594 as u32)1595 .checked_add(amount)1596 .ok_or(Error::<T>::AccountTokenLimitExceeded)?;1597 ensure!(1598 collection.limits.token_limit >= total_items,1599 Error::<T>::CollectionTokenLimitExceeded1600 );1601 ensure!(1602 collection.limits.account_token_ownership_limit >= account_items,1603 Error::<T>::AccountTokenLimitExceeded1604 );16051606 if !Self::is_owner_or_admin_permissions(collection, sender) {1607 ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1608 Self::check_white_list(collection, owner)?;1609 Self::check_white_list(collection, sender)?;1610 }16111612 Ok(())1613 }16141615 fn validate_create_item_args(1616 target_collection: &CollectionHandle<T>,1617 data: &CreateItemData,1618 ) -> DispatchResult {1619 match target_collection.mode {1620 CollectionMode::NFT => {1621 if let CreateItemData::NFT(data) = data {1622 // check sizes1623 ensure!(1624 ChainLimit::get().custom_data_limit >= data.const_data.len() as u32,1625 Error::<T>::TokenConstDataLimitExceeded1626 );1627 ensure!(1628 ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32,1629 Error::<T>::TokenVariableDataLimitExceeded1630 );1631 } else {1632 fail!(Error::<T>::NotNftDataUsedToMintNftCollectionToken);1633 }1634 }1635 CollectionMode::Fungible(_) => {1636 if let CreateItemData::Fungible(_) = data {1637 } else {1638 fail!(Error::<T>::NotFungibleDataUsedToMintFungibleCollectionToken);1639 }1640 }1641 CollectionMode::ReFungible => {1642 if let CreateItemData::ReFungible(data) = data {1643 // check sizes1644 ensure!(1645 ChainLimit::get().custom_data_limit >= data.const_data.len() as u32,1646 Error::<T>::TokenConstDataLimitExceeded1647 );1648 ensure!(1649 ChainLimit::get().custom_data_limit >= data.variable_data.len() as u32,1650 Error::<T>::TokenVariableDataLimitExceeded1651 );16521653 // Check refungibility limits1654 ensure!(1655 data.pieces <= MAX_REFUNGIBLE_PIECES,1656 Error::<T>::WrongRefungiblePieces1657 );1658 ensure!(data.pieces > 0, Error::<T>::WrongRefungiblePieces);1659 } else {1660 fail!(Error::<T>::NotReFungibleDataUsedToMintReFungibleCollectionToken);1661 }1662 }1663 _ => {1664 fail!(Error::<T>::UnexpectedCollectionType);1665 }1666 };16671668 Ok(())1669 }16701671 fn create_item_no_validation(1672 collection: &CollectionHandle<T>,1673 owner: &T::CrossAccountId,1674 data: CreateItemData,1675 ) -> DispatchResult {1676 match data {1677 CreateItemData::NFT(data) => {1678 let item = NftItemType {1679 owner: owner.clone(),1680 const_data: data.const_data,1681 variable_data: data.variable_data,1682 };16831684 Self::add_nft_item(collection, item)?;1685 }1686 CreateItemData::Fungible(data) => {1687 Self::add_fungible_item(collection, owner, data.value)?;1688 }1689 CreateItemData::ReFungible(data) => {1690 let owner_list = vec![Ownership {1691 owner: owner.clone(),1692 fraction: data.pieces,1693 }];16941695 let item = ReFungibleItemType {1696 owner: owner_list,1697 const_data: data.const_data,1698 variable_data: data.variable_data,1699 };17001701 Self::add_refungible_item(collection, item)?;1702 }1703 };17041705 Ok(())1706 }17071708 fn add_fungible_item(1709 collection: &CollectionHandle<T>,1710 owner: &T::CrossAccountId,1711 value: u128,1712 ) -> DispatchResult {1713 let collection_id = collection.id;17141715 // Does new owner already have an account?1716 let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;17171718 // Mint1719 let item = FungibleItemType {1720 value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1721 };1722 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);17231724 // Update balance1725 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1726 .checked_add(value)1727 .ok_or(Error::<T>::NumOverflow)?;1728 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17291730 Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1731 Ok(())1732 }17331734 fn add_refungible_item(1735 collection: &CollectionHandle<T>,1736 item: ReFungibleItemType<T::CrossAccountId>,1737 ) -> DispatchResult {1738 let collection_id = collection.id;17391740 let current_index = <ItemListIndex>::get(collection_id)1741 .checked_add(1)1742 .ok_or(Error::<T>::NumOverflow)?;1743 let itemcopy = item.clone();17441745 ensure!(item.owner.len() == 1, Error::<T>::BadCreateRefungibleCall,);1746 let item_owner = item.owner.first().expect("only one owner is defined");17471748 let value = item_owner.fraction;1749 let owner = item_owner.owner.clone();17501751 Self::add_token_index(collection_id, current_index, &owner)?;17521753 <ItemListIndex>::insert(collection_id, current_index);1754 <ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);17551756 // Update balance1757 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1758 .checked_add(value)1759 .ok_or(Error::<T>::NumOverflow)?;1760 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);17611762 Self::deposit_event(RawEvent::ItemCreated(collection_id, current_index, owner));1763 Ok(())1764 }17651766 fn add_nft_item(1767 collection: &CollectionHandle<T>,1768 item: NftItemType<T::CrossAccountId>,1769 ) -> DispatchResult {1770 let collection_id = collection.id;17711772 let current_index = <ItemListIndex>::get(collection_id)1773 .checked_add(1)1774 .ok_or(Error::<T>::NumOverflow)?;17751776 let item_owner = item.owner.clone();1777 Self::add_token_index(collection_id, current_index, &item.owner)?;17781779 <ItemListIndex>::insert(collection_id, current_index);1780 <NftItemList<T>>::insert(collection_id, current_index, item);17811782 // Update balance1783 let new_balance = <Balance<T>>::get(collection_id, item_owner.as_sub())1784 .checked_add(1)1785 .ok_or(Error::<T>::NumOverflow)?;1786 <Balance<T>>::insert(collection_id, item_owner.as_sub(), new_balance);17871788 collection.log(ERC721Events::Transfer {1789 from: H160::default(),1790 to: *item_owner.as_eth(),1791 token_id: current_index.into(),1792 });1793 Self::deposit_event(RawEvent::ItemCreated(1794 collection_id,1795 current_index,1796 item_owner,1797 ));1798 Ok(())1799 }18001801 fn burn_refungible_item(1802 collection: &CollectionHandle<T>,1803 item_id: TokenId,1804 owner: &T::CrossAccountId,1805 ) -> DispatchResult {1806 let collection_id = collection.id;18071808 let mut token = <ReFungibleItemList<T>>::get(collection_id, item_id)1809 .ok_or(Error::<T>::TokenNotFound)?;1810 let rft_balance = token1811 .owner1812 .iter()1813 .find(|&i| i.owner == *owner)1814 .ok_or(Error::<T>::TokenNotFound)?;1815 Self::remove_token_index(collection_id, item_id, owner)?;18161817 // update balance1818 let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1819 .checked_sub(rft_balance.fraction)1820 .ok_or(Error::<T>::NumOverflow)?;1821 <Balance<T>>::insert(collection_id, rft_balance.owner.as_sub(), new_balance);18221823 // Re-create owners list with sender removed1824 let index = token1825 .owner1826 .iter()1827 .position(|i| i.owner == *owner)1828 .expect("owned item is exists");1829 token.owner.remove(index);1830 let owner_count = token.owner.len();18311832 // Burn the token completely if this was the last (only) owner1833 if owner_count == 0 {1834 <ReFungibleItemList<T>>::remove(collection_id, item_id);1835 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);1836 } else {1837 <ReFungibleItemList<T>>::insert(collection_id, item_id, token);1838 }18391840 Ok(())1841 }18421843 fn burn_nft_item(collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1844 let collection_id = collection.id;18451846 let item =1847 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1848 Self::remove_token_index(collection_id, item_id, &item.owner)?;18491850 // update balance1851 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1852 .checked_sub(1)1853 .ok_or(Error::<T>::NumOverflow)?;1854 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);1855 <NftItemList<T>>::remove(collection_id, item_id);1856 <VariableMetaDataBasket<T>>::remove(collection_id, item_id);18571858 Self::deposit_event(RawEvent::ItemDestroyed(collection.id, item_id));1859 Ok(())1860 }18611862 fn burn_fungible_item(1863 owner: &T::CrossAccountId,1864 collection: &CollectionHandle<T>,1865 value: u128,1866 ) -> DispatchResult {1867 let collection_id = collection.id;18681869 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1870 ensure!(balance.value >= value, Error::<T>::TokenValueNotEnough);18711872 // update balance1873 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1874 .checked_sub(value)1875 .ok_or(Error::<T>::NumOverflow)?;1876 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);18771878 if balance.value - value > 0 {1879 balance.value -= value;1880 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);1881 } else {1882 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());1883 }18841885 collection.log(ERC20Events::Transfer {1886 from: *owner.as_eth(),1887 to: H160::default(),1888 value: value.into(),1889 });1890 Ok(())1891 }18921893 pub fn get_collection(1894 collection_id: CollectionId,1895 ) -> Result<CollectionHandle<T>, sp_runtime::DispatchError> {1896 Ok(<CollectionHandle<T>>::get(collection_id).ok_or(Error::<T>::CollectionNotFound)?)1897 }18981899 fn save_collection(collection: CollectionHandle<T>) {1900 <CollectionById<T>>::insert(collection.id, collection.into_inner());1901 }19021903 pub fn submit_logs(collection: CollectionHandle<T>) -> DispatchResult {1904 if collection.logs.is_empty() {1905 return Ok(());1906 }1907 T::EthereumTransactionSender::submit_logs_transaction(1908 eth::generate_transaction(collection.id, T::EthereumChainId::get()),1909 collection.logs.retrieve_logs(),1910 )1911 }19121913 fn check_owner_permissions(1914 target_collection: &CollectionHandle<T>,1915 subject: &T::AccountId,1916 ) -> DispatchResult {1917 ensure!(1918 *subject == target_collection.owner,1919 Error::<T>::NoPermission1920 );19211922 Ok(())1923 }19241925 fn is_owner_or_admin_permissions(1926 collection: &CollectionHandle<T>,1927 subject: &T::CrossAccountId,1928 ) -> bool {1929 *subject.as_sub() == collection.owner1930 || <AdminList<T>>::get(collection.id).contains(subject)1931 }19321933 fn check_owner_or_admin_permissions(1934 collection: &CollectionHandle<T>,1935 subject: &T::CrossAccountId,1936 ) -> DispatchResult {1937 ensure!(1938 Self::is_owner_or_admin_permissions(collection, subject),1939 Error::<T>::NoPermission1940 );19411942 Ok(())1943 }19441945 fn owned_amount(1946 subject: &T::CrossAccountId,1947 target_collection: &CollectionHandle<T>,1948 item_id: TokenId,1949 ) -> Option<u128> {1950 let collection_id = target_collection.id;19511952 match target_collection.mode {1953 CollectionMode::NFT => {1954 (<NftItemList<T>>::get(collection_id, item_id)?.owner == *subject).then(|| 1)1955 }1956 CollectionMode::Fungible(_) => {1957 Some(<FungibleItemList<T>>::get(collection_id, &subject.as_sub()).value)1958 }1959 CollectionMode::ReFungible => <ReFungibleItemList<T>>::get(collection_id, item_id)?1960 .owner1961 .iter()1962 .find(|i| i.owner == *subject)1963 .map(|i| i.fraction),1964 CollectionMode::Invalid => None,1965 }1966 }19671968 fn is_item_owner(1969 subject: &T::CrossAccountId,1970 target_collection: &CollectionHandle<T>,1971 item_id: TokenId,1972 ) -> bool {1973 match target_collection.mode {1974 CollectionMode::Fungible(_) => true,1975 _ => Self::owned_amount(subject, target_collection, item_id).is_some(),1976 }1977 }19781979 fn check_white_list(1980 collection: &CollectionHandle<T>,1981 address: &T::CrossAccountId,1982 ) -> DispatchResult {1983 let collection_id = collection.id;19841985 let mes = Error::<T>::AddresNotInWhiteList;1986 ensure!(1987 <WhiteList<T>>::contains_key(collection_id, address.as_sub()),1988 mes1989 );19901991 Ok(())1992 }19931994 /// Check if token exists. In case of Fungible, check if there is an entry for1995 /// the owner in fungible balances double map1996 fn token_exists(target_collection: &CollectionHandle<T>, item_id: TokenId) -> DispatchResult {1997 let collection_id = target_collection.id;1998 let exists = match target_collection.mode {1999 CollectionMode::NFT => <NftItemList<T>>::contains_key(collection_id, item_id),2000 CollectionMode::Fungible(_) => true,2001 CollectionMode::ReFungible => {2002 <ReFungibleItemList<T>>::contains_key(collection_id, item_id)2003 }2004 _ => false,2005 };20062007 ensure!(exists, Error::<T>::TokenNotFound);2008 Ok(())2009 }20102011 fn transfer_fungible(2012 collection: &CollectionHandle<T>,2013 value: u128,2014 owner: &T::CrossAccountId,2015 recipient: &T::CrossAccountId,2016 ) -> DispatchResult {2017 let collection_id = collection.id;20182019 let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());2020 ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);20212022 // Send balance to recipient (updates balanceOf of recipient)2023 Self::add_fungible_item(collection, recipient, value)?;20242025 // update balanceOf of sender2026 <Balance<T>>::insert(collection_id, owner.as_sub(), balance.value - value);20272028 // Reduce or remove sender2029 if balance.value == value {2030 <FungibleItemList<T>>::remove(collection_id, owner.as_sub());2031 } else {2032 balance.value -= value;2033 <FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2034 }20352036 collection.log(ERC20Events::Transfer {2037 from: *owner.as_eth(),2038 to: *recipient.as_eth(),2039 value: value.into(),2040 });2041 Self::deposit_event(RawEvent::Transfer(2042 collection.id,2043 1,2044 owner.clone(),2045 recipient.clone(),2046 value,2047 ));20482049 Ok(())2050 }20512052 fn transfer_refungible(2053 collection: &CollectionHandle<T>,2054 item_id: TokenId,2055 value: u128,2056 owner: T::CrossAccountId,2057 new_owner: T::CrossAccountId,2058 ) -> DispatchResult {2059 let collection_id = collection.id;2060 let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2061 .ok_or(Error::<T>::TokenNotFound)?;20622063 let item = full_item2064 .owner2065 .iter()2066 .find(|i| i.owner == owner)2067 .ok_or(Error::<T>::TokenNotFound)?;2068 let amount = item.fraction;20692070 ensure!(amount >= value, Error::<T>::TokenValueTooLow);20712072 // update balance2073 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2074 .checked_sub(value)2075 .ok_or(Error::<T>::NumOverflow)?;2076 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);20772078 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2079 .checked_add(value)2080 .ok_or(Error::<T>::NumOverflow)?;2081 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);20822083 let old_owner = item.owner.clone();2084 let new_owner_has_account = full_item.owner.iter().any(|i| i.owner == new_owner);20852086 let mut new_full_item = full_item.clone();2087 // transfer2088 if amount == value && !new_owner_has_account {2089 // change owner2090 // new owner do not have account2091 new_full_item2092 .owner2093 .iter_mut()2094 .find(|i| i.owner == owner)2095 .expect("old owner does present in refungible")2096 .owner = new_owner.clone();2097 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);20982099 // update index collection2100 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2101 } else {2102 new_full_item2103 .owner2104 .iter_mut()2105 .find(|i| i.owner == owner)2106 .expect("old owner does present in refungible")2107 .fraction -= value;21082109 // separate amount2110 if new_owner_has_account {2111 // new owner has account2112 new_full_item2113 .owner2114 .iter_mut()2115 .find(|i| i.owner == new_owner)2116 .expect("new owner has account")2117 .fraction += value;2118 } else {2119 // new owner do not have account2120 new_full_item.owner.push(Ownership {2121 owner: new_owner.clone(),2122 fraction: value,2123 });2124 Self::add_token_index(collection_id, item_id, &new_owner)?;2125 }21262127 <ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2128 }21292130 Self::deposit_event(RawEvent::Transfer(2131 collection.id,2132 item_id,2133 owner,2134 new_owner,2135 amount,2136 ));21372138 Ok(())2139 }21402141 fn transfer_nft(2142 collection: &CollectionHandle<T>,2143 item_id: TokenId,2144 sender: T::CrossAccountId,2145 new_owner: T::CrossAccountId,2146 ) -> DispatchResult {2147 let collection_id = collection.id;2148 let mut item =2149 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;21502151 ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);21522153 // update balance2154 let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2155 .checked_sub(1)2156 .ok_or(Error::<T>::NumOverflow)?;2157 <Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);21582159 let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2160 .checked_add(1)2161 .ok_or(Error::<T>::NumOverflow)?;2162 <Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);21632164 // change owner2165 let old_owner = item.owner.clone();2166 item.owner = new_owner.clone();2167 <NftItemList<T>>::insert(collection_id, item_id, item);21682169 // update index collection2170 Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;21712172 collection.log(ERC721Events::Transfer {2173 from: *sender.as_eth(),2174 to: *new_owner.as_eth(),2175 token_id: item_id.into(),2176 });2177 Self::deposit_event(RawEvent::Transfer(2178 collection.id,2179 item_id,2180 sender,2181 new_owner,2182 1,2183 ));21842185 Ok(())2186 }21872188 fn set_re_fungible_variable_data(2189 collection: &CollectionHandle<T>,2190 item_id: TokenId,2191 data: Vec<u8>,2192 ) -> DispatchResult {2193 let collection_id = collection.id;2194 let mut item = <ReFungibleItemList<T>>::get(collection_id, item_id)2195 .ok_or(Error::<T>::TokenNotFound)?;21962197 item.variable_data = data;21982199 <ReFungibleItemList<T>>::insert(collection_id, item_id, item);22002201 Ok(())2202 }22032204 fn set_nft_variable_data(2205 collection: &CollectionHandle<T>,2206 item_id: TokenId,2207 data: Vec<u8>,2208 ) -> DispatchResult {2209 let collection_id = collection.id;2210 let mut item =2211 <NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;22122213 item.variable_data = data;22142215 <NftItemList<T>>::insert(collection_id, item_id, item);22162217 Ok(())2218 }22192220 #[allow(dead_code)]2221 fn init_collection(item: &Collection<T>) {2222 // check params2223 assert!(2224 item.decimal_points <= MAX_DECIMAL_POINTS,2225 "decimal_points parameter must be lower than MAX_DECIMAL_POINTS"2226 );2227 assert!(2228 item.name.len() <= 64,2229 "Collection name can not be longer than 63 char"2230 );2231 assert!(2232 item.name.len() <= 256,2233 "Collection description can not be longer than 255 char"2234 );2235 assert!(2236 item.token_prefix.len() <= 16,2237 "Token prefix can not be longer than 15 char"2238 );22392240 // Generate next collection ID2241 let next_id = CreatedCollectionCount::get().checked_add(1).unwrap();22422243 CreatedCollectionCount::put(next_id);2244 }22452246 #[allow(dead_code)]2247 fn init_nft_token(collection_id: CollectionId, item: &NftItemType<T::CrossAccountId>) {2248 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22492250 Self::add_token_index(collection_id, current_index, &item.owner).unwrap();22512252 <ItemListIndex>::insert(collection_id, current_index);22532254 // Update balance2255 let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())2256 .checked_add(1)2257 .unwrap();2258 <Balance<T>>::insert(collection_id, item.owner.as_sub(), new_balance);2259 }22602261 #[allow(dead_code)]2262 fn init_fungible_token(2263 collection_id: CollectionId,2264 owner: &T::CrossAccountId,2265 item: &FungibleItemType,2266 ) {2267 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22682269 Self::add_token_index(collection_id, current_index, owner).unwrap();22702271 <ItemListIndex>::insert(collection_id, current_index);22722273 // Update balance2274 let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())2275 .checked_add(item.value)2276 .unwrap();2277 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2278 }22792280 #[allow(dead_code)]2281 fn init_refungible_token(2282 collection_id: CollectionId,2283 item: &ReFungibleItemType<T::CrossAccountId>,2284 ) {2285 let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();22862287 let value = item.owner.first().unwrap().fraction;2288 let owner = item.owner.first().unwrap().owner.clone();22892290 Self::add_token_index(collection_id, current_index, &owner).unwrap();22912292 <ItemListIndex>::insert(collection_id, current_index);22932294 // Update balance2295 let new_balance = <Balance<T>>::get(collection_id, &owner.as_sub())2296 .checked_add(value)2297 .unwrap();2298 <Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);2299 }23002301 fn add_token_index(2302 collection_id: CollectionId,2303 item_index: TokenId,2304 owner: &T::CrossAccountId,2305 ) -> DispatchResult {2306 // add to account limit2307 if <AccountItemCount<T>>::contains_key(owner.as_sub()) {2308 // bound Owned tokens by a single address2309 let count = <AccountItemCount<T>>::get(owner.as_sub());2310 ensure!(2311 count < ChainLimit::get().account_token_ownership_limit,2312 Error::<T>::AddressOwnershipLimitExceeded2313 );23142315 <AccountItemCount<T>>::insert(2316 owner.as_sub(),2317 count.checked_add(1).ok_or(Error::<T>::NumOverflow)?,2318 );2319 } else {2320 <AccountItemCount<T>>::insert(owner.as_sub(), 1);2321 }23222323 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2324 if list_exists {2325 let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2326 let item_contains = list.contains(&item_index.clone());23272328 if !item_contains {2329 list.push(item_index);2330 }23312332 <AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2333 } else {2334 let itm = vec![item_index];2335 <AddressTokens<T>>::insert(collection_id, owner.as_sub(), itm);2336 }23372338 Ok(())2339 }23402341 fn remove_token_index(2342 collection_id: CollectionId,2343 item_index: TokenId,2344 owner: &T::CrossAccountId,2345 ) -> DispatchResult {2346 // update counter2347 <AccountItemCount<T>>::insert(2348 owner.as_sub(),2349 <AccountItemCount<T>>::get(owner.as_sub())2350 .checked_sub(1)2351 .ok_or(Error::<T>::NumOverflow)?,2352 );23532354 let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2355 if list_exists {2356 let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2357 let item_contains = list.contains(&item_index.clone());23582359 if item_contains {2360 list.retain(|&item| item != item_index);2361 <AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2362 }2363 }23642365 Ok(())2366 }23672368 fn move_token_index(2369 collection_id: CollectionId,2370 item_index: TokenId,2371 old_owner: &T::CrossAccountId,2372 new_owner: &T::CrossAccountId,2373 ) -> DispatchResult {2374 Self::remove_token_index(collection_id, item_index, old_owner)?;2375 Self::add_token_index(collection_id, item_index, new_owner)?;23762377 Ok(())2378 }2379}23802381sp_api::decl_runtime_apis! {2382 pub trait NftApi {2383 /// Used for ethereum integration2384 fn eth_contract_code(account: H160) -> Option<Vec<u8>>;2385 }2386}1//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;
}