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

--- a/pallets/common/src/erc.rs
+++ b/pallets/common/src/erc.rs
@@ -26,7 +26,7 @@
 use sp_std::vec::Vec;
 use up_data_structs::{
 	AccessMode, CollectionMode, CollectionPermissions, OwnerRestrictedSet, Property,
-	SponsoringRateLimit,
+	SponsoringRateLimit, SponsorshipState,
 };
 use alloc::format;
 
@@ -63,7 +63,7 @@
 #[solidity_interface(name = Collection)]
 impl<T: Config> CollectionHandle<T>
 where
-	T::AccountId: From<[u8; 32]>,
+	T::AccountId: From<[u8; 32]> + AsRef<[u8]>,
 {
 	/// Set collection property.
 	///
@@ -128,6 +128,25 @@
 		save(self)
 	}
 
+	/// Set the substrate sponsor of the collection.
+	///
+	/// @dev In order for sponsorship to work, it must be confirmed on behalf of the sponsor.
+	///
+	/// @param sponsor Substrate address of the sponsor from whose account funds will be debited for operations with the contract.
+	fn set_collection_sponsor_substrate(&mut self, caller: caller, sponsor: uint256) -> Result<void> {
+		check_is_owner_or_admin(caller, self)?;
+
+		let sponsor = convert_uint256_to_cross_account::<T>(sponsor);
+		self.set_sponsor(sponsor.as_sub().clone())
+			.map_err(dispatch_to_evm::<T>)?;
+		save(self)
+	}
+
+	// /// Whether there is a pending sponsor.
+	fn has_collection_pending_sponsor(&self) -> Result<bool> {
+		Ok(matches!(self.collection.sponsorship, SponsorshipState::Unconfirmed(_)))
+	}
+
 	/// Collection sponsorship confirmation.
 	///
 	/// @dev After setting the sponsor for the collection, it must be confirmed with this function.
@@ -142,6 +161,26 @@
 		save(self)
 	}
 
+	/// Remove collection sponsor.
+	fn remove_collection_sponsor(&mut self, caller: caller) -> Result<void> {
+		check_is_owner_or_admin(caller, self)?;
+		self.remove_sponsor().map_err(dispatch_to_evm::<T>)?;
+		save(self)
+	}
+
+	/// Get current sponsor.
+	///
+	/// @return Tuble with sponsor address and his substrate mirror. If there is no confirmed sponsor error "Contract has no sponsor" throw.
+	fn get_collection_sponsor(&self) -> Result<(address, uint256)> {
+		let sponsor = match self.collection.sponsorship {
+			SponsorshipState::Disabled | SponsorshipState::Unconfirmed(_) => return Ok(Default::default()),
+			SponsorshipState::Confirmed(ref sponsor) => sponsor,
+		};
+		let sponsor = T::CrossAccountId::from_sub(sponsor.clone());
+		let sponsor_sub = convert_cross_account_to_uint256::<T>(&sponsor)?;
+		Ok((*sponsor.as_eth(), sponsor_sub))
+	}
+
 	/// Set limits for the collection.
 	/// @dev Throws error if limit not found.
 	/// @param limit Name of the limit. Valid names:

--- a/pallets/common/src/eth.rs
+++ b/pallets/common/src/eth.rs
@@ -58,3 +58,14 @@
 	let slice = from.as_sub().as_ref();
 	uint256::from_big_endian(slice)
 }
+
+/// Convert `uint256` to `CrossAccountId`.
+pub fn convert_uint256_to_cross_account<T: Config>(from: uint256) -> T::CrossAccountId 
+where
+	T::AccountId: From<[u8; 32]>,
+{
+	let mut new_admin_arr: [u8; 32] = Default::default();
+	from.to_big_endian(&mut new_admin_arr);
+	let account_id = T::AccountId::from(new_admin_arr);
+	T::CrossAccountId::from_sub(account_id)
+}

