git.delta.rocks / unique-network / refs/commits / da8dccd94122

34use frame_system::{self as system, ensure_signed};34use frame_system::{self as system, ensure_signed};
35use sp_core::H160;35use sp_core::H160;
36use sp_std::vec;36use sp_std::vec;
37use sp_runtime::sp_std::prelude::Vec;37use sp_runtime::{DispatchError, sp_std::prelude::Vec};
38use core::ops::{Deref, DerefMut};38use core::ops::{Deref, DerefMut};
39use nft_data_structs::{39use nft_data_structs::{
40	MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,40	MAX_DECIMAL_POINTS, MAX_SPONSOR_TIMEOUT, MAX_TOKEN_OWNERSHIP, MAX_REFUNGIBLE_PIECES,
203	pub fn log(&self, log: impl evm_coder::ToLog) -> DispatchResult {203	pub fn log(&self, log: impl evm_coder::ToLog) -> DispatchResult {
204		self.recorder.log_sub(log)204		self.recorder.log_sub(log)
205	}205	}
206	#[allow(dead_code)]
206	fn consume_gas(&self, gas: u64) -> DispatchResult {207	fn consume_gas(&self, gas: u64) -> DispatchResult {
207		self.recorder.consume_gas_sub(gas)208		self.recorder.consume_gas_sub(gas)
208	}209	}
210	fn consume_sload(&self) -> DispatchResult {
211		self.recorder.consume_sload_sub()
212	}
213	fn consume_sstore(&self) -> DispatchResult {
214		self.recorder.consume_sstore_sub()
215	}
209	pub fn submit_logs(self) -> DispatchResult {216	pub fn submit_logs(self) -> DispatchResult {
210		self.recorder.submit_logs()217		self.recorder.submit_logs()
211	}218	}
1255		item_id: TokenId,1262		item_id: TokenId,
1256		value: u128,1263		value: u128,
1257	) -> DispatchResult {1264	) -> DispatchResult {
1258		target_collection.consume_gas(2000000)?;
1259		// Limits check1265		// Limits check
1260		Self::is_correct_transfer(target_collection, recipient)?;1266		Self::is_correct_transfer(target_collection, recipient)?;
12611267
1262		// Transfer permissions check1268		// Transfer permissions check
1263		ensure!(1269		ensure!(
1264			Self::is_item_owner(sender, target_collection, item_id)1270			Self::is_item_owner(sender, target_collection, item_id)?
1265				|| Self::is_owner_or_admin_permissions(target_collection, sender),1271				|| Self::is_owner_or_admin_permissions(target_collection, sender)?,
1266			Error::<T>::NoPermission1272			Error::<T>::NoPermission
1267		);1273		);
12681274
1309		item_id: TokenId,1315		item_id: TokenId,
1310		amount: u128,1316		amount: u128,
1311	) -> DispatchResult {1317	) -> DispatchResult {
1312		collection.consume_gas(2000000)?;
1313		Self::token_exists(collection, item_id)?;1318		Self::token_exists(collection, item_id)?;
13141319
1315		// Transfer permissions check1320		// Transfer permissions check
1316		let bypasses_limits = collection.limits.owner_can_transfer1321		let bypasses_limits = collection.limits.owner_can_transfer
1317			&& Self::is_owner_or_admin_permissions(collection, sender);1322			&& Self::is_owner_or_admin_permissions(collection, sender)?;
13181323
1319		let allowance_limit = if bypasses_limits {1324		let allowance_limit = if bypasses_limits {
1320			None1325			None
1321		} else if let Some(amount) = Self::owned_amount(sender, collection, item_id) {1326		} else if let Some(amount) = Self::owned_amount(sender, collection, item_id)? {
1322			Some(amount)1327			Some(amount)
1323		} else {1328		} else {
1324			fail!(Error::<T>::NoPermission);1329			fail!(Error::<T>::NoPermission);
1329			Self::check_white_list(collection, spender)?;1334			Self::check_white_list(collection, spender)?;
1330		}1335		}
13311336
1337		collection.consume_sload()?;
1332		let allowance: u128 = amount1338		let allowance: u128 = amount
1333			.checked_add(<Allowances<T>>::get(1339			.checked_add(<Allowances<T>>::get(
1334				collection.id,1340				collection.id,
1338		if let Some(limit) = allowance_limit {1344		if let Some(limit) = allowance_limit {
1339			ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);1345			ensure!(limit >= allowance, Error::<T>::TokenValueTooLow);
1340		}1346		}
1347		collection.consume_sstore()?;
1341		<Allowances<T>>::insert(1348		<Allowances<T>>::insert(
1342			collection.id,1349			collection.id,
1343			(item_id, sender.as_sub(), spender.as_sub()),1350			(item_id, sender.as_sub(), spender.as_sub()),
1380		item_id: TokenId,1387		item_id: TokenId,
1381		amount: u128,1388		amount: u128,
1382	) -> DispatchResult {1389	) -> DispatchResult {
1390		// Check approval
1383		collection.consume_gas(2000000)?;1391		collection.consume_sload()?;
1384		// Check approval
1385		let approval: u128 =1392		let approval: u128 =
1386			<Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));1393			<Allowances<T>>::get(collection.id, (item_id, from.as_sub(), sender.as_sub()));
13871394
1392		ensure!(1399		ensure!(
1393			approval >= amount1400			approval >= amount
1394				|| (collection.limits.owner_can_transfer1401				|| (collection.limits.owner_can_transfer
1395					&& Self::is_owner_or_admin_permissions(collection, sender)),1402					&& Self::is_owner_or_admin_permissions(collection, sender)?),
1396			Error::<T>::NoPermission1403			Error::<T>::NoPermission
1397		);1404		);
13981405
14031410
1404		// Reduce approval by transferred amount or remove if remaining approval drops to 01411		// Reduce approval by transferred amount or remove if remaining approval drops to 0
1405		let allowance = approval.saturating_sub(amount);1412		let allowance = approval.saturating_sub(amount);
1413		collection.consume_sstore()?;
1406		if allowance > 0 {1414		if allowance > 0 {
1407			<Allowances<T>>::insert(1415			<Allowances<T>>::insert(
1408				collection.id,1416				collection.id,
14561464
1457		// Modify permissions check1465		// Modify permissions check
1458		ensure!(1466		ensure!(
1459			Self::is_item_owner(sender, collection, item_id)1467			Self::is_item_owner(sender, collection, item_id)?
1460				|| Self::is_owner_or_admin_permissions(collection, sender),1468				|| Self::is_owner_or_admin_permissions(collection, sender)?,
1461			Error::<T>::NoPermission1469			Error::<T>::NoPermission
1462		);1470		);
14631471
1498		value: u128,1506		value: u128,
1499	) -> DispatchResult {1507	) -> DispatchResult {
1500		ensure!(1508		ensure!(
1501			Self::is_item_owner(sender, collection, item_id)1509			Self::is_item_owner(sender, collection, item_id)?
1502				|| (collection.limits.owner_can_transfer1510				|| (collection.limits.owner_can_transfer
1503					&& Self::is_owner_or_admin_permissions(collection, sender)),1511					&& Self::is_owner_or_admin_permissions(collection, sender)?),
1504			Error::<T>::NoPermission1512			Error::<T>::NoPermission
1505		);1513		);
15061514
1542		let collection_id = collection.id;1550		let collection_id = collection.id;
15431551
1544		// check token limit and account token limit1552		// check token limit and account token limit
1553		collection.consume_sload()?;
1545		let account_items: u32 =1554		let account_items: u32 =
1546			<AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;1555			<AddressTokens<T>>::get(collection_id, recipient.as_sub()).len() as u32;
1547		ensure!(1556		ensure!(
1580			Error::<T>::AccountTokenLimitExceeded1589			Error::<T>::AccountTokenLimitExceeded
1581		);1590		);
15821591
1583		if !Self::is_owner_or_admin_permissions(collection, sender) {1592		if !Self::is_owner_or_admin_permissions(collection, sender)? {
1584			ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);1593			ensure!(collection.mint_mode, Error::<T>::PublicMintingNotAllowed);
1585			Self::check_white_list(collection, owner)?;1594			Self::check_white_list(collection, owner)?;
1586			Self::check_white_list(collection, sender)?;1595			Self::check_white_list(collection, sender)?;
1669		let collection_id = collection.id;1678		let collection_id = collection.id;
16701679
1671		// Does new owner already have an account?1680		// Does new owner already have an account?
1681		collection.consume_sload()?;
1672		let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;1682		let balance: u128 = <FungibleItemList<T>>::get(collection_id, owner.as_sub()).value;
16731683
1674		// Mint1684		// Mint
1675		let item = FungibleItemType {1685		let item = FungibleItemType {
1676			value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,1686			value: balance.checked_add(value).ok_or(Error::<T>::NumOverflow)?,
1677		};1687		};
1688		collection.consume_sstore()?;
1678		<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);1689		<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), item);
16791690
1680		// Update balance1691		// Update balance
1692		collection.consume_sload()?;
1681		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())1693		let new_balance = <Balance<T>>::get(collection_id, owner.as_sub())
1682			.checked_add(value)1694			.checked_add(value)
1683			.ok_or(Error::<T>::NumOverflow)?;1695			.ok_or(Error::<T>::NumOverflow)?;
1696		collection.consume_sstore()?;
1684		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);1697		<Balance<T>>::insert(collection_id, owner.as_sub(), new_balance);
16851698
1699		collection.log(ERC20Events::Transfer {
1700			from: H160::default(),
1701			to: *owner.as_eth(),
1702			value: value.into(),
1703		})?;
1686		Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));1704		Self::deposit_event(RawEvent::ItemCreated(collection_id, 0, owner.clone()));
1687		Ok(())1705		Ok(())
1688	}1706	}
1704		let value = item_owner.fraction;1722		let value = item_owner.fraction;
1705		let owner = item_owner.owner.clone();1723		let owner = item_owner.owner.clone();
17061724
1707		Self::add_token_index(collection_id, current_index, &owner)?;1725		Self::add_token_index(collection, current_index, &owner)?;
17081726
1709		<ItemListIndex>::insert(collection_id, current_index);1727		<ItemListIndex>::insert(collection_id, current_index);
1710		<ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);1728		<ReFungibleItemList<T>>::insert(collection_id, current_index, itemcopy);
1730			.ok_or(Error::<T>::NumOverflow)?;1748			.ok_or(Error::<T>::NumOverflow)?;
17311749
1732		let item_owner = item.owner.clone();1750		let item_owner = item.owner.clone();
1733		Self::add_token_index(collection_id, current_index, &item.owner)?;1751		Self::add_token_index(collection, current_index, &item.owner)?;
17341752
1735		<ItemListIndex>::insert(collection_id, current_index);1753		<ItemListIndex>::insert(collection_id, current_index);
1736		<NftItemList<T>>::insert(collection_id, current_index, item);1754		<NftItemList<T>>::insert(collection_id, current_index, item);
1768			.iter()1786			.iter()
1769			.find(|&i| i.owner == *owner)1787			.find(|&i| i.owner == *owner)
1770			.ok_or(Error::<T>::TokenNotFound)?;1788			.ok_or(Error::<T>::TokenNotFound)?;
1771		Self::remove_token_index(collection_id, item_id, owner)?;1789		Self::remove_token_index(collection, item_id, owner)?;
17721790
1773		// update balance1791		// update balance
1774		let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())1792		let new_balance = <Balance<T>>::get(collection_id, rft_balance.owner.as_sub())
18011819
1802		let item =1820		let item =
1803			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;1821			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;
1804		Self::remove_token_index(collection_id, item_id, &item.owner)?;1822		Self::remove_token_index(collection, item_id, &item.owner)?;
18051823
1806		// update balance1824		// update balance
1807		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())1825		let new_balance = <Balance<T>>::get(collection_id, item.owner.as_sub())
1867	fn is_owner_or_admin_permissions(1885	fn is_owner_or_admin_permissions(
1868		collection: &CollectionHandle<T>,1886		collection: &CollectionHandle<T>,
1869		subject: &T::CrossAccountId,1887		subject: &T::CrossAccountId,
1870	) -> bool {1888	) -> Result<bool, DispatchError> {
1889		collection.consume_sload()?;
1871		*subject.as_sub() == collection.owner1890		Ok(*subject.as_sub() == collection.owner
1872			|| <AdminList<T>>::get(collection.id).contains(subject)1891			|| <AdminList<T>>::get(collection.id).contains(subject))
1873	}1892	}
18741893
1875	fn check_owner_or_admin_permissions(1894	fn check_owner_or_admin_permissions(
1876		collection: &CollectionHandle<T>,1895		collection: &CollectionHandle<T>,
1877		subject: &T::CrossAccountId,1896		subject: &T::CrossAccountId,
1878	) -> DispatchResult {1897	) -> DispatchResult {
1879		ensure!(1898		ensure!(
1880			Self::is_owner_or_admin_permissions(collection, subject),1899			Self::is_owner_or_admin_permissions(collection, subject)?,
1881			Error::<T>::NoPermission1900			Error::<T>::NoPermission
1882		);1901		);
18831902
1884		Ok(())1903		Ok(())
1885	}1904	}
18861905
1887	fn owned_amount(1906	fn owned_amount(
1907		subject: &T::CrossAccountId,
1908		collection: &CollectionHandle<T>,
1909		item_id: TokenId,
1910	) -> Result<Option<u128>, DispatchError> {
1911		collection.consume_sload()?;
1912		Ok(Self::owned_amount_unchecked(subject, collection, item_id))
1913	}
1914
1915	fn owned_amount_unchecked(
1888		subject: &T::CrossAccountId,1916		subject: &T::CrossAccountId,
1889		target_collection: &CollectionHandle<T>,1917		target_collection: &CollectionHandle<T>,
1890		item_id: TokenId,1918		item_id: TokenId,
1911		subject: &T::CrossAccountId,1939		subject: &T::CrossAccountId,
1912		target_collection: &CollectionHandle<T>,1940		target_collection: &CollectionHandle<T>,
1913		item_id: TokenId,1941		item_id: TokenId,
1914	) -> bool {1942	) -> Result<bool, DispatchError> {
1915		match target_collection.mode {1943		Ok(match target_collection.mode {
1916			CollectionMode::Fungible(_) => true,1944			CollectionMode::Fungible(_) => true,
1917			_ => Self::owned_amount(subject, target_collection, item_id).is_some(),1945			_ => Self::owned_amount(subject, target_collection, item_id)?.is_some(),
1918		}1946		})
1919	}1947	}
19201948
1921	fn check_white_list(1949	fn check_white_list(
1922		collection: &CollectionHandle<T>,1950		collection: &CollectionHandle<T>,
1923		address: &T::CrossAccountId,1951		address: &T::CrossAccountId,
1924	) -> DispatchResult {1952	) -> DispatchResult {
1925		let collection_id = collection.id;1953		collection.consume_sload()?;
1926
1927		let mes = Error::<T>::AddresNotInWhiteList;
1928		ensure!(1954		ensure!(
1929			<WhiteList<T>>::contains_key(collection_id, address.as_sub()),1955			<WhiteList<T>>::contains_key(collection.id, address.as_sub()),
1930			mes1956			Error::<T>::AddresNotInWhiteList,
1931		);1957		);
1932
1933		Ok(())1958		Ok(())
1958	) -> DispatchResult {1983	) -> DispatchResult {
1959		let collection_id = collection.id;1984		let collection_id = collection.id;
19601985
1986		collection.consume_sload()?;
1987		collection.consume_sload()?;
1988		let mut recipient_balance = <FungibleItemList<T>>::get(collection_id, recipient.as_sub());
1961		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());1989		let mut balance = <FungibleItemList<T>>::get(collection_id, owner.as_sub());
1990
1991		recipient_balance.value = recipient_balance
1992			.value
1993			.checked_add(value)
1994			.ok_or(Error::<T>::NumOverflow)?;
1962		ensure!(balance.value >= value, Error::<T>::TokenValueTooLow);1995		balance.value = balance
19631996			.value
1964		// Send balance to recipient (updates balanceOf of recipient)1997			.checked_sub(value)
1998			.ok_or(Error::<T>::TokenValueTooLow)?;
1999
2000		// update balanceOf
1965		Self::add_fungible_item(collection, recipient, value)?;2001		collection.consume_sstore()?;
19662002		collection.consume_sstore()?;
1967		// update balanceOf of sender2003		if balance.value != 0 {
1968		<Balance<T>>::insert(collection_id, owner.as_sub(), balance.value - value);2004			<Balance<T>>::insert(collection_id, owner.as_sub(), balance.value);
2005		} else {
2006			<Balance<T>>::remove(collection_id, owner.as_sub());
2007		}
2008		<Balance<T>>::insert(collection_id, recipient.as_sub(), recipient_balance.value);
19692009
1970		// Reduce or remove sender2010		// Reduce or remove sender
2011		collection.consume_sstore()?;
2012		collection.consume_sstore()?;
1971		if balance.value == value {2013		if balance.value != 0 {
1972			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());2014			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);
1973		} else {2015		} else {
1974			balance.value -= value;
1975			<FungibleItemList<T>>::insert(collection_id, owner.as_sub(), balance);2016			<FungibleItemList<T>>::remove(collection_id, owner.as_sub());
1976		}2017		}
2018		<FungibleItemList<T>>::insert(collection_id, recipient.as_sub(), recipient_balance);
19772019
1978		collection.log(ERC20Events::Transfer {2020		collection.log(ERC20Events::Transfer {
1979			from: *owner.as_eth(),2021			from: *owner.as_eth(),
1999		new_owner: T::CrossAccountId,2041		new_owner: T::CrossAccountId,
2000	) -> DispatchResult {2042	) -> DispatchResult {
2001		let collection_id = collection.id;2043		let collection_id = collection.id;
2044		collection.consume_sload()?;
2002		let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)2045		let full_item = <ReFungibleItemList<T>>::get(collection_id, item_id)
2003			.ok_or(Error::<T>::TokenNotFound)?;2046			.ok_or(Error::<T>::TokenNotFound)?;
20042047
20112054
2012		ensure!(amount >= value, Error::<T>::TokenValueTooLow);2055		ensure!(amount >= value, Error::<T>::TokenValueTooLow);
20132056
2057		collection.consume_sload()?;
2014		// update balance2058		// update balance
2015		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2059		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())
2016			.checked_sub(value)2060			.checked_sub(value)
2017			.ok_or(Error::<T>::NumOverflow)?;2061			.ok_or(Error::<T>::NumOverflow)?;
2062		collection.consume_sstore()?;
2018		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);2063		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);
20192064
2065		collection.consume_sload()?;
2020		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2066		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())
2021			.checked_add(value)2067			.checked_add(value)
2022			.ok_or(Error::<T>::NumOverflow)?;2068			.ok_or(Error::<T>::NumOverflow)?;
2069		collection.consume_sstore()?;
2023		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);2070		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);
20242071
2025		let old_owner = item.owner.clone();2072		let old_owner = item.owner.clone();
2036				.find(|i| i.owner == owner)2083				.find(|i| i.owner == owner)
2037				.expect("old owner does present in refungible")2084				.expect("old owner does present in refungible")
2038				.owner = new_owner.clone();2085				.owner = new_owner.clone();
2086			collection.consume_sstore()?;
2039			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2087			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);
20402088
2041			// update index collection2089			// update index collection
2042			Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2090			Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;
2043		} else {2091		} else {
2044			new_full_item2092			new_full_item
2045				.owner2093				.owner
2063					owner: new_owner.clone(),2111					owner: new_owner.clone(),
2064					fraction: value,2112					fraction: value,
2065				});2113				});
2066				Self::add_token_index(collection_id, item_id, &new_owner)?;2114				Self::add_token_index(collection, item_id, &new_owner)?;
2067			}2115			}
20682116
2117			collection.consume_sstore()?;
2069			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);2118			<ReFungibleItemList<T>>::insert(collection_id, item_id, new_full_item);
2070		}2119		}
20712120
2087		new_owner: T::CrossAccountId,2136		new_owner: T::CrossAccountId,
2088	) -> DispatchResult {2137	) -> DispatchResult {
2089		let collection_id = collection.id;2138		let collection_id = collection.id;
2139		collection.consume_sload()?;
2090		let mut item =2140		let mut item =
2091			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;2141			<NftItemList<T>>::get(collection_id, item_id).ok_or(Error::<T>::TokenNotFound)?;
20922142
2093		ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);2143		ensure!(sender == item.owner, Error::<T>::MustBeTokenOwner);
20942144
2145		collection.consume_sload()?;
2095		// update balance2146		// update balance
2096		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())2147		let balance_old_owner = <Balance<T>>::get(collection_id, item.owner.as_sub())
2097			.checked_sub(1)2148			.checked_sub(1)
2098			.ok_or(Error::<T>::NumOverflow)?;2149			.ok_or(Error::<T>::NumOverflow)?;
2150		collection.consume_sstore()?;
2099		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);2151		<Balance<T>>::insert(collection_id, item.owner.as_sub(), balance_old_owner);
21002152
2153		collection.consume_sload()?;
2101		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())2154		let balance_new_owner = <Balance<T>>::get(collection_id, new_owner.as_sub())
2102			.checked_add(1)2155			.checked_add(1)
2103			.ok_or(Error::<T>::NumOverflow)?;2156			.ok_or(Error::<T>::NumOverflow)?;
2157		collection.consume_sstore()?;
2104		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);2158		<Balance<T>>::insert(collection_id, new_owner.as_sub(), balance_new_owner);
21052159
2106		// change owner2160		// change owner
2107		let old_owner = item.owner.clone();2161		let old_owner = item.owner.clone();
2108		item.owner = new_owner.clone();2162		item.owner = new_owner.clone();
2163		collection.consume_sstore()?;
2109		<NftItemList<T>>::insert(collection_id, item_id, item);2164		<NftItemList<T>>::insert(collection_id, item_id, item);
21102165
2111		// update index collection2166		// update index collection
2112		Self::move_token_index(collection_id, item_id, &old_owner, &new_owner)?;2167		Self::move_token_index(collection, item_id, &old_owner, &new_owner)?;
21132168
2114		collection.log(ERC721Events::Transfer {2169		collection.log(ERC721Events::Transfer {
2115			from: *sender.as_eth(),2170			from: *sender.as_eth(),
2190		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();2245		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();
21912246
2192		Self::add_token_index(collection_id, current_index, &item.owner).unwrap();2247		Self::add_token_index(
2248			&CollectionHandle::get(collection_id).unwrap(),
2249			current_index,
2250			&item.owner,
2251		)
2252		.unwrap();
21932253
2209		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();2269		let current_index = <ItemListIndex>::get(collection_id).checked_add(1).unwrap();
22102270
2211		Self::add_token_index(collection_id, current_index, owner).unwrap();2271		Self::add_token_index(
2272			&CollectionHandle::get(collection_id).unwrap(),
2273			current_index,
2274			owner,
2275		)
2276		.unwrap();
22122277
2230		let owner = item.owner.first().unwrap().owner.clone();2295		let owner = item.owner.first().unwrap().owner.clone();
22312296
2232		Self::add_token_index(collection_id, current_index, &owner).unwrap();2297		Self::add_token_index(
2298			&CollectionHandle::get(collection_id).unwrap(),
2299			current_index,
2300			&owner,
2301		)
2302		.unwrap();
22332303
2241	}2311	}
22422312
2243	fn add_token_index(2313	fn add_token_index(
2244		collection_id: CollectionId,2314		collection: &CollectionHandle<T>,
2245		item_index: TokenId,2315		item_index: TokenId,
2246		owner: &T::CrossAccountId,2316		owner: &T::CrossAccountId,
2247	) -> DispatchResult {2317	) -> DispatchResult {
2248		// add to account limit2318		// add to account limit
2319		collection.consume_sload()?;
2249		if <AccountItemCount<T>>::contains_key(owner.as_sub()) {2320		if <AccountItemCount<T>>::contains_key(owner.as_sub()) {
2250			// bound Owned tokens by a single address2321			// bound Owned tokens by a single address
2322			collection.consume_sload()?;
2251			let count = <AccountItemCount<T>>::get(owner.as_sub());2323			let count = <AccountItemCount<T>>::get(owner.as_sub());
2252			ensure!(2324			ensure!(
2253				count < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,2325				count < ACCOUNT_TOKEN_OWNERSHIP_LIMIT,
2254				Error::<T>::AddressOwnershipLimitExceeded2326				Error::<T>::AddressOwnershipLimitExceeded
2255			);2327			);
22562328
2329			collection.consume_sstore()?;
2257			<AccountItemCount<T>>::insert(2330			<AccountItemCount<T>>::insert(
2258				owner.as_sub(),2331				owner.as_sub(),
2259				count.checked_add(1).ok_or(Error::<T>::NumOverflow)?,2332				count.checked_add(1).ok_or(Error::<T>::NumOverflow)?,
2260			);2333			);
2261		} else {2334		} else {
2335			collection.consume_sstore()?;
2262			<AccountItemCount<T>>::insert(owner.as_sub(), 1);2336			<AccountItemCount<T>>::insert(owner.as_sub(), 1);
2263		}2337		}
22642338
2339		collection.consume_sload()?;
2265		let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2340		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());
2266		if list_exists {2341		if list_exists {
2342			collection.consume_sload()?;
2267			let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2343			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());
2268			let item_contains = list.contains(&item_index.clone());2344			let item_contains = list.contains(&item_index.clone());
22692345
2270			if !item_contains {2346			if !item_contains {
2271				list.push(item_index);2347				list.push(item_index);
2272			}2348			}
22732349
2350			collection.consume_sstore()?;
2274			<AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2351			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);
2275		} else {2352		} else {
2276			let itm = vec![item_index];2353			let itm = vec![item_index];
2354			collection.consume_sstore()?;
2277			<AddressTokens<T>>::insert(collection_id, owner.as_sub(), itm);2355			<AddressTokens<T>>::insert(collection.id, owner.as_sub(), itm);
2278		}2356		}
22792357
2280		Ok(())2358		Ok(())
2281	}2359	}
22822360
2283	fn remove_token_index(2361	fn remove_token_index(
2284		collection_id: CollectionId,2362		collection: &CollectionHandle<T>,
2285		item_index: TokenId,2363		item_index: TokenId,
2286		owner: &T::CrossAccountId,2364		owner: &T::CrossAccountId,
2287	) -> DispatchResult {2365	) -> DispatchResult {
2288		// update counter2366		// update counter
2367		collection.consume_sload()?;
2368		collection.consume_sstore()?;
2289		<AccountItemCount<T>>::insert(2369		<AccountItemCount<T>>::insert(
2290			owner.as_sub(),2370			owner.as_sub(),
2291			<AccountItemCount<T>>::get(owner.as_sub())2371			<AccountItemCount<T>>::get(owner.as_sub())
2292				.checked_sub(1)2372				.checked_sub(1)
2293				.ok_or(Error::<T>::NumOverflow)?,2373				.ok_or(Error::<T>::NumOverflow)?,
2294		);2374		);
22952375
2376		collection.consume_sload()?;
2296		let list_exists = <AddressTokens<T>>::contains_key(collection_id, owner.as_sub());2377		let list_exists = <AddressTokens<T>>::contains_key(collection.id, owner.as_sub());
2297		if list_exists {2378		if list_exists {
2379			collection.consume_sload()?;
2298			let mut list = <AddressTokens<T>>::get(collection_id, owner.as_sub());2380			let mut list = <AddressTokens<T>>::get(collection.id, owner.as_sub());
2299			let item_contains = list.contains(&item_index.clone());2381			let item_contains = list.contains(&item_index.clone());
23002382
2301			if item_contains {2383			if item_contains {
2302				list.retain(|&item| item != item_index);2384				list.retain(|&item| item != item_index);
2385				collection.consume_sstore()?;
2303				<AddressTokens<T>>::insert(collection_id, owner.as_sub(), list);2386				<AddressTokens<T>>::insert(collection.id, owner.as_sub(), list);
2304			}2387			}
2305		}2388		}
23062389
2307		Ok(())2390		Ok(())
2308	}2391	}
23092392
2310	fn move_token_index(2393	fn move_token_index(
2311		collection_id: CollectionId,2394		collection: &CollectionHandle<T>,
2312		item_index: TokenId,2395		item_index: TokenId,
2313		old_owner: &T::CrossAccountId,2396		old_owner: &T::CrossAccountId,
2314		new_owner: &T::CrossAccountId,2397		new_owner: &T::CrossAccountId,
2315	) -> DispatchResult {2398	) -> DispatchResult {
2316		Self::remove_token_index(collection_id, item_index, old_owner)?;2399		Self::remove_token_index(collection, item_index, old_owner)?;
2317		Self::add_token_index(collection_id, item_index, new_owner)?;2400		Self::add_token_index(collection, item_index, new_owner)?;
23182401
2319		Ok(())2402		Ok(())
2320	}2403	}

