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

difftreelog

path: Add some methods for manipulate collection sponsor via eth.

Trubnikov Sergey2022-08-24parent: #8684bc0.patch.diff
in: master

8 files changed

modifiedpallets/common/src/erc.rsdiffbeforeafterboth
--- 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:
modifiedpallets/common/src/eth.rsdiffbeforeafterboth
--- 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)
+}
modifiedpallets/common/src/lib.rsdiffbeforeafterboth
--- 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()),
modifiedpallets/fungible/src/erc.rsdiffbeforeafterboth
--- 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");
modifiedpallets/nonfungible/src/erc.rsdiffbeforeafterboth
--- 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");
modifiedpallets/refungible/src/erc.rsdiffbeforeafterboth
--- 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(
modifiedruntime/common/dispatch.rsdiffbeforeafterboth
--- 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()
modifiedtests/src/eth/collectionSponsoring.test.tsdiffbeforeafterboth
before · tests/src/eth/collectionSponsoring.test.ts
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';3import nonFungibleAbi from './nonFungibleAbi.json';4import {expect} from 'chai';5import {evmToAddress} from '@polkadot/util-crypto';67describe('evm collection sponsoring', () => {8  itWeb3('sponsors mint transactions', async ({web3, privateKeyWrapper}) => {9    const alice = privateKeyWrapper('//Alice');1011    const collection = await createCollectionExpectSuccess();12    await setCollectionSponsorExpectSuccess(collection, alice.address);13    await confirmSponsorshipExpectSuccess(collection);1415    const minter = createEthAccount(web3);16    expect(await web3.eth.getBalance(minter)).to.equal('0');1718    const address = collectionIdToAddress(collection);19    const contract = new web3.eth.Contract(nonFungibleAbi as any, collectionIdToAddress(collection), {from: minter, ...GAS_ARGS});2021    await enablePublicMintingExpectSuccess(alice, collection);22    await addToAllowListExpectSuccess(alice, collection, {Ethereum: minter});2324    const nextTokenId = await contract.methods.nextTokenId().call();25    expect(nextTokenId).to.equal('1');26    const result = await contract.methods.mint(minter, nextTokenId).send();27    const events = normalizeEvents(result.events);28    expect(events).to.be.deep.equal([29      {30        address,31        event: 'Transfer',32        args: {33          from: '0x0000000000000000000000000000000000000000',34          to: minter,35          tokenId: nextTokenId,36        },37      },38    ]);39  });4041  itWeb3('Sponsoring collection from evm address via access list', async ({api, web3, privateKeyWrapper}) => {42    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);43    const collectionHelpers = evmCollectionHelpers(web3, owner);44    let result = await collectionHelpers.methods.createNonfungibleCollection('Sponsor collection', '1', '1').send();45    const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result);46    const sponsor = await createEthAccountWithBalance(api, web3, privateKeyWrapper);47    const collectionEvm = evmCollection(web3, owner, collectionIdAddress);48    result = await collectionEvm.methods.setCollectionSponsor(sponsor).send({from: owner});49    let collectionSub = (await getDetailedCollectionInfo(api, collectionId))!;50    const ss58Format = (api.registry.getChainProperties())!.toJSON().ss58Format;51    expect(collectionSub.sponsorship.isUnconfirmed).to.be.true;52    expect(collectionSub.sponsorship.asUnconfirmed.toHuman()).to.be.eq(evmToAddress(sponsor, Number(ss58Format)));53    await expect(collectionEvm.methods.confirmCollectionSponsorship().call()).to.be.rejectedWith('caller is not set as sponsor');5455    await collectionEvm.methods.confirmCollectionSponsorship().send({from: sponsor});56    collectionSub = (await getDetailedCollectionInfo(api, collectionId))!;57    expect(collectionSub.sponsorship.isConfirmed).to.be.true;58    expect(collectionSub.sponsorship.asConfirmed.toHuman()).to.be.eq(evmToAddress(sponsor, Number(ss58Format)));5960    const user = createEthAccount(web3);61    const nextTokenId = await collectionEvm.methods.nextTokenId().call();62    expect(nextTokenId).to.be.equal('1');6364    const oldPermissions = (await getDetailedCollectionInfo(api, collectionId))!.permissions.toHuman();65    expect(oldPermissions.mintMode).to.be.false;66    expect(oldPermissions.access).to.be.equal('Normal');6768    await collectionEvm.methods.setCollectionAccess(1 /*'AllowList'*/).send({from: owner});69    await collectionEvm.methods.addToCollectionAllowList(user).send({from: owner});70    await collectionEvm.methods.setCollectionMintMode(true).send({from: owner});7172    const newPermissions = (await getDetailedCollectionInfo(api, collectionId))!.permissions.toHuman();73    expect(newPermissions.mintMode).to.be.true;74    expect(newPermissions.access).to.be.equal('AllowList');7576    const ownerBalanceBefore = await ethBalanceViaSub(api, owner);77    const sponsorBalanceBefore = await ethBalanceViaSub(api, sponsor);7879    {80      const nextTokenId = await collectionEvm.methods.nextTokenId().call();81      expect(nextTokenId).to.be.equal('1');82      const result = await collectionEvm.methods.mintWithTokenURI(83        user,84        nextTokenId,85        'Test URI',86      ).send({from: user});87      const events = normalizeEvents(result.events);8889      expect(events).to.be.deep.equal([90        {91          address: collectionIdAddress,92          event: 'Transfer',93          args: {94            from: '0x0000000000000000000000000000000000000000',95            to: user,96            tokenId: nextTokenId,97          },98        },99      ]);100101      const ownerBalanceAfter = await ethBalanceViaSub(api, owner);102      const sponsorBalanceAfter = await ethBalanceViaSub(api, sponsor);103104      expect(await collectionEvm.methods.tokenURI(nextTokenId).call()).to.be.equal('Test URI');105      expect(ownerBalanceBefore).to.be.eq(ownerBalanceAfter);106      expect(sponsorBalanceBefore > sponsorBalanceAfter).to.be.true;107    }108  });109110  itWeb3('Check that transaction via EVM spend money from sponsor address', async ({api, web3, privateKeyWrapper}) => {111    const owner = await createEthAccountWithBalance(api, web3, privateKeyWrapper);112    const collectionHelpers = evmCollectionHelpers(web3, owner);113    let result = await collectionHelpers.methods.createNonfungibleCollection('Sponsor collection', '1', '1').send();114    const {collectionIdAddress, collectionId} = await getCollectionAddressFromResult(api, result);115    const sponsor = await createEthAccountWithBalance(api, web3, privateKeyWrapper);116    const collectionEvm = evmCollection(web3, owner, collectionIdAddress);117    result = await collectionEvm.methods.setCollectionSponsor(sponsor).send();118    let collectionSub = (await getDetailedCollectionInfo(api, collectionId))!;119    const ss58Format = (api.registry.getChainProperties())!.toJSON().ss58Format;120    expect(collectionSub.sponsorship.isUnconfirmed).to.be.true;121    expect(collectionSub.sponsorship.asUnconfirmed.toHuman()).to.be.eq(evmToAddress(sponsor, Number(ss58Format)));122    await expect(collectionEvm.methods.confirmCollectionSponsorship().call()).to.be.rejectedWith('caller is not set as sponsor');123    const sponsorCollection = evmCollection(web3, sponsor, collectionIdAddress);124    await sponsorCollection.methods.confirmCollectionSponsorship().send();125    collectionSub = (await getDetailedCollectionInfo(api, collectionId))!;126    expect(collectionSub.sponsorship.isConfirmed).to.be.true;127    expect(collectionSub.sponsorship.asConfirmed.toHuman()).to.be.eq(evmToAddress(sponsor, Number(ss58Format)));128129    const user = createEthAccount(web3);130    await collectionEvm.methods.addCollectionAdmin(user).send();131    132    const ownerBalanceBefore = await ethBalanceViaSub(api, owner);133    const sponsorBalanceBefore = await ethBalanceViaSub(api, sponsor);134    135  136    const userCollectionEvm = evmCollection(web3, user, collectionIdAddress);137    const nextTokenId = await userCollectionEvm.methods.nextTokenId().call();138    expect(nextTokenId).to.be.equal('1');139    result = await userCollectionEvm.methods.mintWithTokenURI(140      user,141      nextTokenId,142      'Test URI',143    ).send();144145    const events = normalizeEvents(result.events);146    const address = collectionIdToAddress(collectionId);147148    expect(events).to.be.deep.equal([149      {150        address,151        event: 'Transfer',152        args: {153          from: '0x0000000000000000000000000000000000000000',154          to: user,155          tokenId: nextTokenId,156        },157      },158    ]);159    expect(await userCollectionEvm.methods.tokenURI(nextTokenId).call()).to.be.equal('Test URI');160  161    const ownerBalanceAfter = await ethBalanceViaSub(api, owner);162    expect(ownerBalanceAfter).to.be.eq(ownerBalanceBefore);163    const sponsorBalanceAfter = await ethBalanceViaSub(api, sponsor);164    expect(sponsorBalanceAfter < sponsorBalanceBefore).to.be.true;165  });166});