--- a/pallets/common/src/lib.rs
+++ b/pallets/common/src/lib.rs
@@ -231,6 +231,12 @@
 		Ok(true)
 	}
 
+	/// Remove collection sponsor.
+	pub fn remove_sponsor(&mut self) -> DispatchResult {
+		self.collection.sponsorship = SponsorshipState::Disabled;
+		Ok(())
+	}
+
 	/// Checks that the collection was created with, and must be operated upon through **Unique API**.
 	/// Now check only the `external_collection` flag and if it's **true**, then return [`Error::CollectionIsExternal`] error.
 	pub fn check_is_internal(&self) -> DispatchResult {
@@ -732,12 +738,7 @@
 
 	/// Get the effective limits for the collection.
 	pub fn effective_collection_limits(collection: CollectionId) -> Option<CollectionLimits> {
-		let collection = <CollectionById<T>>::get(collection);
-		if collection.is_none() {
-			return None;
-		}
-
-		let collection = collection.unwrap();
+		let collection = <CollectionById<T>>::get(collection)?;
 		let limits = collection.limits;
 		let effective_limits = CollectionLimits {
 			account_token_ownership_limit: Some(limits.account_token_ownership_limit()),

--- a/pallets/fungible/src/erc.rs
+++ b/pallets/fungible/src/erc.rs
@@ -154,14 +154,14 @@
 		Collection(common_mut, CollectionHandle<T>),
 	)
 )]
-impl<T: Config> FungibleHandle<T> where T::AccountId: From<[u8; 32]> {}
+impl<T: Config> FungibleHandle<T> where T::AccountId: From<[u8; 32]> + AsRef<[u8]> {}
 
 generate_stubgen!(gen_impl, UniqueFungibleCall<()>, true);
 generate_stubgen!(gen_iface, UniqueFungibleCall<()>, false);
 
 impl<T: Config> CommonEvmHandler for FungibleHandle<T>
 where
-	T::AccountId: From<[u8; 32]>,
+	T::AccountId: From<[u8; 32]> + AsRef<[u8]>,
 {
 	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueFungible.raw");
 

--- a/pallets/nonfungible/src/erc.rs
+++ b/pallets/nonfungible/src/erc.rs
@@ -740,7 +740,7 @@
 		TokenProperties,
 	)
 )]
-impl<T: Config> NonfungibleHandle<T> where T::AccountId: From<[u8; 32]> {}
+impl<T: Config> NonfungibleHandle<T> where T::AccountId: From<[u8; 32]> + AsRef<[u8]> {}
 
 // Not a tests, but code generators
 generate_stubgen!(gen_impl, UniqueNFTCall<()>, true);
@@ -748,7 +748,7 @@
 
 impl<T: Config> CommonEvmHandler for NonfungibleHandle<T>
 where
-	T::AccountId: From<[u8; 32]>,
+	T::AccountId: From<[u8; 32]> + AsRef<[u8]>,
 {
 	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueNFT.raw");
 

--- a/pallets/refungible/src/erc.rs
+++ b/pallets/refungible/src/erc.rs
@@ -789,7 +789,7 @@
 		TokenProperties,
 	)
 )]
-impl<T: Config> RefungibleHandle<T> where T::AccountId: From<[u8; 32]> {}
+impl<T: Config> RefungibleHandle<T> where T::AccountId: From<[u8; 32]> + AsRef<[u8]> {}
 
 // Not a tests, but code generators
 generate_stubgen!(gen_impl, UniqueRefungibleCall<()>, true);
@@ -797,7 +797,7 @@
 
 impl<T: Config> CommonEvmHandler for RefungibleHandle<T>
 where