4  "description": "Substrate Nft tests",4  "description": "Substrate Nft tests",
5  "main": "",5  "main": "",
6  "devDependencies": {6  "devDependencies": {
7    "@polkadot/dev": "0.62.43",7    "@polkadot/dev": "0.62.60",
8    "@polkadot/ts": "0.3.89",8    "@polkadot/ts": "0.4.4",
9    "@polkadot/typegen": "5.0.1",9    "@polkadot/typegen": "5.5.1",
10    "@types/chai": "^4.2.17",10    "@types/chai": "^4.2.17",
11    "@types/chai-as-promised": "^7.1.3",11    "@types/chai-as-promised": "^7.1.3",
12    "@types/mocha": "^8.2.2",12    "@types/mocha": "^8.2.2",
66  "license": "SEE LICENSE IN ../LICENSE",66  "license": "SEE LICENSE IN ../LICENSE",
67  "homepage": "",67  "homepage": "",
68  "dependencies": {68  "dependencies": {
69    "@polkadot/api": "5.0.1",69    "@polkadot/api": "5.5.1",
70    "@polkadot/api-contract": "5.0.1",70    "@polkadot/api-contract": "5.5.1",
71    "@polkadot/util-crypto": "^7.2.1",
71    "bignumber.js": "^9.0.1",72    "bignumber.js": "^9.0.1",
72    "chai-as-promised": "^7.1.1",73    "chai-as-promised": "^7.1.1",
73    "solc": "^0.8.6",74    "solc": "^0.8.6",

4//4//
55
6import privateKey from '../substrate/privateKey';6import privateKey from '../substrate/privateKey';
7import { approveExpectSuccess, createCollectionExpectSuccess, createFungibleItemExpectSuccess, transferExpectSuccess, transferFromExpectSuccess } from '../util/helpers';7import { approveExpectSuccess, createCollectionExpectSuccess, createFungibleItemExpectSuccess, transferExpectSuccess, transferFromExpectSuccess, UNIQUE } from '../util/helpers';
8import { collectionIdToAddress, createEthAccount, createEthAccountWithBalance, GAS_ARGS, itWeb3, normalizeEvents, recordEvents, subToEth, transferBalanceToEth } from './util/helpers';8import { collectionIdToAddress, createEthAccount, createEthAccountWithBalance, GAS_ARGS, itWeb3, normalizeEvents, recordEthFee, recordEvents, subToEth, transferBalanceToEth } from './util/helpers';
9import fungibleAbi from './fungibleAbi.json';9import fungibleAbi from './fungibleAbi.json';
10import { expect } from 'chai';10import { expect } from 'chai';
1111
192  });192  });
193});193});
194
195describe('Fungible: Fees', () => {
196  itWeb3('approve() call fee is less than 0.2UNQ', async ({ web3, api }) => {
197    const collection = await createCollectionExpectSuccess({
198      mode: { type: 'Fungible', decimalPoints: 0 },
199    });
200    const alice = privateKey('//Alice');
201
202    const owner = await createEthAccountWithBalance(api, web3);
203    const spender = createEthAccount(web3);
204
205    await createFungibleItemExpectSuccess(alice, collection, { Value: 200n }, { ethereum: owner });
206
207    const address = collectionIdToAddress(collection);
208    const contract = new web3.eth.Contract(fungibleAbi as any, address, { from: owner, ...GAS_ARGS });
209
210    const cost = await recordEthFee(api, owner, () => contract.methods.approve(spender, 100).send({ from: owner }));
211    expect(cost < BigInt(0.2 * Number(UNIQUE)));
212  });
213
214  itWeb3('transferFrom() call fee is less than 0.2UNQ', async ({ web3, api }) => {
215    const collection = await createCollectionExpectSuccess({
216      mode: {type: 'Fungible', decimalPoints: 0},
217    });
218    const alice = privateKey('//Alice');
219  
220    const owner = await createEthAccountWithBalance(api, web3);
221    const spender = await createEthAccountWithBalance(api, web3);
222
223    await createFungibleItemExpectSuccess(alice, collection, { Value: 200n }, { ethereum: owner });
224
225    const address = collectionIdToAddress(collection);
226    const contract = new web3.eth.Contract(fungibleAbi as any, address, { from: owner, ...GAS_ARGS });
227
228    await contract.methods.approve(spender, 100).send({ from: owner });
229
230    const cost = await recordEthFee(api, spender, () => contract.methods.transferFrom(owner, spender, 100).send({ from: spender }));
231    expect(cost < BigInt(0.2 * Number(UNIQUE)));
232  });
233
234  itWeb3('transfer() call fee is less than 0.2UNQ', async ({ web3, api }) => {
235    const collection = await createCollectionExpectSuccess({
236      mode: { type: 'Fungible', decimalPoints: 0 },
237    });
238    const alice = privateKey('//Alice');
239
240    const owner = await createEthAccountWithBalance(api, web3);
241    const receiver = createEthAccount(web3);
242
243    await createFungibleItemExpectSuccess(alice, collection, { Value: 200n }, { ethereum: owner });
244
245    const address = collectionIdToAddress(collection);
246    const contract = new web3.eth.Contract(fungibleAbi as any, address, { from: owner, ...GAS_ARGS });
247
248    const cost = await recordEthFee(api, owner, () => contract.methods.transfer(receiver, 100).send({ from: owner }));
249    expect(cost < BigInt(0.2 * Number(UNIQUE)));
250  });
251});
194252
195describe('Fungible: Substrate calls', () => {253describe('Fungible: Substrate calls', () => {
196  itWeb3('Events emitted for approve()', async ({ web3 }) => {254  itWeb3('Events emitted for approve()', async ({ web3 }) => {