git.delta.rocks / unique-network / refs/commits / 507b779dd4fb

903903
904[[package]]904[[package]]
905name = "clap"905name = "clap"
906version = "4.0.30"906version = "4.0.32"
907source = "registry+https://github.com/rust-lang/crates.io-index"907source = "registry+https://github.com/rust-lang/crates.io-index"
908checksum = "656ad1e55e23d287773f7d8192c300dc715c3eeded93b3da651d11c42cfd74d2"908checksum = "a7db700bc935f9e43e88d00b0850dae18a63773cfbec6d8e070fccf7fef89a39"
909dependencies = [909dependencies = [
910 "bitflags",910 "bitflags",
911 "clap_derive",911 "clap_derive",
1300[[package]]1300[[package]]
1301name = "cumulus-client-cli"1301name = "cumulus-client-cli"
1302version = "0.1.0"1302version = "0.1.0"
1303source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#a4e825c9500acab6cc3deccffea7b01350f12ed1"1303source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#afe528af891f464b318293f183f6d3eefbc979b0"
1304dependencies = [1304dependencies = [
1305 "clap",1305 "clap",
1306 "parity-scale-codec 3.2.1",1306 "parity-scale-codec 3.2.1",
1315[[package]]1315[[package]]
1316name = "cumulus-client-collator"1316name = "cumulus-client-collator"
1317version = "0.1.0"1317version = "0.1.0"
1318source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#a4e825c9500acab6cc3deccffea7b01350f12ed1"1318source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#afe528af891f464b318293f183f6d3eefbc979b0"
1319dependencies = [1319dependencies = [
1320 "cumulus-client-consensus-common",1320 "cumulus-client-consensus-common",
1321 "cumulus-client-network",1321 "cumulus-client-network",
1338[[package]]1338[[package]]
1339name = "cumulus-client-consensus-aura"1339name = "cumulus-client-consensus-aura"
1340version = "0.1.0"1340version = "0.1.0"
1341source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#a4e825c9500acab6cc3deccffea7b01350f12ed1"1341source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#afe528af891f464b318293f183f6d3eefbc979b0"
1342dependencies = [1342dependencies = [
1343 "async-trait",1343 "async-trait",
1344 "cumulus-client-consensus-common",1344 "cumulus-client-consensus-common",
1367[[package]]1367[[package]]
1368name = "cumulus-client-consensus-common"1368name = "cumulus-client-consensus-common"
1369version = "0.1.0"1369version = "0.1.0"
1370source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#a4e825c9500acab6cc3deccffea7b01350f12ed1"1370source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#afe528af891f464b318293f183f6d3eefbc979b0"
1371dependencies = [1371dependencies = [
1372 "async-trait",1372 "async-trait",
1373 "cumulus-client-pov-recovery",1373 "cumulus-client-pov-recovery",
1390[[package]]1390[[package]]
1391name = "cumulus-client-network"1391name = "cumulus-client-network"
1392version = "0.1.0"1392version = "0.1.0"
1393source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#a4e825c9500acab6cc3deccffea7b01350f12ed1"1393source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#afe528af891f464b318293f183f6d3eefbc979b0"
1394dependencies = [1394dependencies = [
1395 "async-trait",1395 "async-trait",
1396 "cumulus-relay-chain-interface",1396 "cumulus-relay-chain-interface",
1413[[package]]1413[[package]]
1414name = "cumulus-client-pov-recovery"1414name = "cumulus-client-pov-recovery"
1415version = "0.1.0"1415version = "0.1.0"
1416source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#a4e825c9500acab6cc3deccffea7b01350f12ed1"1416source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#afe528af891f464b318293f183f6d3eefbc979b0"
1417dependencies = [1417dependencies = [
1418 "cumulus-primitives-core",1418 "cumulus-primitives-core",
1419 "cumulus-relay-chain-interface",1419 "cumulus-relay-chain-interface",
1436[[package]]1436[[package]]
1437name = "cumulus-client-service"1437name = "cumulus-client-service"
1438version = "0.1.0"1438version = "0.1.0"
1439source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#a4e825c9500acab6cc3deccffea7b01350f12ed1"1439source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#afe528af891f464b318293f183f6d3eefbc979b0"
1440dependencies = [1440dependencies = [
1441 "cumulus-client-cli",1441 "cumulus-client-cli",
1442 "cumulus-client-collator",1442 "cumulus-client-collator",
1464[[package]]1464[[package]]
1465name = "cumulus-pallet-aura-ext"1465name = "cumulus-pallet-aura-ext"
1466version = "0.1.0"1466version = "0.1.0"
1467source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#a4e825c9500acab6cc3deccffea7b01350f12ed1"1467source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#afe528af891f464b318293f183f6d3eefbc979b0"
1468dependencies = [1468dependencies = [
1469 "frame-support",1469 "frame-support",
1470 "frame-system",1470 "frame-system",
1480[[package]]1480[[package]]
1481name = "cumulus-pallet-dmp-queue"1481name = "cumulus-pallet-dmp-queue"
1482version = "0.1.0"1482version = "0.1.0"
1483source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#a4e825c9500acab6cc3deccffea7b01350f12ed1"1483source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#afe528af891f464b318293f183f6d3eefbc979b0"
1484dependencies = [1484dependencies = [
1485 "cumulus-primitives-core",1485 "cumulus-primitives-core",
1486 "frame-support",1486 "frame-support",
1497[[package]]1497[[package]]
1498name = "cumulus-pallet-parachain-system"1498name = "cumulus-pallet-parachain-system"
1499version = "0.1.0"1499version = "0.1.0"
1500source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#a4e825c9500acab6cc3deccffea7b01350f12ed1"1500source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#afe528af891f464b318293f183f6d3eefbc979b0"
1501dependencies = [1501dependencies = [
1502 "bytes",1502 "bytes",
1503 "cumulus-pallet-parachain-system-proc-macro",1503 "cumulus-pallet-parachain-system-proc-macro",
1525[[package]]1525[[package]]
1526name = "cumulus-pallet-parachain-system-proc-macro"1526name = "cumulus-pallet-parachain-system-proc-macro"
1527version = "0.1.0"1527version = "0.1.0"
1528source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#a4e825c9500acab6cc3deccffea7b01350f12ed1"1528source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#afe528af891f464b318293f183f6d3eefbc979b0"
1529dependencies = [1529dependencies = [
1530 "proc-macro-crate",1530 "proc-macro-crate",
1531 "proc-macro2",1531 "proc-macro2",
1536[[package]]1536[[package]]
1537name = "cumulus-pallet-xcm"1537name = "cumulus-pallet-xcm"
1538version = "0.1.0"1538version = "0.1.0"
1539source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#a4e825c9500acab6cc3deccffea7b01350f12ed1"1539source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#afe528af891f464b318293f183f6d3eefbc979b0"
1540dependencies = [1540dependencies = [
1541 "cumulus-primitives-core",1541 "cumulus-primitives-core",
1542 "frame-support",1542 "frame-support",
1552[[package]]1552[[package]]
1553name = "cumulus-pallet-xcmp-queue"1553name = "cumulus-pallet-xcmp-queue"
1554version = "0.1.0"1554version = "0.1.0"
1555source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#a4e825c9500acab6cc3deccffea7b01350f12ed1"1555source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#afe528af891f464b318293f183f6d3eefbc979b0"
1556dependencies = [1556dependencies = [
1557 "cumulus-primitives-core",1557 "cumulus-primitives-core",
1558 "frame-support",1558 "frame-support",
1570[[package]]1570[[package]]
1571name = "cumulus-primitives-core"1571name = "cumulus-primitives-core"
1572version = "0.1.0"1572version = "0.1.0"
1573source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#a4e825c9500acab6cc3deccffea7b01350f12ed1"1573source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#afe528af891f464b318293f183f6d3eefbc979b0"
1574dependencies = [1574dependencies = [
1575 "parity-scale-codec 3.2.1",1575 "parity-scale-codec 3.2.1",
1576 "polkadot-core-primitives",1576 "polkadot-core-primitives",
1585[[package]]1585[[package]]
1586name = "cumulus-primitives-parachain-inherent"1586name = "cumulus-primitives-parachain-inherent"
1587version = "0.1.0"1587version = "0.1.0"
1588source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#a4e825c9500acab6cc3deccffea7b01350f12ed1"1588source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#afe528af891f464b318293f183f6d3eefbc979b0"
1589dependencies = [1589dependencies = [
1590 "async-trait",1590 "async-trait",
1591 "cumulus-primitives-core",1591 "cumulus-primitives-core",
1608[[package]]1608[[package]]
1609name = "cumulus-primitives-timestamp"1609name = "cumulus-primitives-timestamp"
1610version = "0.1.0"1610version = "0.1.0"
1611source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#a4e825c9500acab6cc3deccffea7b01350f12ed1"1611source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#afe528af891f464b318293f183f6d3eefbc979b0"
1612dependencies = [1612dependencies = [
1613 "cumulus-primitives-core",1613 "cumulus-primitives-core",
1614 "futures 0.3.25",1614 "futures 0.3.25",
1621[[package]]1621[[package]]
1622name = "cumulus-primitives-utility"1622name = "cumulus-primitives-utility"
1623version = "0.1.0"1623version = "0.1.0"
1624source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#a4e825c9500acab6cc3deccffea7b01350f12ed1"1624source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#afe528af891f464b318293f183f6d3eefbc979b0"
1625dependencies = [1625dependencies = [
1626 "cumulus-primitives-core",1626 "cumulus-primitives-core",
1627 "frame-support",1627 "frame-support",
1637[[package]]1637[[package]]
1638name = "cumulus-relay-chain-inprocess-interface"1638name = "cumulus-relay-chain-inprocess-interface"
1639version = "0.1.0"1639version = "0.1.0"
1640source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#a4e825c9500acab6cc3deccffea7b01350f12ed1"1640source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#afe528af891f464b318293f183f6d3eefbc979b0"
1641dependencies = [1641dependencies = [
1642 "async-trait",1642 "async-trait",
1643 "cumulus-primitives-core",1643 "cumulus-primitives-core",
1662[[package]]1662[[package]]
1663name = "cumulus-relay-chain-interface"1663name = "cumulus-relay-chain-interface"
1664version = "0.1.0"1664version = "0.1.0"
1665source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#a4e825c9500acab6cc3deccffea7b01350f12ed1"1665source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#afe528af891f464b318293f183f6d3eefbc979b0"
1666dependencies = [1666dependencies = [
1667 "async-trait",1667 "async-trait",
1668 "cumulus-primitives-core",1668 "cumulus-primitives-core",
1682[[package]]1682[[package]]
1683name = "cumulus-relay-chain-minimal-node"1683name = "cumulus-relay-chain-minimal-node"
1684version = "0.1.0"1684version = "0.1.0"
1685source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#a4e825c9500acab6cc3deccffea7b01350f12ed1"1685source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#afe528af891f464b318293f183f6d3eefbc979b0"
1686dependencies = [1686dependencies = [
1687 "array-bytes 6.0.0",1687 "array-bytes 6.0.0",
1688 "async-trait",1688 "async-trait",
1722[[package]]1722[[package]]
1723name = "cumulus-relay-chain-rpc-interface"1723name = "cumulus-relay-chain-rpc-interface"
1724version = "0.1.0"1724version = "0.1.0"
1725source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#a4e825c9500acab6cc3deccffea7b01350f12ed1"1725source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#afe528af891f464b318293f183f6d3eefbc979b0"
1726dependencies = [1726dependencies = [
1727 "async-trait",1727 "async-trait",
1728 "cumulus-primitives-core",1728 "cumulus-primitives-core",
1751[[package]]1751[[package]]
1752name = "cumulus-test-relay-sproof-builder"1752name = "cumulus-test-relay-sproof-builder"
1753version = "0.1.0"1753version = "0.1.0"
1754source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#a4e825c9500acab6cc3deccffea7b01350f12ed1"1754source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#afe528af891f464b318293f183f6d3eefbc979b0"
1755dependencies = [1755dependencies = [
1756 "cumulus-primitives-core",1756 "cumulus-primitives-core",
1757 "parity-scale-codec 3.2.1",1757 "parity-scale-codec 3.2.1",
6982[[package]]6982[[package]]
6983name = "parachain-info"6983name = "parachain-info"
6984version = "0.1.0"6984version = "0.1.0"
6985source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#a4e825c9500acab6cc3deccffea7b01350f12ed1"6985source = "git+https://github.com/paritytech/cumulus?branch=polkadot-v0.9.36#afe528af891f464b318293f183f6d3eefbc979b0"
6986dependencies = [6986dependencies = [
6987 "cumulus-primitives-core",6987 "cumulus-primitives-core",
6988 "frame-support",6988 "frame-support",

125/// Ethereum representation of Optional value with CrossAddress.125/// Ethereum representation of Optional value with CrossAddress.
126#[derive(Debug, Default, AbiCoder)]126#[derive(Debug, Default, AbiCoder)]
127pub struct OptionCrossAddress {127pub struct OptionCrossAddress {
128	/// Is address set
128	pub status: bool,129	pub status: bool,
130	/// Address value
129	pub value: CrossAddress,131	pub value: CrossAddress,
130}132}
131133

23	execution::Result,23	execution::Result,
24	generate_stubgen, solidity_interface,24	generate_stubgen, solidity_interface,
25	types::*,25	types::*,
26	ToLog, AbiCoder,26	ToLog,
27};27};
28use pallet_common::eth;28use pallet_common::eth;
29use pallet_evm::{29use pallet_evm::{

binary blob — no preview

283283
284/// Ethereum representation of Optional value with CrossAddress.284/// Ethereum representation of Optional value with CrossAddress.
285struct OptionCrossAddress {285struct OptionCrossAddress {
286	/// TODO: field description
286	bool status;287	bool status;
288	/// TODO: field description
287	CrossAddress value;289	CrossAddress value;
288}290}
289291

43	TotalSupply, weights::WeightInfo,43	TotalSupply, weights::WeightInfo,
44};44};
4545
46/// Refungible token handle contains information about token's collection and id
47///
48/// RefungibleTokenHandle doesn't check token's existance upon creation
46pub struct RefungibleTokenHandle<T: Config>(pub RefungibleHandle<T>, pub TokenId);49pub struct RefungibleTokenHandle<T: Config>(pub RefungibleHandle<T>, pub TokenId);
4750
48#[solidity_interface(name = ERC1633)]51#[solidity_interface(name = ERC1633)]

32	Config as FungibleConfig,32	Config as FungibleConfig,
33	erc::{UniqueFungibleCall, ERC20Call},33	erc::{UniqueFungibleCall, ERC20Call},
34};34};
35use pallet_refungible::Config as RefungibleConfig;35use pallet_refungible::{
36	Config as RefungibleConfig,
37	erc::UniqueRefungibleCall,
38	erc_token::{RefungibleTokenHandle, UniqueRefungibleTokenCall},
39	RefungibleHandle,
40};
36use pallet_unique::Config as UniqueConfig;41use pallet_unique::Config as UniqueConfig;
37use sp_std::prelude::*;42use sp_std::prelude::*;
38use up_data_structs::{CollectionMode, CreateItemData, CreateNftData, TokenId};43use up_data_structs::{
44	CollectionMode, CreateItemData, CreateNftData, mapping::TokenAddressMapping, TokenId,
45};
39use up_sponsorship::SponsorshipHandler;46use up_sponsorship::SponsorshipHandler;
40
41use crate::{Runtime, runtime_common::sponsoring::*};47use crate::{Runtime, runtime_common::sponsoring::*};
48
49mod refungible;
4250
43pub type EvmSponsorshipHandler = (51pub type EvmSponsorshipHandler = (
44	UniqueEthSponsorshipHandler<Runtime>,52	UniqueEthSponsorshipHandler<Runtime>,
53		who: &T::CrossAccountId,61		who: &T::CrossAccountId,
54		call_context: &CallContext,62		call_context: &CallContext,
55	) -> Option<T::CrossAccountId> {63	) -> Option<T::CrossAccountId> {
56		let collection_id = map_eth_to_id(&call_context.contract_address)?;64		if let Some(collection_id) = map_eth_to_id(&call_context.contract_address) {
57		let collection = <CollectionHandle<T>>::new(collection_id)?;65			let collection = <CollectionHandle<T>>::new(collection_id)?;
58		let sponsor = collection.sponsorship.sponsor()?.clone();66			let sponsor = collection.sponsorship.sponsor()?.clone();
59		let (method_id, mut reader) = AbiReader::new_call(&call_context.input).ok()?;67			let (method_id, mut reader) = AbiReader::new_call(&call_context.input).ok()?;
106					_ => None,116						_ => None,
107				}117					}
108			}118				}
119				CollectionMode::ReFungible => {
120					let call = <UniqueRefungibleCall<T>>::parse(method_id, &mut reader).ok()??;
121					refungible::call_sponsor(call, collection, who).map(|()| sponsor)
122				}
109			CollectionMode::Fungible(_) => {123				CollectionMode::Fungible(_) => {
110				let call = <UniqueFungibleCall<T>>::parse(method_id, &mut reader).ok()??;124					let call = <UniqueFungibleCall<T>>::parse(method_id, &mut reader).ok()??;
111				#[allow(clippy::single_match)]
112				match call {125					match call {
113					UniqueFungibleCall::ERC20(ERC20Call::Transfer { .. }) => {126						UniqueFungibleCall::ERC20(ERC20Call::Transfer { .. }) => {
114						withdraw_transfer::<T>(&collection, who, &TokenId::default())127							withdraw_transfer::<T>(&collection, who, &TokenId::default())
126					_ => None,139						_ => None,
127				}140					}
128			}141				}
129			_ => None,
130		}?))142			}?))
143		} else {
144			let (collection_id, token_id) =
145				T::EvmTokenAddressMapping::address_to_token(&call_context.contract_address)?;
146			let collection = <CollectionHandle<T>>::new(collection_id)?;
147			if collection.mode != CollectionMode::ReFungible {
148				return None;
149			}
150			let sponsor = collection.sponsorship.sponsor()?.clone();
151			let rft_collection = RefungibleHandle::cast(collection);
152			// Token existance isn't checked at this point and should be checked in `withdraw` method.
153			let token = RefungibleTokenHandle(rft_collection, token_id);
154
155			let (method_id, mut reader) = AbiReader::new_call(&call_context.input).ok()?;
156			let call = <UniqueRefungibleTokenCall<T>>::parse(method_id, &mut reader).ok()??;
157			Some(T::CrossAccountId::from_sub(
158				refungible::token_call_sponsor(call, token, who).map(|()| sponsor)?,
159			))
160		}
131	}161	}
132}162}
163
164mod common {
165	use super::*;
166
167	use pallet_common::erc::{CollectionCall};
168
169	pub fn collection_call_sponsor<T>(
170		call: CollectionCall<T>,
171		_collection: CollectionHandle<T>,
172		_who: &T::CrossAccountId,
173	) -> Option<()>
174	where
175		T: UniqueConfig + FungibleConfig + NonfungibleConfig + RefungibleConfig,
176	{
177		use CollectionCall::*;
178
179		match call {
180			// Readonly
181			ERC165Call(_, _)
182			| CollectionProperty { .. }
183			| CollectionProperties { .. }
184			| HasCollectionPendingSponsor
185			| CollectionSponsor
186			| ContractAddress
187			| AllowlistedCross { .. }
188			| IsOwnerOrAdminEth { .. }
189			| IsOwnerOrAdminCross { .. }
190			| CollectionOwner
191			| CollectionAdmins
192			| CollectionLimits
193			| CollectionNestingRestrictedIds
194			| CollectionNestingPermissions
195			| UniqueCollectionType => None,
196
197			// Not sponsored
198			AddToCollectionAllowList { .. }
199			| AddToCollectionAllowListCross { .. }
200			| RemoveFromCollectionAllowList { .. }
201			| RemoveFromCollectionAllowListCross { .. }
202			| AddCollectionAdminCross { .. }
203			| RemoveCollectionAdminCross { .. }
204			| AddCollectionAdmin { .. }
205			| RemoveCollectionAdmin { .. }
206			| SetNestingBool { .. }
207			| SetNesting { .. }
208			| SetCollectionAccess { .. }
209			| SetCollectionMintMode { .. }
210			| SetOwner { .. }
211			| ChangeCollectionOwnerCross { .. }
212			| SetCollectionProperty { .. }
213			| SetCollectionProperties { .. }
214			| DeleteCollectionProperty { .. }
215			| DeleteCollectionProperties { .. }
216			| SetCollectionSponsor { .. }
217			| SetCollectionSponsorCross { .. }
218			| SetCollectionLimit { .. }
219			| ConfirmCollectionSponsorship
220			| RemoveCollectionSponsor => None,
221		}
222	}
223}
133224

98    "outputs": [],98    "outputs": [],
99    "stateMutability": "nonpayable",99    "stateMutability": "nonpayable",
100    "type": "function"100    "type": "function"
101  }101  },
102  {
103    "inputs": [
104      { "internalType": "address", "name": "to", "type": "address" },
105      { "internalType": "uint256[]", "name": "tokenIds", "type": "uint256[]" }
106    ],
107    "name": "mintBulk",
108    "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
109    "stateMutability": "nonpayable",
110    "type": "function"
111  },
112  {
113    "inputs": [
114      { "internalType": "address", "name": "to", "type": "address" },
115      {
116        "components": [
117          { "internalType": "uint256", "name": "field_0", "type": "uint256" },
118          { "internalType": "string", "name": "field_1", "type": "string" }
119        ],
120        "internalType": "struct Tuple0[]",
121        "name": "tokens",
122        "type": "tuple[]"
123      }
124    ],
125    "name": "mintBulkWithTokenURI",
126    "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
127    "stateMutability": "nonpayable",
128    "type": "function"
129  }
102]130]
103131

183183
184/// Ethereum representation of Optional value with CrossAddress.184/// Ethereum representation of Optional value with CrossAddress.
185struct OptionCrossAddress {185struct OptionCrossAddress {
186	/// TODO: field description
186	bool status;187	bool status;
188	/// TODO: field description
187	CrossAddress value;189	CrossAddress value;
188}190}
189191

15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
1616
17import {IKeyringPair} from '@polkadot/types/types';17import {IKeyringPair} from '@polkadot/types/types';
18import {usingPlaygrounds} from '../util/index';18import {Pallets, requirePalletsOrSkip, usingPlaygrounds} from '../util/index';
19import {itEth, expect} from './util';19import {itEth, expect} from './util';
2020
21describe('evm collection sponsoring', () => {21describe('evm nft collection sponsoring', () => {
22  let donor: IKeyringPair;22  let donor: IKeyringPair;
23  let alice: IKeyringPair;23  let alice: IKeyringPair;
24  let nominal: bigint;24  let nominal: bigint;
101      expect(await collectionEvm.methods.hasCollectionPendingSponsor().call({from: owner})).to.be.true;101      expect(await collectionEvm.methods.hasCollectionPendingSponsor().call({from: owner})).to.be.true;
102102
103      await collectionEvm.methods.confirmCollectionSponsorship().send({from: sponsor});103      await collectionEvm.methods.confirmCollectionSponsorship().send({from: sponsor});
104      let sponsorTuple = await collectionEvm.methods.collectionSponsor().call({from: owner});104      let sponsorStruct = await collectionEvm.methods.collectionSponsor().call({from: owner});
105      expect(helper.address.restoreCrossAccountFromBigInt(BigInt(sponsorTuple.sub))).to.be.eq(helper.address.ethToSubstrate(sponsor, true));105      expect(helper.address.restoreCrossAccountFromBigInt(BigInt(sponsorStruct.sub))).to.be.eq(helper.address.ethToSubstrate(sponsor, true));
106      expect(await collectionEvm.methods.hasCollectionPendingSponsor().call({from: owner})).to.be.false;106      expect(await collectionEvm.methods.hasCollectionPendingSponsor().call({from: owner})).to.be.false;
107107
108      await collectionEvm.methods.removeCollectionSponsor().send({from: owner});108      await collectionEvm.methods.removeCollectionSponsor().send({from: owner});
109109
110      sponsorTuple = await collectionEvm.methods.collectionSponsor().call({from: owner});110      sponsorStruct = await collectionEvm.methods.collectionSponsor().call({from: owner});
111      expect(sponsorTuple.eth).to.be.eq('0x0000000000000000000000000000000000000000');111      expect(sponsorStruct.eth).to.be.eq('0x0000000000000000000000000000000000000000');
112    }));112    }));
113113
114  [114  [
144      expect(nextTokenId).to.be.equal('1');144      expect(nextTokenId).to.be.equal('1');
145145
146      // Set collection permissions:146      // Set collection permissions:
147      const oldPermissions = (await collectionSub.getData())!.raw.permissions; // (await getDetailedCollectionInfo(api, collectionId))!.permissions.toHuman();147      const oldPermissions = (await collectionSub.getData())!.raw.permissions;
148      expect(oldPermissions.mintMode).to.be.false;148      expect(oldPermissions.mintMode).to.be.false;
149      expect(oldPermissions.access).to.be.equal('Normal');149      expect(oldPermissions.access).to.be.equal('Normal');
150150
151      await collectionEvm.methods.setCollectionAccess(1 /*'AllowList'*/).send({from: owner});151      await collectionEvm.methods.setCollectionAccess(1 /*'AllowList'*/).send({from: owner});
152      await collectionEvm.methods.addToCollectionAllowListCross(userCross).send({from: owner});152      await collectionEvm.methods.addToCollectionAllowListCross(userCross).send({from: owner});
153      await collectionEvm.methods.setCollectionMintMode(true).send({from: owner});153      await collectionEvm.methods.setCollectionMintMode(true).send({from: owner});
154154
155      const newPermissions = (await collectionSub.getData())!.raw.permissions; // (await getDetailedCollectionInfo(api, collectionId))!.permissions.toHuman();155      const newPermissions = (await collectionSub.getData())!.raw.permissions;
156      expect(newPermissions.mintMode).to.be.true;156      expect(newPermissions.mintMode).to.be.true;
157      expect(newPermissions.access).to.be.equal('AllowList');157      expect(newPermissions.access).to.be.equal('AllowList');
158158
159      const ownerBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(owner));159      const ownerBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(owner));
160      const sponsorBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsorEth));160      const sponsorBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsorEth));
161      const userBalanceBefore =  await helper.balance.getSubstrate(helper.address.ethToSubstrate(user));
161162
162      // User can mint token without balance:163      // User can mint token without balance:
163      {164      {
181182
182        expect(await collectionEvm.methods.tokenURI(nextTokenId).call()).to.be.equal('Test URI');183        expect(await collectionEvm.methods.tokenURI(nextTokenId).call()).to.be.equal('Test URI');
183        expect(ownerBalanceBefore).to.be.eq(ownerBalanceAfter);184        expect(ownerBalanceBefore).to.be.eq(ownerBalanceAfter);
184        expect(userBalanceAfter).to.be.eq(0n);185        expect(userBalanceAfter).to.be.eq(userBalanceBefore);
185        expect(sponsorBalanceBefore > sponsorBalanceAfter).to.be.true;186        expect(sponsorBalanceBefore > sponsorBalanceAfter).to.be.true;
186      }187      }
187    }));188    }));
318  });319  });
319});320});
321
322describe('evm RFT collection sponsoring', () => {
323  let donor: IKeyringPair;
324  let alice: IKeyringPair;
325  let nominal: bigint;
326
327  before(async function() {
328    await usingPlaygrounds(async (helper, privateKey) => {
329      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);
330      donor = await privateKey({filename: __filename});
331      [alice] = await helper.arrange.createAccounts([100n], donor);
332      nominal = helper.balance.getOneTokenNominal();
333    });
334  });
335
336  [
337    'mintCross',
338    'mintWithTokenURI',
339  ].map(testCase =>
340    itEth(`[${testCase}] sponsors mint transactions`, async ({helper}) => {
341      const collection = await helper.rft.mintCollection(alice, {tokenPrefix: 'spnr', permissions: {mintMode: true}, tokenPropertyPermissions: [
342        {key: 'URI', permission: {tokenOwner: true, mutable: true, collectionAdmin: true}},
343      ]});
344
345      const owner = await helper.eth.createAccountWithBalance(donor);
346      await collection.setSponsor(alice, alice.address);
347      await collection.confirmSponsorship(alice);
348
349      const minter = helper.eth.createAccount();
350      const minterCross = helper.ethCrossAccount.fromAddress(minter);
351      expect(await helper.balance.getEthereum(minter)).to.equal(0n);
352
353      const collectionAddress = helper.ethAddress.fromCollectionId(collection.collectionId);
354      const contract = await helper.ethNativeContract.collection(collectionAddress, 'rft', minter, true);
355
356      await collection.addToAllowList(alice, {Ethereum: minter});
357      await collection.addAdmin(alice, {Ethereum: owner});
358      const collectionHelpers = await helper.ethNativeContract.collectionHelpers(owner);
359      await collectionHelpers.methods.makeCollectionERC721MetadataCompatible(collectionAddress, 'base/')
360        .send();
361
362      let mintingResult;
363      let tokenId;
364      switch (testCase) {
365        case 'mintCross':
366          mintingResult = await contract.methods.mintCross(minterCross, []).send();
367          break;
368        case 'mintWithTokenURI':
369          mintingResult = await contract.methods.mintWithTokenURI(minter, 'Test URI').send();
370          tokenId = mintingResult.events.Transfer.returnValues.tokenId;
371          expect(await contract.methods.tokenURI(tokenId).call()).to.be.equal('Test URI');
372          break;
373      }
374
375      const events = helper.eth.normalizeEvents(mintingResult.events);
376      expect(events).to.deep.include({
377        address: collectionAddress,
378        event: 'Transfer',
379        args: {
380          from: '0x0000000000000000000000000000000000000000',
381          to: minter,
382          tokenId: '1',
383        },
384      });
385    }));
386
387  [
388    'setCollectionSponsorCross',
389    'setCollectionSponsor', // Soft-deprecated
390  ].map(testCase =>
391    itEth(`[${testCase}] can remove collection sponsor`, async ({helper}) => {
392      const owner = await helper.eth.createAccountWithBalance(donor);
393      const collectionHelpers = await helper.ethNativeContract.collectionHelpers(owner);
394
395      let result = await collectionHelpers.methods.createRFTCollection('Sponsor collection', '1', '1').send({value: Number(2n * nominal)});
396      const collectionIdAddress = helper.ethAddress.normalizeAddress(result.events.CollectionCreated.returnValues.collectionId);
397      const sponsor = await helper.eth.createAccountWithBalance(donor);
398      const sponsorCross = helper.ethCrossAccount.fromAddress(sponsor);
399      const collectionEvm = await helper.ethNativeContract.collection(collectionIdAddress, 'rft', owner, testCase === 'setCollectionSponsor');
400
401      expect(await collectionEvm.methods.hasCollectionPendingSponsor().call({from: owner})).to.be.false;
402      result = await collectionEvm.methods[testCase](testCase === 'setCollectionSponsor' ? sponsor : sponsorCross).send({from: owner});
403      expect(await collectionEvm.methods.hasCollectionPendingSponsor().call({from: owner})).to.be.true;
404
405      await collectionEvm.methods.confirmCollectionSponsorship().send({from: sponsor});
406      expect(await collectionEvm.methods.hasCollectionPendingSponsor().call({from: owner})).to.be.false;
407
408      await collectionEvm.methods.removeCollectionSponsor().send({from: owner});
409
410      const sponsorStruct = await collectionEvm.methods.collectionSponsor().call({from: owner});
411      expect(sponsorStruct.eth).to.be.eq('0x0000000000000000000000000000000000000000');
412    }));
413
414  [
415    'setCollectionSponsorCross',
416    'setCollectionSponsor', // Soft-deprecated
417  ].map(testCase =>
418    itEth(`[${testCase}] Can sponsor from evm address via access list`, async ({helper}) => {
419      const owner = await helper.eth.createAccountWithBalance(donor);
420      const sponsorEth = await helper.eth.createAccountWithBalance(donor);
421      const sponsorCrossEth = helper.ethCrossAccount.fromAddress(sponsorEth);
422
423      const {collectionId, collectionAddress} = await helper.eth.createERC721MetadataCompatibleRFTCollection(owner, 'Sponsor collection', '1', '1', '');
424
425      const collectionSub = helper.rft.getCollectionObject(collectionId);
426      const collectionEvm = await helper.ethNativeContract.collection(collectionAddress, 'rft', owner, testCase === 'setCollectionSponsor');
427
428      // Set collection sponsor:
429      await collectionEvm.methods[testCase](testCase === 'setCollectionSponsor' ? sponsorEth : sponsorCrossEth).send({from: owner});
430      let sponsorship = (await collectionSub.getData())!.raw.sponsorship;
431      expect(sponsorship.Unconfirmed).to.be.eq(helper.address.ethToSubstrate(sponsorEth, true));
432      // Account cannot confirm sponsorship if it is not set as a sponsor
433      await expect(collectionEvm.methods.confirmCollectionSponsorship().call()).to.be.rejectedWith('ConfirmSponsorshipFail');
434
435      // Sponsor can confirm sponsorship:
436      await collectionEvm.methods.confirmCollectionSponsorship().send({from: sponsorEth});
437      sponsorship = (await collectionSub.getData())!.raw.sponsorship;
438      expect(sponsorship.Confirmed).to.be.eq(helper.address.ethToSubstrate(sponsorEth, true));
439
440      // Create user with no balance:
441      const user = helper.eth.createAccount();
442      const userCross = helper.ethCrossAccount.fromAddress(user);
443      const nextTokenId = await collectionEvm.methods.nextTokenId().call();
444      expect(nextTokenId).to.be.equal('1');
445
446      // Set collection permissions:
447      const oldPermissions = (await collectionSub.getData())!.raw.permissions;
448      expect(oldPermissions.mintMode).to.be.false;
449      expect(oldPermissions.access).to.be.equal('Normal');
450
451      await collectionEvm.methods.setCollectionAccess(1 /*'AllowList'*/).send({from: owner});
452      await collectionEvm.methods.addToCollectionAllowListCross(userCross).send({from: owner});
453      await collectionEvm.methods.setCollectionMintMode(true).send({from: owner});
454
455      const newPermissions = (await collectionSub.getData())!.raw.permissions;
456      expect(newPermissions.mintMode).to.be.true;
457      expect(newPermissions.access).to.be.equal('AllowList');
458
459      const ownerBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(owner));
460      const sponsorBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsorEth));
461      const userBalanceBefore =  await helper.balance.getSubstrate(helper.address.ethToSubstrate(user));
462
463      // User can mint token without balance:
464      {
465        const result = await collectionEvm.methods.mintWithTokenURI(user, 'Test URI').send({from: user});
466        const events = helper.eth.normalizeEvents(result.events);
467
468        expect(events).to.deep.include({
469          address: collectionAddress,
470          event: 'Transfer',
471          args: {
472            from: '0x0000000000000000000000000000000000000000',
473            to: user,
474            tokenId: '1',
475          },
476        });
477
478        const ownerBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(owner));
479        const sponsorBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsorEth));
480        const userBalanceAfter =  await helper.balance.getSubstrate(helper.address.ethToSubstrate(user));
481
482        expect(await collectionEvm.methods.tokenURI(nextTokenId).call()).to.be.equal('Test URI');
483        expect(ownerBalanceBefore).to.be.eq(ownerBalanceAfter);
484        expect(userBalanceAfter).to.be.eq(userBalanceBefore);
485        expect(sponsorBalanceBefore > sponsorBalanceAfter).to.be.true;
486      }
487    }));
488
489  [
490    'setCollectionSponsorCross',
491    'setCollectionSponsor', // Soft-deprecated
492  ].map(testCase =>
493    itEth(`[${testCase}] Check that collection admin EVM transaction spend money from sponsor eth address`, async ({helper}) => {
494      const owner = await helper.eth.createAccountWithBalance(donor);
495      const sponsor = await helper.eth.createAccountWithBalance(donor);
496      const sponsorCross = helper.ethCrossAccount.fromAddress(sponsor);
497
498      const {collectionAddress, collectionId} = await helper.eth.createERC721MetadataCompatibleRFTCollection(owner,'Sponsor collection', '1', '1', '');
499
500      const collectionSub = helper.rft.getCollectionObject(collectionId);
501      const collectionEvm = await helper.ethNativeContract.collection(collectionAddress, 'rft', owner, testCase === 'setCollectionSponsor');
502      // Set collection sponsor:
503      expect(await collectionEvm.methods.hasCollectionPendingSponsor().call()).to.be.false;
504      await collectionEvm.methods[testCase](testCase === 'setCollectionSponsor' ? sponsor : sponsorCross).send();
505      expect(await collectionEvm.methods.hasCollectionPendingSponsor().call()).to.be.true;
506      let collectionData = (await collectionSub.getData())!;
507      expect(collectionData.raw.sponsorship.Unconfirmed).to.be.eq(helper.address.ethToSubstrate(sponsor, true));
508      await expect(collectionEvm.methods.confirmCollectionSponsorship().call()).to.be.rejectedWith('ConfirmSponsorshipFail');
509      expect(await collectionEvm.methods.hasCollectionPendingSponsor().call()).to.be.true;
510
511      await collectionEvm.methods.confirmCollectionSponsorship().send({from: sponsor});
512      collectionData = (await collectionSub.getData())!;
513      expect(collectionData.raw.sponsorship.Confirmed).to.be.eq(helper.address.ethToSubstrate(sponsor, true));
514      expect(await collectionEvm.methods.hasCollectionPendingSponsor().call()).to.be.false;
515      const sponsorStruct = await collectionEvm.methods.collectionSponsor().call({from: owner});
516      const sponsorSubAddress = helper.address.normalizeSubstrateToChainFormat(helper.address.ethToSubstrate(sponsor));
517      const actualSubAddress = helper.address.normalizeSubstrateToChainFormat(helper.address.restoreCrossAccountFromBigInt(BigInt(sponsorStruct.sub)));
518      expect(actualSubAddress).to.be.equal(sponsorSubAddress);
519
520      const user = helper.eth.createAccount();
521      const userCross = helper.ethCrossAccount.fromAddress(user);
522      await collectionEvm.methods.addCollectionAdminCross(userCross).send();
523
524      const ownerBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(owner));
525      const sponsorBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsor));
526
527      const mintingResult = await collectionEvm.methods.mintWithTokenURI(user, 'Test URI').send({from: user});
528      const tokenId = mintingResult.events.Transfer.returnValues.tokenId;
529
530      const events = helper.eth.normalizeEvents(mintingResult.events);
531      const address = helper.ethAddress.fromCollectionId(collectionId);
532
533      expect(events).to.deep.include({
534        address,
535        event: 'Transfer',
536        args: {
537          from: '0x0000000000000000000000000000000000000000',
538          to: user,
539          tokenId: '1',
540        },
541      });
542      expect(await collectionEvm.methods.tokenURI(tokenId).call({from: user})).to.be.equal('Test URI');
543
544      const ownerBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(owner));
545      expect(ownerBalanceAfter).to.be.eq(ownerBalanceBefore);
546      const sponsorBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsor));
547      expect(sponsorBalanceAfter < sponsorBalanceBefore).to.be.true;
548    }));
549
550  itEth('Check that collection admin EVM transaction spend money from sponsor sub address', async ({helper}) => {
551    const owner = await helper.eth.createAccountWithBalance(donor);
552    const sponsor = alice;
553    const sponsorCross = helper.ethCrossAccount.fromKeyringPair(sponsor);
554
555    const {collectionAddress, collectionId} = await helper.eth.createERC721MetadataCompatibleRFTCollection(owner,'Sponsor collection', '1', '1', '');
556
557    const collectionSub = helper.rft.getCollectionObject(collectionId);
558    const collectionEvm = await helper.ethNativeContract.collection(collectionAddress, 'rft', owner, false);
559    // Set collection sponsor:
560    expect(await collectionEvm.methods.hasCollectionPendingSponsor().call()).to.be.false;
561    await collectionEvm.methods.setCollectionSponsorCross(sponsorCross).send();
562    expect(await collectionEvm.methods.hasCollectionPendingSponsor().call()).to.be.true;
563    let collectionData = (await collectionSub.getData())!;
564    expect(collectionData.raw.sponsorship.Unconfirmed).to.be.eq(sponsor.address);
565    await expect(collectionEvm.methods.confirmCollectionSponsorship().call()).to.be.rejectedWith('ConfirmSponsorshipFail');
566
567    await collectionSub.confirmSponsorship(sponsor);
568    collectionData = (await collectionSub.getData())!;
569    expect(collectionData.raw.sponsorship.Confirmed).to.be.eq(sponsor.address);
570    expect(await collectionEvm.methods.hasCollectionPendingSponsor().call()).to.be.false;
571    const sponsorStruct = await collectionEvm.methods.collectionSponsor().call({from: owner});
572    expect(BigInt(sponsorStruct.sub)).to.be.equal(BigInt('0x' + Buffer.from(sponsor.addressRaw).toString('hex')));
573
574    const user = helper.eth.createAccount();
575    const userCross = helper.ethCrossAccount.fromAddress(user);
576    await collectionEvm.methods.addCollectionAdminCross(userCross).send();
577
578    const ownerBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(owner));
579    const sponsorBalanceBefore = await helper.balance.getSubstrate(sponsor.address);
580
581    const mintingResult = await collectionEvm.methods.mintWithTokenURI(user, 'Test URI').send({from: user});
582    const tokenId = mintingResult.events.Transfer.returnValues.tokenId;
583
584    const events = helper.eth.normalizeEvents(mintingResult.events);
585
586    expect(events).to.deep.include({
587      address: collectionAddress,
588      event: 'Transfer',
589      args: {
590        from: '0x0000000000000000000000000000000000000000',
591        to: user,
592        tokenId: '1',
593      },
594    });
595    expect(await collectionEvm.methods.tokenURI(tokenId).call({from: user})).to.be.equal('Test URI');
596
597    const ownerBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(owner));
598    expect(ownerBalanceAfter).to.be.eq(ownerBalanceBefore);
599    const sponsorBalanceAfter = await helper.balance.getSubstrate(sponsor.address);
600    expect(sponsorBalanceAfter < sponsorBalanceBefore).to.be.true;
601  });
602
603  itEth('Sponsoring collection from substrate address via access list', async ({helper}) => {
604    const owner = await helper.eth.createAccountWithBalance(donor);
605    const user = helper.eth.createAccount();
606    const userCross =  helper.ethCrossAccount.fromAddress(user);
607    const sponsor = alice;
608    const sponsorCross = helper.ethCrossAccount.fromKeyringPair(sponsor);
609
610    const {collectionAddress, collectionId} = await helper.eth.createERC721MetadataCompatibleRFTCollection(owner,'Sponsor collection', '1', '1', '');
611    const collectionEvm = await helper.ethNativeContract.collection(collectionAddress, 'rft', owner, false);
612
613    await collectionEvm.methods.setCollectionSponsorCross(sponsorCross).send({from: owner});
614
615    const collectionSub = helper.rft.getCollectionObject(collectionId);
616    await collectionSub.confirmSponsorship(sponsor);
617
618    const nextTokenId = await collectionEvm.methods.nextTokenId().call();
619    expect(nextTokenId).to.be.equal('1');
620
621    await collectionEvm.methods.setCollectionAccess(1 /*'AllowList'*/).send({from: owner});
622
623    await collectionEvm.methods.addToCollectionAllowListCross(userCross).send({from: owner});
624    await collectionEvm.methods.setCollectionMintMode(true).send({from: owner});
625
626    const ownerBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(owner));
627    const sponsorBalanceBefore = await helper.balance.getSubstrate(sponsor.address);
628    const userBalanceBefore =  await helper.balance.getSubstrate(helper.address.ethToSubstrate(user));
629
630    {
631      const nextTokenId = await collectionEvm.methods.nextTokenId().call();
632      expect(nextTokenId).to.be.equal('1');
633      const mintingResult = await collectionEvm.methods.mintWithTokenURI(
634        user,
635        'Test URI',
636      ).send({from: user});
637
638      const events = helper.eth.normalizeEvents(mintingResult.events);
639
640
641      expect(events).to.deep.include({
642        address: collectionAddress,
643        event: 'Transfer',
644        args: {
645          from: '0x0000000000000000000000000000000000000000',
646          to: user,
647          tokenId: nextTokenId,
648        },
649      });
650
651      const ownerBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(owner));
652      const sponsorBalanceAfter = await helper.balance.getSubstrate(sponsor.address);
653      const userBalanceAfter =  await helper.balance.getSubstrate(helper.address.ethToSubstrate(user));
654
655      expect(await collectionEvm.methods.tokenURI(nextTokenId).call()).to.be.equal('Test URI');
656      expect(ownerBalanceBefore).to.be.eq(ownerBalanceAfter);
657      expect(userBalanceAfter).to.be.eq(userBalanceBefore);
658      expect(sponsorBalanceBefore > sponsorBalanceAfter).to.be.true;
659    }
660  });
661
662  itEth('Can reassign collection sponsor', async ({helper}) => {
663    const owner = await helper.eth.createAccountWithBalance(donor);
664    const sponsorEth = await helper.eth.createAccountWithBalance(donor);
665    const sponsorCrossEth = helper.ethCrossAccount.fromAddress(sponsorEth);
666    const [sponsorSub] = await helper.arrange.createAccounts([100n], donor);
667    const sponsorCrossSub = helper.ethCrossAccount.fromKeyringPair(sponsorSub);
668
669    const {collectionAddress, collectionId} = await helper.eth.createERC721MetadataCompatibleRFTCollection(owner,'Sponsor collection', '1', '1', '');
670    const collectionSub = helper.rft.getCollectionObject(collectionId);
671    const collectionEvm = await helper.ethNativeContract.collection(collectionAddress, 'rft', owner);
672
673    // Set and confirm sponsor:
674    await collectionEvm.methods.setCollectionSponsorCross(sponsorCrossEth).send({from: owner});
675    await collectionEvm.methods.confirmCollectionSponsorship().send({from: sponsorEth});
676
677    // Can reassign sponsor:
678    await collectionEvm.methods.setCollectionSponsorCross(sponsorCrossSub).send({from: owner});
679    const collectionSponsor = (await collectionSub.getData())?.raw.sponsorship;
680    expect(collectionSponsor).to.deep.eq({Unconfirmed: sponsorSub.address});
681  });
682
683  [
684    'transfer',
685    'transferCross',
686    'transferFrom',
687    'transferFromCross',
688  ].map(testCase =>
689    itEth(`[${testCase}] Check that transfer via EVM spend money from sponsor address`, async ({helper}) => {
690      const owner = await helper.eth.createAccountWithBalance(donor);
691
692      const {collectionAddress} = await helper.eth.createERC721MetadataCompatibleRFTCollection(owner,'Sponsor collection', '1', '1', '');
693      const sponsor = await helper.eth.createAccountWithBalance(donor);
694      const sponsorCross = helper.ethCrossAccount.fromAddress(sponsor);
695      const receiver = await helper.eth.createAccountWithBalance(donor);
696      const collectionEvm = await helper.ethNativeContract.collection(collectionAddress, 'rft', owner);
697
698      await collectionEvm.methods.setCollectionSponsorCross(sponsorCross).send();
699      await collectionEvm.methods.confirmCollectionSponsorship().send({from: sponsor});
700
701      const user = await helper.eth.createAccountWithBalance(donor);
702      const userCross = helper.ethCrossAccount.fromAddress(user);
703      await collectionEvm.methods.addCollectionAdminCross(userCross).send();
704
705      const result = await collectionEvm.methods.mintWithTokenURI(user, 'Test URI').send({from: user});
706      const tokenId = result.events.Transfer.returnValues.tokenId;
707
708      const ownerBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(owner));
709      const sponsorBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsor));
710      const userBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(user));
711
712      switch (testCase) {
713        case 'transfer':
714          await collectionEvm.methods.transfer(receiver, tokenId).send({from: user});
715          break;
716        case 'transferCross':
717          await collectionEvm.methods.transferCross(helper.ethCrossAccount.fromAddress(receiver), tokenId).send({from: user});
718          break;
719        case 'transferFrom':
720          await collectionEvm.methods.transferFrom(user, receiver, tokenId).send({from: user});
721          break;
722        case 'transferFromCross':
723          await collectionEvm.methods.transferFromCross(helper.ethCrossAccount.fromAddress(user), helper.ethCrossAccount.fromAddress(receiver), tokenId).send({from: user});
724          break;
725      }
726
727      const ownerBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(owner));
728      expect(ownerBalanceAfter).to.be.eq(ownerBalanceBefore);
729      const sponsorBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsor));
730      expect(sponsorBalanceAfter < sponsorBalanceBefore).to.be.true;
731      const userBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(user));
732      expect(userBalanceAfter).to.be.eq(userBalanceBefore);
733    }));
734});
735
736describe('evm RFT token sponsoring', () => {
737  let donor: IKeyringPair;
738
739  before(async function() {
740    await usingPlaygrounds(async (helper, privateKey) => {
741      requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);
742      donor = await privateKey({filename: __filename});
743    });
744  });
745
746  [
747    'transfer',
748    'transferCross',
749    'transferFrom',
750    'transferFromCross',
751  ].map(testCase =>
752    itEth(`[${testCase}] Check that token piece transfer via EVM spend money from sponsor address`, async ({helper}) => {
753      const owner = await helper.eth.createAccountWithBalance(donor);
754
755      const {collectionAddress, collectionId} = await helper.eth.createERC721MetadataCompatibleRFTCollection(owner,'Sponsor collection', '1', '1', '');
756      const sponsor = await helper.eth.createAccountWithBalance(donor);
757      const sponsorCross = helper.ethCrossAccount.fromAddress(sponsor);
758      const receiver = await helper.eth.createAccountWithBalance(donor);
759      const collectionEvm = await helper.ethNativeContract.collection(collectionAddress, 'rft', owner);
760
761      await collectionEvm.methods.setCollectionSponsorCross(sponsorCross).send();
762      await collectionEvm.methods.confirmCollectionSponsorship().send({from: sponsor});
763
764      const user = await helper.eth.createAccountWithBalance(donor);
765      const userCross = helper.ethCrossAccount.fromAddress(user);
766      await collectionEvm.methods.addCollectionAdminCross(userCross).send();
767
768      const result = await collectionEvm.methods.mintWithTokenURI(user, 'Test URI').send({from: user});
769      const tokenId = result.events.Transfer.returnValues.tokenId;
770
771      const tokenContract = await helper.ethNativeContract.rftTokenById(collectionId, tokenId, user);
772      await tokenContract.methods.repartition(2).send();
773
774      const ownerBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(owner));
775      const sponsorBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsor));
776      const userBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(user));
777
778      switch (testCase) {
779        case 'transfer':
780          await tokenContract.methods.transfer(receiver, 1).send();
781          break;
782        case 'transferCross':
783          await tokenContract.methods.transferCross(helper.ethCrossAccount.fromAddress(receiver), 1).send();
784          break;
785        case 'transferFrom':
786          await tokenContract.methods.transferFrom(user, receiver, 1).send();
787          break;
788        case 'transferFromCross':
789          await tokenContract.methods.transferFromCross(helper.ethCrossAccount.fromAddress(user), helper.ethCrossAccount.fromAddress(receiver), 1).send();
790          break;
791      }
792
793      const ownerBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(owner));
794      expect(ownerBalanceAfter).to.be.eq(ownerBalanceBefore);
795      const sponsorBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsor));
796      expect(sponsorBalanceAfter < sponsorBalanceBefore).to.be.true;
797      const userBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(user));
798      expect(userBalanceAfter).to.be.eq(userBalanceBefore);
799    }));
800
801  [
802    'approve',
803    'approveCross',
804  ].map(testCase =>
805    itEth(`[${testCase}] Check that approve via EVM spend money from sponsor address`, async ({helper}) => {
806      const owner = await helper.eth.createAccountWithBalance(donor);
807
808      const {collectionAddress, collectionId} = await helper.eth.createERC721MetadataCompatibleRFTCollection(owner,'Sponsor collection', '1', '1', '');
809      const sponsor = await helper.eth.createAccountWithBalance(donor);
810      const sponsorCross = helper.ethCrossAccount.fromAddress(sponsor);
811      const receiver = await helper.eth.createAccountWithBalance(donor);
812      const collectionEvm = await helper.ethNativeContract.collection(collectionAddress, 'rft', owner);
813
814      await collectionEvm.methods.setCollectionSponsorCross(sponsorCross).send();
815      await collectionEvm.methods.confirmCollectionSponsorship().send({from: sponsor});
816
817      const user = await helper.eth.createAccountWithBalance(donor);
818      const userCross = helper.ethCrossAccount.fromAddress(user);
819      await collectionEvm.methods.addCollectionAdminCross(userCross).send();
820
821      const result = await collectionEvm.methods.mintWithTokenURI(user, 'Test URI').send({from: user});
822      const tokenId = result.events.Transfer.returnValues.tokenId;
823
824      const tokenContract = await helper.ethNativeContract.rftTokenById(collectionId, tokenId, user);
825      await tokenContract.methods.repartition(2).send();
826
827      const ownerBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(owner));
828      const sponsorBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsor));
829      const userBalanceBefore = await helper.balance.getSubstrate(helper.address.ethToSubstrate(user));
830
831      switch (testCase) {
832        case 'approve':
833          await tokenContract.methods.approve(receiver, 1).send();
834          break;
835        case 'approveCross':
836          await tokenContract.methods.approveCross(helper.ethCrossAccount.fromAddress(receiver), 1).send();
837          break;
838      }
839
840      const ownerBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(owner));
841      expect(ownerBalanceAfter).to.be.eq(ownerBalanceBefore);
842      const sponsorBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(sponsor));
843      expect(sponsorBalanceAfter < sponsorBalanceBefore).to.be.true;
844      const userBalanceAfter = await helper.balance.getSubstrate(helper.address.ethToSubstrate(user));
845      expect(userBalanceAfter).to.be.eq(userBalanceBefore);
846    }));
847});
320848
849