-	T::AccountId: From<[u8; 32]>,
+	T::AccountId: From<[u8; 32]> + AsRef<[u8]>,
 {
 	const CODE: &'static [u8] = include_bytes!("./stubs/UniqueRefungible.raw");
 	fn call(

--- a/runtime/common/dispatch.rs
+++ b/runtime/common/dispatch.rs
@@ -124,7 +124,7 @@
 		+ pallet_fungible::Config
 		+ pallet_nonfungible::Config
 		+ pallet_refungible::Config,
-	T::AccountId: From<[u8; 32]>,
+	T::AccountId: From<[u8; 32]> + AsRef<[u8]>,
 {
 	fn is_reserved(target: &H160) -> bool {
 		map_eth_to_id(target).is_some()

1import {addToAllowListExpectSuccess, confirmSponsorshipExpectSuccess, createCollectionExpectSuccess, enablePublicMintingExpectSuccess, getDetailedCollectionInfo, setCollectionSponsorExpectSuccess} from '../util/helpers';1import {addToAllowListExpectSuccess, confirmSponsorshipExpectSuccess, createCollectionExpectSuccess, enablePublicMintingExpectSuccess, getDetailedCollectionInfo, setCollectionSponsorExpectSuccess} from '../util/helpers';
2import {itWeb3, createEthAccount, collectionIdToAddress, GAS_ARGS, normalizeEvents, createEthAccountWithBalance, evmCollectionHelpers, getCollectionAddressFromResult, evmCollection, ethBalanceViaSub} from './util/helpers';2import {itWeb3, createEthAccount, collectionIdToAddress, GAS_ARGS, normalizeEvents, createEthAccountWithBalance, evmCollectionHelpers, getCollectionAddressFromResult, evmCollection, ethBalanceViaSub, subToEth} from './util/helpers';
3import nonFungibleAbi from './nonFungibleAbi.json';3import nonFungibleAbi from './nonFungibleAbi.json';
4import {expect} from 'chai';4import {expect} from 'chai';
5import {evmToAddress} from '@polkadot/util-crypto';5import {evmToAddress} from '@polkadot/util-crypto';
6import {submitTransactionAsync} from '../substrate/substrate-api';
7import getBalance from '../substrate/get-balance';
68
7describe('evm collection sponsoring', () => {9describe('evm collection sponsoring', () => {
8  itWeb3('sponsors mint transactions', async ({web3, privateKeyWrapper}) => {10  itWeb3('sponsors mint transactions', async ({web3, privateKeyWrapper}) => {
38    ]);40    ]);
39  });41  });
42
43  itWeb3('Set substrate sponsor', async ({api, web3, privateKeyWrapper}) => {
44    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
45    const collectionHelpers = evmCollectionHelpers(web3, owner);
46    let result = await collectionHelpers.methods.createNonfungibleCollection('Sponsor collection', '1', '1').send();
47    const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result);
48    const sponsor = privateKeyWrapper('//Alice');
49    const collectionEvm = evmCollection(web3, owner, collectionIdAddress);
50
51    expect(await collectionEvm.methods.hasCollectionPendingSponsor().call({from: owner})).to.be.false;
52    result = await collectionEvm.methods.setCollectionSponsorSubstrate(sponsor.addressRaw).send({from: owner});
53    expect(await collectionEvm.methods.hasCollectionPendingSponsor().call({from: owner})).to.be.true;
54    
55    const confirmTx = await api.tx.unique.confirmSponsorship(collectionId);
56    await submitTransactionAsync(sponsor, confirmTx);
57    expect(await collectionEvm.methods.hasCollectionPendingSponsor().call({from: owner})).to.be.false;
58    
59    const sponsorTuple = await collectionEvm.methods.getCollectionSponsor().call({from: owner});
60    expect(sponsorTuple.field_0).to.be.eq(subToEth(sponsor.address));
61  });
62
63  itWeb3('Remove sponsor', async ({api, web3, privateKeyWrapper}) => {
64    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
65    const collectionHelpers = evmCollectionHelpers(web3, owner);
66    let result = await collectionHelpers.methods.createNonfungibleCollection('Sponsor collection', '1', '1').send();
67    const {collectionIdAddress} = await getCollectionAddressFromResult(api, result);
68    const sponsor = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
69    const collectionEvm = evmCollection(web3, owner, collectionIdAddress);
70
71    expect(await collectionEvm.methods.hasCollectionPendingSponsor().call({from: owner})).to.be.false;
72    result = await collectionEvm.methods.setCollectionSponsor(sponsor).send({from: owner});
73    expect(await collectionEvm.methods.hasCollectionPendingSponsor().call({from: owner})).to.be.true;
74    
75    await collectionEvm.methods.confirmCollectionSponsorship().send({from: sponsor});
76    expect(await collectionEvm.methods.hasCollectionPendingSponsor().call({from: owner})).to.be.false;
77    
78    await collectionEvm.methods.removeCollectionSponsor().send({from: owner});
79    
80    const sponsorTuple = await collectionEvm.methods.getCollectionSponsor().call({from: owner});
81    expect(sponsorTuple.field_0).to.be.eq('0x0000000000000000000000000000000000000000');
82  });
4083
41  itWeb3('Sponsoring collection from evm address via access list', async ({api, web3, privateKeyWrapper}) => {84  itWeb3('Sponsoring collection from evm address via access list', async ({api, web3, privateKeyWrapper}) => {
42    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);85    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
107    }150    }
108  });151  });
152
153  itWeb3('Sponsoring collection from substrate address via access list', async ({api, web3, privateKeyWrapper}) => {
154    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);
155    const collectionHelpers = evmCollectionHelpers(web3, owner);
156    const result = await collectionHelpers.methods.createNonfungibleCollection('Sponsor collection', '1', '1').send();
157    const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result);
158    const sponsor = privateKeyWrapper('//Alice');
159    const collectionEvm = evmCollection(web3, owner, collectionIdAddress);
160
161    await collectionEvm.methods.setCollectionSponsorSubstrate(sponsor.addressRaw).send({from: owner});
162    
163    const confirmTx = await api.tx.unique.confirmSponsorship(collectionId);
164    await submitTransactionAsync(sponsor, confirmTx);
165    
166    const user = createEthAccount(web3);
167    const nextTokenId = await collectionEvm.methods.nextTokenId().call();
168    expect(nextTokenId).to.be.equal('1');
169
170    await collectionEvm.methods.setCollectionAccess(1 /*'AllowList'*/).send({from: owner});
171    await collectionEvm.methods.addToCollectionAllowList(user).send({from: owner});
172    await collectionEvm.methods.setCollectionMintMode(true).send({from: owner});
173
174    const ownerBalanceBefore = await ethBalanceViaSub(api, owner);
175    const sponsorBalanceBefore = (await getBalance(api, [sponsor.address]))[0];
176
177    {
178      const nextTokenId = await collectionEvm.methods.nextTokenId().call();
179      expect(nextTokenId).to.be.equal('1');
180      const result = await collectionEvm.methods.mintWithTokenURI(
181        user,
182        nextTokenId,
183        'Test URI',
184      ).send({from: user});
185      const events = normalizeEvents(result.events);
186
187      expect(events).to.be.deep.equal([
188        {
189          address: collectionIdAddress,
190          event: 'Transfer',
191          args: {
192            from: '0x0000000000000000000000000000000000000000',
193            to: user,
194            tokenId: nextTokenId,
195          },
196        },
197      ]);
198
199      const ownerBalanceAfter = await ethBalanceViaSub(api, owner);
200      const sponsorBalanceAfter = (await getBalance(api, [sponsor.address]))[0];
201
202      expect(await collectionEvm.methods.tokenURI(nextTokenId).call()).to.be.equal('Test URI');
203      expect(ownerBalanceBefore).to.be.eq(ownerBalanceAfter);
204      expect(sponsorBalanceBefore > sponsorBalanceAfter).to.be.true;
205    }
206  });
109207
110  itWeb3('Check that transaction via EVM spend money from sponsor address', async ({api, web3, privateKeyWrapper}) => {208  itWeb3('Check that transaction via EVM spend money from sponsor address', async ({api, web3, privateKeyWrapper}) => {
111    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);209    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);