--- a/pallets/common/src/lib.rs +++ b/pallets/common/src/lib.rs @@ -746,6 +746,8 @@ ApprovedValueTooLow, /// Tried to approve more than owned CantApproveMoreThanOwned, + /// Only spending from eth mirror could be approved + AddressIsNotEthMirror, /// Can't transfer tokens to ethereum zero address AddressIsZero, @@ -1797,6 +1799,9 @@ /// The price of setting the permission of the operation from another user. fn approve() -> Weight; + /// The price of setting the permission of the operation from another user for eth mirror. + fn approve_from() -> Weight; + /// Transfer price from another user. fn transfer_from() -> Weight; @@ -2008,6 +2013,22 @@ amount: u128, ) -> DispatchResultWithPostInfo; + /// Grant access to another account to transfer parts of the token owned by the calling user's eth mirror via [Self::transfer_from]. + /// + /// * `sender` - The user who grants access to the token. + /// * `from` - Spender's eth mirror. + /// * `to` - The user to whom the rights are granted. + /// * `token` - The token to which access is granted. + /// * `amount` - The amount of pieces that another user can dispose of. + fn approve_from( + &self, + sender: T::CrossAccountId, + from: T::CrossAccountId, + to: T::CrossAccountId, + token: TokenId, + amount: u128, + ) -> DispatchResultWithPostInfo; + /// Send parts of a token owned by another user. /// /// Before calling this method, you must grant rights to the calling user via [`Self::approve`]. --- a/pallets/evm-contract-helpers/src/stubs/ContractHelpers.sol +++ b/pallets/evm-contract-helpers/src/stubs/ContractHelpers.sol @@ -283,8 +283,8 @@ /// Ethereum representation of Optional value with CrossAddress. struct OptionCrossAddress { - /// TODO: field description + /// Whether or not this CrossAdress is valid and has meaning. bool status; - /// TODO: field description + /// The underlying CrossAddress value. If the status is false, can be set to whatever. CrossAddress value; } --- a/pallets/fungible/src/benchmarking.rs +++ b/pallets/fungible/src/benchmarking.rs @@ -82,6 +82,16 @@ >::create_item(&collection, &owner, (sender.clone(), 200), &Unlimited)?; }: {>::set_allowance(&collection, &sender, &spender, 100)?} + approve_from { + bench_init!{ + owner: sub; collection: collection(owner); + owner: cross_from_sub; sender: cross_sub; spender: cross_sub; + + }; + let owner_eth = T::CrossAccountId::from_eth(*sender.as_eth()); + >::create_item(&collection, &owner, (owner_eth.clone(), 200), &Unlimited)?; + }: {>::set_allowance_from(&collection, &sender, &owner_eth, &spender, 100)?} + transfer_from { bench_init!{ owner: sub; collection: collection(owner); --- a/pallets/fungible/src/common.rs +++ b/pallets/fungible/src/common.rs @@ -87,6 +87,10 @@ >::approve() } + fn approve_from() -> Weight { + >::approve_from() + } + fn transfer_from() -> Weight { >::transfer_from() } @@ -254,6 +258,25 @@ ) } + fn approve_from( + &self, + sender: T::CrossAccountId, + from: T::CrossAccountId, + to: T::CrossAccountId, + token: TokenId, + amount: u128, + ) -> DispatchResultWithPostInfo { + ensure!( + token == TokenId::default(), + >::FungibleItemsHaveNoId + ); + + with_weight( + >::set_allowance_from(self, &sender, &from, &to, amount), + >::approve_from(), + ) + } + fn transfer_from( &self, sender: T::CrossAccountId, --- a/pallets/fungible/src/lib.rs +++ b/pallets/fungible/src/lib.rs @@ -613,6 +613,45 @@ Ok(()) } + /// Set allowance for the spender to `transfer` or `burn` owner's tokens from eth mirror. + /// + /// - `collection`: Collection that contains the token + /// - `sender`: Owner of tokens that sets the allowance. + /// - `from`: Owner's eth mirror. + /// - `to`: Recipient of the allowance rights. + /// - `amount`: Amount of tokens the spender is allowed to `transfer` or `burn`. + pub fn set_allowance_from( + collection: &FungibleHandle, + sender: &T::CrossAccountId, + from: &T::CrossAccountId, + to: &T::CrossAccountId, + amount: u128, + ) -> DispatchResult { + if collection.permissions.access() == AccessMode::AllowList { + collection.check_allowlist(sender)?; + collection.check_allowlist(from)?; + collection.check_allowlist(to)?; + } + + ensure!( + sender.conv_eq(from), + >::AddressIsNotEthMirror + ); + + if >::get((collection.id, from)) < amount { + ensure!( + collection.limits.owner_can_transfer() + && (collection.is_owner_or_admin(sender) || collection.is_owner_or_admin(from)), + >::CantApproveMoreThanOwned + ); + } + + // ========= + + Self::set_allowance_unchecked(collection, from, to, amount); + Ok(()) + } + /// Checks if a non-owner has (enough) allowance from the owner to perform operations on the tokens. /// Returns the expected remaining allowance - it should be set manually if the transaction proceeds. /// --- a/pallets/fungible/src/weights.rs +++ b/pallets/fungible/src/weights.rs @@ -39,6 +39,7 @@ fn burn_item() -> Weight; fn transfer() -> Weight; fn approve() -> Weight; + fn approve_from() -> Weight; fn transfer_from() -> Weight; fn burn_from() -> Weight; } @@ -84,6 +85,13 @@ .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } + // Storage: Fungible Balance (r:1 w:0) + // Storage: Fungible Allowance (r:0 w:1) + fn approve_from() -> Weight { + Weight::from_ref_time(19_817_000 as u64) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } // Storage: Fungible Allowance (r:1 w:1) // Storage: Fungible Balance (r:2 w:2) fn transfer_from() -> Weight { @@ -141,6 +149,13 @@ .saturating_add(RocksDbWeight::get().reads(1 as u64)) .saturating_add(RocksDbWeight::get().writes(1 as u64)) } + // Storage: Fungible Balance (r:1 w:0) + // Storage: Fungible Allowance (r:0 w:1) + fn approve_from() -> Weight { + Weight::from_ref_time(19_817_000 as u64) + .saturating_add(RocksDbWeight::get().reads(1 as u64)) + .saturating_add(RocksDbWeight::get().writes(1 as u64)) + } // Storage: Fungible Allowance (r:1 w:1) // Storage: Fungible Balance (r:2 w:2) fn transfer_from() -> Weight { --- a/pallets/nonfungible/src/benchmarking.rs +++ b/pallets/nonfungible/src/benchmarking.rs @@ -134,6 +134,15 @@ let item = create_max_item(&collection, &owner, sender.clone())?; }: {>::set_allowance(&collection, &sender, item, Some(&spender))?} + approve_from { + bench_init!{ + owner: sub; collection: collection(owner); + owner: cross_from_sub; sender: cross_sub; spender: cross_sub; + }; + let owner_eth = T::CrossAccountId::from_eth(*sender.as_eth()); + let item = create_max_item(&collection, &owner, owner_eth.clone())?; + }: {>::set_allowance_from(&collection, &sender, &owner_eth, item, Some(&spender))?} + transfer_from { bench_init!{ owner: sub; collection: collection(owner); --- a/pallets/nonfungible/src/common.rs +++ b/pallets/nonfungible/src/common.rs @@ -102,6 +102,10 @@ >::approve() } + fn approve_from() -> Weight { + >::approve_from() + } + fn transfer_from() -> Weight { >::transfer_from() } @@ -353,6 +357,26 @@ ) } + fn approve_from( + &self, + sender: T::CrossAccountId, + from: T::CrossAccountId, + to: T::CrossAccountId, + token: TokenId, + amount: u128, + ) -> DispatchResultWithPostInfo { + ensure!(amount <= 1, >::NonfungibleItemsHaveNoAmount); + + with_weight( + if amount == 1 { + >::set_allowance_from(self, &sender, &from, token, Some(&to)) + } else { + >::set_allowance_from(self, &sender, &from, token, None) + }, + >::approve_from(), + ) + } + fn transfer_from( &self, sender: T::CrossAccountId, --- a/pallets/nonfungible/src/lib.rs +++ b/pallets/nonfungible/src/lib.rs @@ -1171,6 +1171,51 @@ Ok(()) } + /// Set allowance for the spender to `transfer` or `burn` sender's token from eth mirror. + /// + /// - `from`: Address of sender's eth mirror. + /// - `to`: Adress of spender. + /// - `token`: Token the spender is allowed to `transfer` or `burn`. + pub fn set_allowance_from( + collection: &NonfungibleHandle, + sender: &T::CrossAccountId, + from: &T::CrossAccountId, + token: TokenId, + to: Option<&T::CrossAccountId>, + ) -> DispatchResult { + if collection.permissions.access() == AccessMode::AllowList { + collection.check_allowlist(sender)?; + collection.check_allowlist(from)?; + if let Some(to) = to { + collection.check_allowlist(to)?; + } + } + + if let Some(to) = to { + >::ensure_correct_receiver(to)?; + } + + ensure!( + sender.conv_eq(from), + >::AddressIsNotEthMirror + ); + + let token_data = + >::get((collection.id, token)).ok_or(>::TokenNotFound)?; + if token_data.owner != *from { + ensure!( + collection.limits.owner_can_transfer() + && (collection.is_owner_or_admin(sender) || collection.is_owner_or_admin(from)), + >::CantApproveMoreThanOwned + ); + } + + // ========= + + Self::set_allowance_unchecked(collection, from, token, to, false); + Ok(()) + } + /// Checks allowance for the spender to use the token. fn check_allowed( collection: &NonfungibleHandle, --- a/pallets/nonfungible/src/weights.rs +++ b/pallets/nonfungible/src/weights.rs @@ -42,6 +42,7 @@ fn burn_recursively_breadth_plus_self_plus_self_per_each_raw(b: u32, ) -> Weight; fn transfer() -> Weight; fn approve() -> Weight; + fn approve_from() -> Weight; fn transfer_from() -> Weight; fn burn_from() -> Weight; fn set_token_property_permissions(b: u32, ) -> Weight; @@ -147,6 +148,13 @@ .saturating_add(T::DbWeight::get().reads(2 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } + // Storage: Nonfungible TokenData (r:1 w:0) + // Storage: Nonfungible Allowance (r:1 w:1) + fn approve_from() -> Weight { + Weight::from_ref_time(18_965_000 as u64) + .saturating_add(T::DbWeight::get().reads(2 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } // Storage: Nonfungible Allowance (r:1 w:1) // Storage: Nonfungible TokenData (r:1 w:1) // Storage: Nonfungible AccountBalance (r:2 w:2) @@ -310,6 +318,13 @@ .saturating_add(RocksDbWeight::get().reads(2 as u64)) .saturating_add(RocksDbWeight::get().writes(1 as u64)) } + // Storage: Nonfungible TokenData (r:1 w:0) + // Storage: Nonfungible Allowance (r:1 w:1) + fn approve_from() -> Weight { + Weight::from_ref_time(18_965_000 as u64) + .saturating_add(RocksDbWeight::get().reads(2 as u64)) + .saturating_add(RocksDbWeight::get().writes(1 as u64)) + } // Storage: Nonfungible Allowance (r:1 w:1) // Storage: Nonfungible TokenData (r:1 w:1) // Storage: Nonfungible AccountBalance (r:2 w:2) --- a/pallets/refungible/src/benchmarking.rs +++ b/pallets/refungible/src/benchmarking.rs @@ -163,6 +163,15 @@ let item = create_max_item(&collection, &owner, [(sender.clone(), 200)])?; }: {>::set_allowance(&collection, &sender, &spender, item, 100)?} + approve_from { + bench_init!{ + owner: sub; collection: collection(owner); + owner: cross_from_sub; sender: cross_sub; spender: cross_sub; + }; + let owner_eth = T::CrossAccountId::from_eth(*sender.as_eth()); + let item = create_max_item(&collection, &owner, [(owner_eth.clone(), 200)])?; + }: {>::set_allowance_from(&collection, &sender, &owner_eth, &spender, item, 100)?} + transfer_from_normal { bench_init!{ owner: sub; collection: collection(owner); --- a/pallets/refungible/src/common.rs +++ b/pallets/refungible/src/common.rs @@ -127,6 +127,10 @@ >::approve() } + fn approve_from() -> Weight { + >::approve_from() + } + fn transfer_from() -> Weight { max_weight_of!( transfer_from_normal(), @@ -314,6 +318,20 @@ ) } + fn approve_from( + &self, + sender: T::CrossAccountId, + from: T::CrossAccountId, + to: T::CrossAccountId, + token_id: TokenId, + amount: u128, + ) -> DispatchResultWithPostInfo { + with_weight( + >::set_allowance_from(self, &sender, &from, &to, token_id, amount), + >::approve_from(), + ) + } + fn transfer_from( &self, sender: T::CrossAccountId, --- a/pallets/refungible/src/lib.rs +++ b/pallets/refungible/src/lib.rs @@ -1102,6 +1102,47 @@ Ok(()) } + /// Set allowance to spend from sender's eth mirror + /// + /// - `from`: Address of sender's eth mirror. + /// - `to`: Adress of spender. + /// - `amount`: Amount of token pieces the spender is allowed to `transfer` or `burn. + pub fn set_allowance_from( + collection: &RefungibleHandle, + sender: &T::CrossAccountId, + from: &T::CrossAccountId, + to: &T::CrossAccountId, + token_id: TokenId, + amount: u128, + ) -> DispatchResult { + if collection.permissions.access() == AccessMode::AllowList { + collection.check_allowlist(sender)?; + collection.check_allowlist(from)?; + collection.check_allowlist(to)?; + } + + >::ensure_correct_receiver(to)?; + + ensure!( + sender.conv_eq(from), + >::AddressIsNotEthMirror + ); + + if >::get((collection.id, token_id, from)) < amount { + ensure!( + collection.limits.owner_can_transfer() + && (collection.is_owner_or_admin(sender) || collection.is_owner_or_admin(from)) + && Self::token_exists(collection, token_id), + >::CantApproveMoreThanOwned + ); + } + + // ========= + + Self::set_allowance_unchecked(collection, from, to, token_id, amount); + Ok(()) + } + /// Returns allowance, which should be set after transaction fn check_allowed( collection: &RefungibleHandle, --- a/pallets/refungible/src/weights.rs +++ b/pallets/refungible/src/weights.rs @@ -45,6 +45,7 @@ fn transfer_removing() -> Weight; fn transfer_creating_removing() -> Weight; fn approve() -> Weight; + fn approve_from() -> Weight; fn transfer_from_normal() -> Weight; fn transfer_from_creating() -> Weight; fn transfer_from_removing() -> Weight; @@ -175,6 +176,13 @@ .saturating_add(T::DbWeight::get().reads(1 as u64)) .saturating_add(T::DbWeight::get().writes(1 as u64)) } + // Storage: Refungible Balance (r:1 w:0) + // Storage: Refungible Allowance (r:0 w:1) + fn approve_from() -> Weight { + Weight::from_ref_time(20_649_000 as u64) + .saturating_add(T::DbWeight::get().reads(1 as u64)) + .saturating_add(T::DbWeight::get().writes(1 as u64)) + } // Storage: Refungible Allowance (r:1 w:1) // Storage: Refungible CollectionAllowance (r:1 w:0) // Storage: Refungible Balance (r:2 w:2) @@ -400,6 +408,13 @@ .saturating_add(RocksDbWeight::get().reads(1 as u64)) .saturating_add(RocksDbWeight::get().writes(1 as u64)) } + // Storage: Refungible Balance (r:1 w:0) + // Storage: Refungible Allowance (r:0 w:1) + fn approve_from() -> Weight { + Weight::from_ref_time(20_649_000 as u64) + .saturating_add(RocksDbWeight::get().reads(1 as u64)) + .saturating_add(RocksDbWeight::get().writes(1 as u64)) + } // Storage: Refungible Allowance (r:1 w:1) // Storage: Refungible CollectionAllowance (r:1 w:0) // Storage: Refungible Balance (r:2 w:2) --- a/pallets/unique/src/lib.rs +++ b/pallets/unique/src/lib.rs @@ -851,6 +851,29 @@ dispatch_tx::(collection_id, |d| d.approve(sender, spender, item_id, amount)) } + /// Allow a non-permissioned address to transfer or burn an item from owner's eth mirror. + /// + /// # Permissions + /// + /// * Collection owner + /// * Collection admin + /// * Current item owner + /// + /// # Arguments + /// + /// * `from`: Owner's account eth mirror + /// * `to`: Account to be approved to make specific transactions on non-owned tokens. + /// * `collection_id`: ID of the collection the item belongs to. + /// * `item_id`: ID of the item transactions on which are now approved. + /// * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs). + /// Set to 0 to revoke the approval. + #[weight = T::CommonWeightInfo::approve_from()] + pub fn approve_from(origin, from:T::CrossAccountId, to: T::CrossAccountId, collection_id: CollectionId, item_id: TokenId, amount: u128) -> DispatchResultWithPostInfo { + let sender = T::CrossAccountId::from_sub(ensure_signed(origin)?); + + dispatch_tx::(collection_id, |d| d.approve_from(sender, from, to, item_id, amount)) + } + /// Change ownership of an item on behalf of the owner as a non-owner account. /// /// See the [`approve`][`Pallet::approve`] method for additional information. --- a/runtime/common/identity.rs +++ b/runtime/common/identity.rs @@ -23,6 +23,8 @@ traits::{DispatchInfoOf, SignedExtension}, transaction_validity::{TransactionValidity, ValidTransaction, TransactionValidityError}, }; +#[cfg(feature = "collator-selection")] +use sp_runtime::transaction_validity::InvalidTransaction; #[cfg(feature = "collator-selection")] use sp_runtime::transaction_validity::InvalidTransaction; --- a/runtime/common/weights.rs +++ b/runtime/common/weights.rs @@ -101,6 +101,10 @@ dispatch_weight::() + max_weight_of!(approve()) } + fn approve_from() -> Weight { + dispatch_weight::() + max_weight_of!(approve_from()) + } + fn transfer_from() -> Weight { dispatch_weight::() + max_weight_of!(transfer_from()) } --- a/tests/src/approve.test.ts +++ b/tests/src/approve.test.ts @@ -16,336 +16,521 @@ import {IKeyringPair} from '@polkadot/types/types'; import {expect, itSub, Pallets, usingPlaygrounds} from './util'; +import {CrossAccountId} from './util/playgrounds/unique'; + -describe('Integration Test approve(spender, collection_id, item_id, amount):', () => { - let alice: IKeyringPair; - let bob: IKeyringPair; - let charlie: IKeyringPair; +[ + {method: 'approveToken', account: (account: IKeyringPair) => CrossAccountId.fromKeyring(account)}, + {method: 'approveTokenFromEth', account: (account: IKeyringPair) => CrossAccountId.fromKeyring(account).toEthereum()}, +].map(testCase => { + describe(`Integration Test ${testCase.method}(spender, collection_id, item_id, amount):`, () => { + let alice: IKeyringPair; + let bob: IKeyringPair; + let charlie: IKeyringPair; - before(async () => { - await usingPlaygrounds(async (helper, privateKey) => { - const donor = await privateKey({filename: __filename}); - [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor); + before(async () => { + await usingPlaygrounds(async (helper, privateKey) => { + const donor = await privateKey({filename: __filename}); + [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor); + }); }); - }); - itSub('[nft] Execute the extrinsic and check approvedList', async ({helper}) => { - const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address}); - await helper.nft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}); - expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.true; - }); + itSub('[nft] Execute the extrinsic and check approvedList', async ({helper}) => { + const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(alice)}); + await (helper.nft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}); + expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.true; + }); + + itSub('[fungible] Execute the extrinsic and check approvedList', async ({helper}) => { + const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0); + await helper.ft.mintTokens(alice, collectionId, 10n, testCase.account(alice)); + const tokenId = await helper.ft.getLastTokenId(collectionId); + await (helper.ft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}); + const amount = await helper.ft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, testCase.account(alice)); + expect(amount).to.be.equal(BigInt(1)); + }); + + itSub.ifWithPallets('[refungible] Execute the extrinsic and check approvedList', [Pallets.ReFungible], async ({helper}) => { + const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(alice), pieces: 100n}); + await (helper.rft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}); + const amount = await helper.rft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, testCase.account(alice)); + expect(amount).to.be.equal(BigInt(1)); + }); + + itSub('[nft] Remove approval by using 0 amount', async ({helper}) => { + const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + const collectionId = collection.collectionId; + const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(alice)}); + await (helper.nft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}); + expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.true; + await (helper.nft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}, 0n); + expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.false; + }); - itSub('[fungible] Execute the extrinsic and check approvedList', async ({helper}) => { - const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0); - await helper.ft.mintTokens(alice, collectionId, 10n, {Substrate: alice.address}); - const tokenId = await helper.ft.getLastTokenId(collectionId); - await helper.ft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}); - const amount = await helper.ft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}); - expect(amount).to.be.equal(BigInt(1)); - }); + itSub('[fungible] Remove approval by using 0 amount', async ({helper}) => { + const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0); + await helper.ft.mintTokens(alice, collectionId, 10n, testCase.account(alice)); + const tokenId = await helper.ft.getLastTokenId(collectionId); + await (helper.ft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}); + const amountBefore = await helper.ft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, testCase.account(alice)); + expect(amountBefore).to.be.equal(BigInt(1)); - itSub.ifWithPallets('[refungible] Execute the extrinsic and check approvedList', [Pallets.ReFungible], async ({helper}) => { - const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: alice.address, pieces: 100n}); - await helper.rft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}); - const amount = await helper.rft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}); - expect(amount).to.be.equal(BigInt(1)); - }); + await (helper.ft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}, 0n); + const amountAfter = await helper.ft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, testCase.account(alice)); + expect(amountAfter).to.be.equal(BigInt(0)); + }); - itSub('[nft] Remove approval by using 0 amount', async ({helper}) => { - const collection = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - const collectionId = collection.collectionId; - const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address}); - await helper.nft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}); - expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.true; - await helper.signTransaction(alice, helper.constructApiCall('api.tx.unique.approve', [{Substrate: bob.address}, collectionId, tokenId, 0])); - expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.false; - }); + itSub.ifWithPallets('[refungible] Remove approval by using 0 amount', [Pallets.ReFungible], async ({helper}) => { + const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(alice), pieces: 100n}); + await (helper.rft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}); + const amountBefore = await helper.rft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, testCase.account(alice)); + expect(amountBefore).to.be.equal(BigInt(1)); - itSub('[fungible] Remove approval by using 0 amount', async ({helper}) => { - const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0); - await helper.ft.mintTokens(alice, collectionId, 10n, {Substrate: alice.address}); - const tokenId = await helper.ft.getLastTokenId(collectionId); - await helper.ft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}); - const amountBefore = await helper.ft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}); - expect(amountBefore).to.be.equal(BigInt(1)); + await (helper.rft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}, 0n); + const amountAfter = await helper.rft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, testCase.account(alice)); + expect(amountAfter).to.be.equal(BigInt(0)); + }); - await helper.ft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}, 0n); - const amountAfter = await helper.ft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}); - expect(amountAfter).to.be.equal(BigInt(0)); + itSub('can`t be called by collection owner on non-owned item when OwnerCanTransfer == false', async ({helper}) => { + const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(bob)}); + const result = (helper.nft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: charlie.address}); + await expect(result).to.be.rejected; + }); }); - itSub.ifWithPallets('[refungible] Remove approval by using 0 amount', [Pallets.ReFungible], async ({helper}) => { - const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: alice.address, pieces: 100n}); - await helper.rft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}); - const amountBefore = await helper.rft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}); - expect(amountBefore).to.be.equal(BigInt(1)); + describe(`[${testCase.method}] Normal user can approve other users to transfer:`, () => { + let alice: IKeyringPair; + let bob: IKeyringPair; + let charlie: IKeyringPair; - await helper.rft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}, 0n); - const amountAfter = await helper.rft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}); - expect(amountAfter).to.be.equal(BigInt(0)); - }); + before(async () => { + await usingPlaygrounds(async (helper, privateKey) => { + const donor = await privateKey({filename: __filename}); + [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor); + }); + }); - itSub('can`t be called by collection owner on non-owned item when OwnerCanTransfer == false', async ({helper}) => { - const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address}); - const approveTokenTx = () => helper.nft.approveToken(alice, collectionId, tokenId, {Substrate: charlie.address}); - await expect(approveTokenTx()).to.be.rejected; - }); -}); + itSub('NFT', async ({helper}) => { + const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(bob)}); + await (helper.nft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: charlie.address}); + expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: charlie.address})).to.be.true; + }); -describe('Normal user can approve other users to transfer:', () => { - let alice: IKeyringPair; - let bob: IKeyringPair; - let charlie: IKeyringPair; + itSub('Fungible up to an approved amount', async ({helper}) => { + const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0); + await helper.ft.mintTokens(alice, collectionId, 10n, testCase.account(bob)); + const tokenId = await helper.ft.getLastTokenId(collectionId); + await (helper.ft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: charlie.address}); + const amount = await helper.ft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: charlie.address}, testCase.account(bob)); + expect(amount).to.be.equal(BigInt(1)); + }); - before(async () => { - await usingPlaygrounds(async (helper, privateKey) => { - const donor = await privateKey({filename: __filename}); - [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor); + itSub.ifWithPallets('ReFungible up to an approved amount', [Pallets.ReFungible], async ({helper}) => { + const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(bob), pieces: 100n}); + await (helper.rft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: charlie.address}, 100n); + const amount = await helper.rft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: charlie.address}, testCase.account(bob)); + expect(amount).to.be.equal(BigInt(100n)); }); }); - itSub('NFT', async ({helper}) => { - const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address}); - await helper.nft.approveToken(bob, collectionId, tokenId, {Substrate: charlie.address}); - expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: charlie.address})).to.be.true; - }); + describe(`[${testCase.method}] Approved users can transferFrom up to approved amount:`, () => { + let alice: IKeyringPair; + let bob: IKeyringPair; + let charlie: IKeyringPair; - itSub('Fungible up to an approved amount', async ({helper}) => { - const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0); - await helper.ft.mintTokens(alice, collectionId, 10n, bob.address); - const tokenId = await helper.ft.getLastTokenId(collectionId); - await helper.ft.approveToken(bob, collectionId, tokenId, {Substrate: charlie.address}); - const amount = await helper.ft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: charlie.address}, {Substrate: bob.address}); - expect(amount).to.be.equal(BigInt(1)); - }); + before(async () => { + await usingPlaygrounds(async (helper, privateKey) => { + const donor = await privateKey({filename: __filename}); + [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor); + }); + }); - itSub.ifWithPallets('ReFungible up to an approved amount', [Pallets.ReFungible], async ({helper}) => { - const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: bob.address, pieces: 100n}); - await helper.rft.approveToken(bob, collectionId, tokenId, {Substrate: charlie.address}, 100n); - const amount = await helper.rft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: charlie.address}, {Substrate: bob.address}); - expect(amount).to.be.equal(BigInt(100n)); + itSub('NFT', async ({helper}) => { + const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(bob)}); + await (helper.nft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: charlie.address}); + await helper.nft.transferTokenFrom(charlie, collectionId, tokenId, testCase.account(bob), {Substrate: alice.address}); + const owner = await helper.nft.getTokenOwner(collectionId, tokenId); + expect(owner.Substrate).to.be.equal(alice.address); + }); + + itSub('Fungible up to an approved amount', async ({helper}) => { + const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0); + await helper.ft.mintTokens(alice, collectionId, 10n, testCase.account(bob)); + const tokenId = await helper.ft.getLastTokenId(collectionId); + await (helper.ft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: charlie.address}); + const before = await helper.ft.getBalance(collectionId, {Substrate: alice.address}); + await helper.ft.transferTokenFrom(charlie, collectionId, tokenId, testCase.account(bob), {Substrate: alice.address}, 1n); + const after = await helper.ft.getBalance(collectionId, {Substrate: alice.address}); + expect(after - before).to.be.equal(BigInt(1)); + }); + + itSub.ifWithPallets('ReFungible up to an approved amount', [Pallets.ReFungible], async ({helper}) => { + const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(bob), pieces: 100n}); + await (helper.rft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: charlie.address}); + const before = await helper.rft.getTokenBalance(collectionId, tokenId, {Substrate: alice.address}); + await helper.rft.transferTokenFrom(charlie, collectionId, tokenId, testCase.account(bob), {Substrate: alice.address}, 1n); + const after = await helper.rft.getTokenBalance(collectionId, tokenId, {Substrate: alice.address}); + expect(after - before).to.be.equal(BigInt(1)); + }); }); -}); -describe('Approved users can transferFrom up to approved amount:', () => { - let alice: IKeyringPair; - let bob: IKeyringPair; - let charlie: IKeyringPair; + describe(`[${testCase.method}] Approved users cannot use transferFrom to repeat transfers if approved amount was already transferred:`, () => { + let alice: IKeyringPair; + let bob: IKeyringPair; + let charlie: IKeyringPair; + + before(async () => { + await usingPlaygrounds(async (helper, privateKey) => { + const donor = await privateKey({filename: __filename}); + [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor); + }); + }); + + itSub('NFT', async ({helper}) => { + const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(bob)}); + await (helper.nft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: charlie.address}); + await helper.nft.transferTokenFrom(charlie, collectionId, tokenId, testCase.account(bob), {Substrate: alice.address}); + const owner = await helper.nft.getTokenOwner(collectionId, tokenId); + expect(owner.Substrate).to.be.equal(alice.address); + const transferTokenFromTx = () => helper.nft.transferTokenFrom(charlie, collectionId, tokenId, testCase.account(bob), {Substrate: alice.address}); + await expect(transferTokenFromTx()).to.be.rejected; + }); + + itSub('Fungible up to an approved amount', async ({helper}) => { + const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0); + await helper.ft.mintTokens(alice, collectionId, 10n, testCase.account(bob)); + const tokenId = await helper.ft.getLastTokenId(collectionId); + await (helper.ft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: charlie.address}); + const before = await helper.ft.getBalance(collectionId, {Substrate: alice.address}); + await helper.ft.transferTokenFrom(charlie, collectionId, tokenId, testCase.account(bob), {Substrate: alice.address}, 1n); + const after = await helper.ft.getBalance(collectionId, {Substrate: alice.address}); + expect(after - before).to.be.equal(BigInt(1)); + + const transferTokenFromTx = () => helper.ft.transferTokenFrom(charlie, collectionId, tokenId, testCase.account(bob), {Substrate: alice.address}, 1n); + await expect(transferTokenFromTx()).to.be.rejected; + }); - before(async () => { - await usingPlaygrounds(async (helper, privateKey) => { - const donor = await privateKey({filename: __filename}); - [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor); + itSub.ifWithPallets('ReFungible up to an approved amount', [Pallets.ReFungible], async ({helper}) => { + const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(bob), pieces: 100n}); + await (helper.ft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: charlie.address}, 100n); + const before = await helper.rft.getTokenBalance(collectionId, tokenId, {Substrate: alice.address}); + await helper.rft.transferTokenFrom(charlie, collectionId, tokenId, testCase.account(bob), {Substrate: alice.address}, 100n); + const after = await helper.rft.getTokenBalance(collectionId, tokenId, {Substrate: alice.address}); + expect(after - before).to.be.equal(BigInt(100)); + const transferTokenFromTx = () => helper.rft.transferTokenFrom(charlie, collectionId, tokenId, testCase.account(bob), {Substrate: alice.address}, 100n); + await expect(transferTokenFromTx()).to.be.rejected; }); }); - itSub('NFT', async ({helper}) => { - const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address}); - await helper.nft.approveToken(bob, collectionId, tokenId, {Substrate: charlie.address}); - await helper.nft.transferTokenFrom(charlie, collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}); - const owner = await helper.nft.getTokenOwner(collectionId, tokenId); - expect(owner.Substrate).to.be.equal(alice.address); + describe(`[${testCase.method}] Approved amount decreases by the transferred amount:`, () => { + let alice: IKeyringPair; + let bob: IKeyringPair; + let charlie: IKeyringPair; + let dave: IKeyringPair; + + before(async () => { + await usingPlaygrounds(async (helper, privateKey) => { + const donor = await privateKey({filename: __filename}); + [alice, bob, charlie, dave] = await helper.arrange.createAccounts([100n, 100n, 100n, 100n], donor); + }); + }); + + itSub('If a user B is approved to transfer 10 Fungible tokens from user A, they can transfer 2 tokens to user C, which will result in decreasing approval from 10 to 8. Then user B can transfer 8 tokens to user D.', async ({helper}) => { + const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0); + await helper.ft.mintTokens(alice, collectionId, 10n, testCase.account(alice)); + const tokenId = await helper.ft.getLastTokenId(collectionId); + await (helper.ft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}, 10n); + + const charlieBefore = await helper.ft.getBalance(collectionId, {Substrate: charlie.address}); + await helper.ft.transferTokenFrom(bob, collectionId, tokenId, testCase.account(alice), {Substrate: charlie.address}, 2n); + const charlieAfter = await helper.ft.getBalance(collectionId, {Substrate: charlie.address}); + expect(charlieAfter - charlieBefore).to.be.equal(BigInt(2)); + + const daveBefore = await helper.ft.getBalance(collectionId, {Substrate: dave.address}); + await helper.ft.transferTokenFrom(bob, collectionId, tokenId, testCase.account(alice), {Substrate: dave.address}, 8n); + const daveAfter = await helper.ft.getBalance(collectionId, {Substrate: dave.address}); + expect(daveAfter - daveBefore).to.be.equal(BigInt(8)); + }); }); - itSub('Fungible up to an approved amount', async ({helper}) => { - const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0); - await helper.ft.mintTokens(alice, collectionId, 10n, bob.address); - const tokenId = await helper.ft.getLastTokenId(collectionId); - await helper.ft.approveToken(bob, collectionId, tokenId, {Substrate: charlie.address}); - const before = await helper.ft.getBalance(collectionId, {Substrate: alice.address}); - await helper.ft.transferTokenFrom(charlie, collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}, 1n); - const after = await helper.ft.getBalance(collectionId, {Substrate: alice.address}); - expect(after - before).to.be.equal(BigInt(1)); + describe(`[${testCase.method}] User may clear the approvals to approving for 0 amount:`, () => { + let alice: IKeyringPair; + let bob: IKeyringPair; + let charlie: IKeyringPair; + + before(async () => { + await usingPlaygrounds(async (helper, privateKey) => { + const donor = await privateKey({filename: __filename}); + [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor); + }); + }); + + itSub('NFT', async ({helper}) => { + const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(alice)}); + await (helper.nft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}); + expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.true; + await (helper.nft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}, 0n); + expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.false; + const transferTokenFromTx = () => helper.nft.transferTokenFrom(bob, collectionId, tokenId, {Substrate: bob.address}, {Substrate: bob.address}); + await expect(transferTokenFromTx()).to.be.rejected; + }); + + itSub('Fungible', async ({helper}) => { + const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0); + await helper.ft.mintTokens(alice, collectionId, 10n, testCase.account(alice)); + const tokenId = await helper.ft.getLastTokenId(collectionId); + await (helper.ft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}); + const amountBefore = await helper.ft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, testCase.account(alice)); + expect(amountBefore).to.be.equal(BigInt(1)); + + await (helper.ft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}, 0n); + const amountAfter = await helper.ft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, testCase.account(alice)); + expect(amountAfter).to.be.equal(BigInt(0)); + + const transferTokenFromTx = () => helper.ft.transferTokenFrom(bob, collectionId, tokenId, {Substrate: bob.address}, {Substrate: charlie.address}, 1n); + await expect(transferTokenFromTx()).to.be.rejected; + }); + + itSub.ifWithPallets('ReFungible', [Pallets.ReFungible], async ({helper}) => { + const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(alice), pieces: 100n}); + await (helper.rft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}); + const amountBefore = await helper.rft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, testCase.account(alice)); + expect(amountBefore).to.be.equal(BigInt(1)); + + await (helper.rft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}, 0n); + const amountAfter = await helper.rft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, testCase.account(alice)); + expect(amountAfter).to.be.equal(BigInt(0)); + + const transferTokenFromTx = () => helper.rft.transferTokenFrom(bob, collectionId, tokenId, {Substrate: bob.address}, {Substrate: charlie.address}, 100n); + await expect(transferTokenFromTx()).to.be.rejected; + }); }); - itSub.ifWithPallets('ReFungible up to an approved amount', [Pallets.ReFungible], async ({helper}) => { - const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: bob.address, pieces: 100n}); - await helper.rft.approveToken(bob, collectionId, tokenId, {Substrate: charlie.address}); - const before = await helper.rft.getTokenBalance(collectionId, tokenId, {Substrate: alice.address}); - await helper.rft.transferTokenFrom(charlie, collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}, 1n); - const after = await helper.rft.getTokenBalance(collectionId, tokenId, {Substrate: alice.address}); - expect(after - before).to.be.equal(BigInt(1)); + describe(`[${testCase.method}] User cannot approve for the amount greater than they own:`, () => { + let alice: IKeyringPair; + let bob: IKeyringPair; + let charlie: IKeyringPair; + + before(async () => { + await usingPlaygrounds(async (helper, privateKey) => { + const donor = await privateKey({filename: __filename}); + [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor); + }); + }); + + itSub('1 for NFT', async ({helper}) => { + const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(bob)}); + const result = (helper.nft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: charlie.address}, 2n); + await expect(result).to.be.rejected; + expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: charlie.address})).to.be.false; + }); + + itSub('Fungible', async ({helper}) => { + const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0); + await helper.ft.mintTokens(alice, collectionId, 10n, testCase.account(alice)); + const tokenId = await helper.ft.getLastTokenId(collectionId); + const result = (helper.ft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}, 11n); + await expect(result).to.be.rejected; + }); + + itSub.ifWithPallets('ReFungible', [Pallets.ReFungible], async ({helper}) => { + const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(alice), pieces: 100n}); + const result = (helper.rft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: bob.address}, 101n); + await expect(result).to.be.rejected; + }); }); -}); -describe('Approved users cannot use transferFrom to repeat transfers if approved amount was already transferred:', () => { - let alice: IKeyringPair; - let bob: IKeyringPair; - let charlie: IKeyringPair; + describe(`[${testCase.method}] Integration Test approve(spender, collection_id, item_id, amount) with collection admin permissions:`, () => { + let alice: IKeyringPair; + let bob: IKeyringPair; + let charlie: IKeyringPair; + + before(async () => { + await usingPlaygrounds(async (helper, privateKey) => { + const donor = await privateKey({filename: __filename}); + [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor); + }); + }); - before(async () => { - await usingPlaygrounds(async (helper, privateKey) => { - const donor = await privateKey({filename: __filename}); - [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor); + itSub('can be called by collection admin on non-owned item', async ({helper}) => { + const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(alice)}); + await helper.collection.addAdmin(alice, collectionId, {Substrate: bob.address}); + const result = (helper.nft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: charlie.address}); + await expect(result).to.be.rejected; }); }); - itSub('NFT', async ({helper}) => { - const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address}); - await helper.nft.approveToken(bob, collectionId, tokenId, {Substrate: charlie.address}); - await helper.nft.transferTokenFrom(charlie, collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}); - const owner = await helper.nft.getTokenOwner(collectionId, tokenId); - expect(owner.Substrate).to.be.equal(alice.address); - const transferTokenFromTx = () => helper.nft.transferTokenFrom(charlie, collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}); - await expect(transferTokenFromTx()).to.be.rejected; - }); + describe(`[${testCase.method}] Negative Integration Test approve(spender, collection_id, item_id, amount):`, () => { + let alice: IKeyringPair; + let bob: IKeyringPair; + let charlie: IKeyringPair; - itSub('Fungible up to an approved amount', async ({helper}) => { - const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0); - await helper.ft.mintTokens(alice, collectionId, 10n, bob.address); - const tokenId = await helper.ft.getLastTokenId(collectionId); - await helper.ft.approveToken(bob, collectionId, tokenId, {Substrate: charlie.address}); - const before = await helper.ft.getBalance(collectionId, {Substrate: alice.address}); - await helper.ft.transferTokenFrom(charlie, collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}, 1n); - const after = await helper.ft.getBalance(collectionId, {Substrate: alice.address}); - expect(after - before).to.be.equal(BigInt(1)); + before(async () => { + await usingPlaygrounds(async (helper, privateKey) => { + const donor = await privateKey({filename: __filename}); + [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor); + }); + }); - const transferTokenFromTx = () => helper.ft.transferTokenFrom(charlie, collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}, 1n); - await expect(transferTokenFromTx()).to.be.rejected; - }); + itSub('[nft] Approve for a collection that does not exist', async ({helper}) => { + const collectionId = 1 << 32 - 1; + await expect((helper.nft as any)[testCase.method](bob, collectionId, 1, {Substrate: charlie.address})).to.be.rejected; + }); + + itSub('[fungible] Approve for a collection that does not exist', async ({helper}) => { + const collectionId = 1 << 32 - 1; + const approveTx = () => (helper.ft as any)[testCase.method](bob, collectionId, 1, {Substrate: charlie.address}); + await expect(approveTx()).to.be.rejected; + }); - itSub.ifWithPallets('ReFungible up to an approved amount', [Pallets.ReFungible], async ({helper}) => { - const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: bob.address, pieces: 100n}); - await helper.rft.approveToken(bob, collectionId, tokenId, {Substrate: charlie.address}, 100n); - const before = await helper.rft.getTokenBalance(collectionId, tokenId, {Substrate: alice.address}); - await helper.rft.transferTokenFrom(charlie, collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}, 100n); - const after = await helper.rft.getTokenBalance(collectionId, tokenId, {Substrate: alice.address}); - expect(after - before).to.be.equal(BigInt(100)); - const transferTokenFromTx = () => helper.rft.transferTokenFrom(charlie, collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}, 100n); - await expect(transferTokenFromTx()).to.be.rejected; - }); -}); + itSub.ifWithPallets('[refungible] Approve for a collection that does not exist', [Pallets.ReFungible], async ({helper}) => { + const collectionId = 1 << 32 - 1; + const approveTx = () => (helper.rft as any)[testCase.method](bob, collectionId, 1, {Substrate: charlie.address}); + await expect(approveTx()).to.be.rejected; + }); -describe('Approved amount decreases by the transferred amount:', () => { - let alice: IKeyringPair; - let bob: IKeyringPair; - let charlie: IKeyringPair; - let dave: IKeyringPair; + itSub('[nft] Approve for a collection that was destroyed', async ({helper}) => { + const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + await helper.nft.burn(alice, collectionId); + const approveTx = () => (helper.nft as any)[testCase.method](alice, collectionId, 1, {Substrate: bob.address}); + await expect(approveTx()).to.be.rejected; + }); - before(async () => { - await usingPlaygrounds(async (helper, privateKey) => { - const donor = await privateKey({filename: __filename}); - [alice, bob, charlie, dave] = await helper.arrange.createAccounts([100n, 100n, 100n, 100n], donor); + itSub('[fungible] Approve for a collection that was destroyed', async ({helper}) => { + const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + await helper.ft.burn(alice, collectionId); + const approveTx = () => (helper.ft as any)[testCase.method](alice, collectionId, 1, {Substrate: bob.address}); + await expect(approveTx()).to.be.rejected; }); - }); - itSub('If a user B is approved to transfer 10 Fungible tokens from user A, they can transfer 2 tokens to user C, which will result in decreasing approval from 10 to 8. Then user B can transfer 8 tokens to user D.', async ({helper}) => { - const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0); - await helper.ft.mintTokens(alice, collectionId, 10n, alice.address); - const tokenId = await helper.ft.getLastTokenId(collectionId); - await helper.ft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}, 10n); + itSub.ifWithPallets('[refungible] Approve for a collection that was destroyed', [Pallets.ReFungible], async ({helper}) => { + const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + await helper.rft.burn(alice, collectionId); + const approveTx = () => (helper.rft as any)[testCase.method](alice, collectionId, 1, {Substrate: bob.address}); + await expect(approveTx()).to.be.rejected; + }); - const charlieBefore = await helper.ft.getBalance(collectionId, {Substrate: charlie.address}); - await helper.ft.transferTokenFrom(bob, collectionId, tokenId, {Substrate: alice.address}, {Substrate: charlie.address}, 2n); - const charlieAfter = await helper.ft.getBalance(collectionId, {Substrate: charlie.address}); - expect(charlieAfter - charlieBefore).to.be.equal(BigInt(2)); + itSub('[nft] Approve transfer of a token that does not exist', async ({helper}) => { + const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + const approveTx = () => (helper.nft as any)[testCase.method](alice, collectionId, 2, {Substrate: bob.address}); + await expect(approveTx()).to.be.rejected; + }); - const daveBefore = await helper.ft.getBalance(collectionId, {Substrate: dave.address}); - await helper.ft.transferTokenFrom(bob, collectionId, tokenId, {Substrate: alice.address}, {Substrate: dave.address}, 8n); - const daveAfter = await helper.ft.getBalance(collectionId, {Substrate: dave.address}); - expect(daveAfter - daveBefore).to.be.equal(BigInt(8)); - }); -}); + itSub.ifWithPallets('[refungible] Approve transfer of a token that does not exist', [Pallets.ReFungible], async ({helper}) => { + const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + const approveTx = () => (helper.rft as any)[testCase.method](alice, collectionId, 2, {Substrate: bob.address}); + await expect(approveTx()).to.be.rejected; + }); -describe('User may clear the approvals to approving for 0 amount:', () => { - let alice: IKeyringPair; - let bob: IKeyringPair; - let charlie: IKeyringPair; + itSub('[nft] Approve using the address that does not own the approved token', async ({helper}) => { + const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(alice)}); + const approveTx = () => (helper.nft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: alice.address}); + await expect(approveTx()).to.be.rejected; + }); - before(async () => { - await usingPlaygrounds(async (helper, privateKey) => { - const donor = await privateKey({filename: __filename}); - [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor); + itSub('[fungible] Approve using the address that does not own the approved token', async ({helper}) => { + const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + await helper.ft.mintTokens(alice, collectionId, 10n, testCase.account(alice)); + const tokenId = await helper.ft.getLastTokenId(collectionId); + const approveTx = () => (helper.ft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: alice.address}); + await expect(approveTx()).to.be.rejected; }); - }); - itSub('NFT', async ({helper}) => { - const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address}); - await helper.nft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}); - expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.true; - await helper.signTransaction(alice, helper.constructApiCall('api.tx.unique.approve', [{Substrate: bob.address}, collectionId, tokenId, 0])); - expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: bob.address})).to.be.false; - const transferTokenFromTx = () => helper.nft.transferTokenFrom(bob, collectionId, tokenId, {Substrate: bob.address}, {Substrate: bob.address}); - await expect(transferTokenFromTx()).to.be.rejected; - }); + itSub.ifWithPallets('[refungible] Approve using the address that does not own the approved token', [Pallets.ReFungible], async ({helper}) => { + const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(alice), pieces: 100n}); + const approveTx = () => (helper.rft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: alice.address}); + await expect(approveTx()).to.be.rejected; + }); - itSub('Fungible', async ({helper}) => { - const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0); - await helper.ft.mintTokens(alice, collectionId, 10n, alice.address); - const tokenId = await helper.ft.getLastTokenId(collectionId); - await helper.ft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}); - const amountBefore = await helper.ft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}); - expect(amountBefore).to.be.equal(BigInt(1)); + itSub.ifWithPallets('should fail if approved more ReFungibles than owned', [Pallets.ReFungible], async ({helper}) => { + const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: alice.address, pieces: 100n}); + await helper.rft.transferToken(alice, collectionId, tokenId, testCase.account(bob), 100n); + await (helper.rft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: alice.address}, 100n); - await helper.ft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}, 0n); - const amountAfter = await helper.ft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}); - expect(amountAfter).to.be.equal(BigInt(0)); + const approveTx = () => (helper.rft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: alice.address}, 101n); + await expect(approveTx()).to.be.rejected; + }); - const transferTokenFromTx = () => helper.ft.transferTokenFrom(bob, collectionId, tokenId, {Substrate: bob.address}, {Substrate: charlie.address}, 1n); - await expect(transferTokenFromTx()).to.be.rejected; - }); + itSub('should fail if approved more Fungibles than owned', async ({helper}) => { + const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + await helper.ft.mintTokens(alice, collectionId, 10n, alice.address); + const tokenId = await helper.ft.getLastTokenId(collectionId); - itSub.ifWithPallets('ReFungible', [Pallets.ReFungible], async ({helper}) => { - const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: alice.address, pieces: 100n}); - await helper.rft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}); - const amountBefore = await helper.rft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}); - expect(amountBefore).to.be.equal(BigInt(1)); + await helper.ft.transferToken(alice, collectionId, tokenId, testCase.account(bob), 10n); + await (helper.ft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: alice.address}, 10n); + const approveTx = () => (helper.ft as any)[testCase.method](bob, collectionId, tokenId, {Substrate: alice.address}, 11n); + await expect(approveTx()).to.be.rejected; + }); - await helper.rft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}, 0n); - const amountAfter = await helper.rft.getTokenApprovedPieces(collectionId, tokenId, {Substrate: bob.address}, {Substrate: alice.address}); - expect(amountAfter).to.be.equal(BigInt(0)); + itSub('fails when called by collection owner on non-owned item when OwnerCanTransfer == false', async ({helper}) => { + const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); + const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: testCase.account(bob)}); + await helper.collection.setLimits(alice, collectionId, {ownerCanTransfer: false}); - const transferTokenFromTx = () => helper.rft.transferTokenFrom(bob, collectionId, tokenId, {Substrate: bob.address}, {Substrate: charlie.address}, 100n); - await expect(transferTokenFromTx()).to.be.rejected; + const approveTx = () => (helper.nft as any)[testCase.method](alice, collectionId, tokenId, {Substrate: charlie.address}); + await expect(approveTx()).to.be.rejected; + }); }); }); -describe('User cannot approve for the amount greater than they own:', () => { +describe('Normal user can approve other users to be wallet operator:', () => { let alice: IKeyringPair; let bob: IKeyringPair; - let charlie: IKeyringPair; before(async () => { await usingPlaygrounds(async (helper, privateKey) => { const donor = await privateKey({filename: __filename}); - [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor); + [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor); }); }); - itSub('1 for NFT', async ({helper}) => { + itSub('[nft] Enable and disable approval', async ({helper}) => { const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address}); - const approveTx = () => helper.signTransaction(bob, helper.constructApiCall('api.tx.unique.approve', [{Substrate: charlie.address}, collectionId, tokenId, 2])); - await expect(approveTx()).to.be.rejected; - expect(await helper.nft.isTokenApproved(collectionId, tokenId, {Substrate: charlie.address})).to.be.false; - }); - itSub('Fungible', async ({helper}) => { - const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}, 0); - await helper.ft.mintTokens(alice, collectionId, 10n, alice.address); - const tokenId = await helper.ft.getLastTokenId(collectionId); - const approveTx = () => helper.ft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}, 11n); - await expect(approveTx()).to.be.rejected; + const checkBeforeApproval = await helper.nft.allowanceForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address}); + expect(checkBeforeApproval).to.be.false; + + await helper.nft.setAllowanceForAll(alice, collectionId, {Substrate: bob.address}, true); + const checkAfterApproval = await helper.nft.allowanceForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address}); + expect(checkAfterApproval).to.be.true; + + await helper.nft.setAllowanceForAll(alice, collectionId, {Substrate: bob.address}, false); + const checkAfterDisapproval = await helper.nft.allowanceForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address}); + expect(checkAfterDisapproval).to.be.false; }); - itSub.ifWithPallets('ReFungible', [Pallets.ReFungible], async ({helper}) => { + itSub.ifWithPallets('[rft] Enable and disable approval', [Pallets.ReFungible], async ({helper}) => { const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: alice.address, pieces: 100n}); - const approveTx = () => helper.rft.approveToken(alice, collectionId, tokenId, {Substrate: bob.address}, 101n); - await expect(approveTx()).to.be.rejected; + + const checkBeforeApproval = await helper.rft.allowanceForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address}); + expect(checkBeforeApproval).to.be.false; + + await helper.rft.setAllowanceForAll(alice, collectionId, {Substrate: bob.address}, true); + const checkAfterApproval = await helper.rft.allowanceForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address}); + expect(checkAfterApproval).to.be.true; + + await helper.rft.setAllowanceForAll(alice, collectionId, {Substrate: bob.address}, false); + const checkAfterDisapproval = await helper.rft.allowanceForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address}); + expect(checkAfterDisapproval).to.be.false; }); }); @@ -464,184 +649,5 @@ await token.approve(dave, {Substrate: bob.address}, 50n); await expect(token.approve(dave, {Substrate: charlie.address}, 51n)) .to.be.rejectedWith('this test would fail (since it is skipped), replace this expecting message with what would have been received'); - }); -}); - -describe('Integration Test approve(spender, collection_id, item_id, amount) with collection admin permissions:', () => { - let alice: IKeyringPair; - let bob: IKeyringPair; - let charlie: IKeyringPair; - - before(async () => { - await usingPlaygrounds(async (helper, privateKey) => { - const donor = await privateKey({filename: __filename}); - [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor); - }); - }); - - itSub('can be called by collection admin on non-owned item', async ({helper}) => { - const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address}); - await helper.collection.addAdmin(alice, collectionId, {Substrate: bob.address}); - const approveTx = () => helper.nft.approveToken(bob, collectionId, tokenId, {Substrate: charlie.address}); - await expect(approveTx()).to.be.rejected; - }); -}); - -describe('Negative Integration Test approve(spender, collection_id, item_id, amount):', () => { - let alice: IKeyringPair; - let bob: IKeyringPair; - let charlie: IKeyringPair; - - before(async () => { - await usingPlaygrounds(async (helper, privateKey) => { - const donor = await privateKey({filename: __filename}); - [alice, bob, charlie] = await helper.arrange.createAccounts([100n, 100n, 100n], donor); - }); - }); - - itSub('[nft] Approve for a collection that does not exist', async ({helper}) => { - const collectionId = 1 << 32 - 1; - const approveTx = () => helper.nft.approveToken(bob, collectionId, 1, {Substrate: charlie.address}); - await expect(approveTx()).to.be.rejected; - }); - - itSub('[fungible] Approve for a collection that does not exist', async ({helper}) => { - const collectionId = 1 << 32 - 1; - const approveTx = () => helper.ft.approveToken(bob, collectionId, 1, {Substrate: charlie.address}); - await expect(approveTx()).to.be.rejected; - }); - - itSub.ifWithPallets('[refungible] Approve for a collection that does not exist', [Pallets.ReFungible], async ({helper}) => { - const collectionId = 1 << 32 - 1; - const approveTx = () => helper.rft.approveToken(bob, collectionId, 1, {Substrate: charlie.address}); - await expect(approveTx()).to.be.rejected; - }); - - itSub('[nft] Approve for a collection that was destroyed', async ({helper}) => { - const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - await helper.nft.burn(alice, collectionId); - const approveTx = () => helper.nft.approveToken(alice, collectionId, 1, {Substrate: bob.address}); - await expect(approveTx()).to.be.rejected; - }); - - itSub('[fungible] Approve for a collection that was destroyed', async ({helper}) => { - const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - await helper.ft.burn(alice, collectionId); - const approveTx = () => helper.ft.approveToken(alice, collectionId, 1, {Substrate: bob.address}); - await expect(approveTx()).to.be.rejected; - }); - - itSub.ifWithPallets('[refungible] Approve for a collection that was destroyed', [Pallets.ReFungible], async ({helper}) => { - const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - await helper.rft.burn(alice, collectionId); - const approveTx = () => helper.rft.approveToken(alice, collectionId, 1, {Substrate: bob.address}); - await expect(approveTx()).to.be.rejected; - }); - - itSub('[nft] Approve transfer of a token that does not exist', async ({helper}) => { - const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - const approveTx = () => helper.nft.approveToken(alice, collectionId, 2, {Substrate: bob.address}); - await expect(approveTx()).to.be.rejected; - }); - - itSub.ifWithPallets('[refungible] Approve transfer of a token that does not exist', [Pallets.ReFungible], async ({helper}) => { - const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - const approveTx = () => helper.rft.approveToken(alice, collectionId, 2, {Substrate: bob.address}); - await expect(approveTx()).to.be.rejected; - }); - - itSub('[nft] Approve using the address that does not own the approved token', async ({helper}) => { - const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: alice.address}); - const approveTx = () => helper.nft.approveToken(bob, collectionId, tokenId, {Substrate: alice.address}); - await expect(approveTx()).to.be.rejected; - }); - - itSub('[fungible] Approve using the address that does not own the approved token', async ({helper}) => { - const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - await helper.ft.mintTokens(alice, collectionId, 10n, alice.address); - const tokenId = await helper.ft.getLastTokenId(collectionId); - const approveTx = () => helper.ft.approveToken(bob, collectionId, tokenId, {Substrate: alice.address}); - await expect(approveTx()).to.be.rejected; - }); - - itSub.ifWithPallets('[refungible] Approve using the address that does not own the approved token', [Pallets.ReFungible], async ({helper}) => { - const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: alice.address, pieces: 100n}); - const approveTx = () => helper.rft.approveToken(bob, collectionId, tokenId, {Substrate: alice.address}); - await expect(approveTx()).to.be.rejected; - }); - - itSub.ifWithPallets('should fail if approved more ReFungibles than owned', [Pallets.ReFungible], async ({helper}) => { - const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - const {tokenId} = await helper.rft.mintToken(alice, {collectionId: collectionId, owner: alice.address, pieces: 100n}); - await helper.rft.transferToken(alice, collectionId, tokenId, {Substrate: bob.address}, 100n); - await helper.rft.approveToken(bob, collectionId, tokenId, {Substrate: alice.address}, 100n); - - const approveTx = () => helper.rft.approveToken(bob, collectionId, tokenId, {Substrate: alice.address}, 101n); - await expect(approveTx()).to.be.rejected; - }); - - itSub('should fail if approved more Fungibles than owned', async ({helper}) => { - const {collectionId} = await helper.ft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - await helper.ft.mintTokens(alice, collectionId, 10n, alice.address); - const tokenId = await helper.ft.getLastTokenId(collectionId); - - await helper.ft.transferToken(alice, collectionId, tokenId, {Substrate: bob.address}, 10n); - await helper.ft.approveToken(bob, collectionId, tokenId, {Substrate: alice.address}, 10n); - const approveTx = () => helper.ft.approveToken(bob, collectionId, tokenId, {Substrate: alice.address}, 11n); - await expect(approveTx()).to.be.rejected; - }); - - itSub('fails when called by collection owner on non-owned item when OwnerCanTransfer == false', async ({helper}) => { - const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - const {tokenId} = await helper.nft.mintToken(alice, {collectionId: collectionId, owner: bob.address}); - await helper.collection.setLimits(alice, collectionId, {ownerCanTransfer: false}); - - const approveTx = () => helper.nft.approveToken(alice, collectionId, tokenId, {Substrate: charlie.address}); - await expect(approveTx()).to.be.rejected; - }); -}); - -describe('Normal user can approve other users to be wallet operator:', () => { - let alice: IKeyringPair; - let bob: IKeyringPair; - - before(async () => { - await usingPlaygrounds(async (helper, privateKey) => { - const donor = await privateKey({filename: __filename}); - [alice, bob] = await helper.arrange.createAccounts([100n, 100n], donor); - }); - }); - - itSub('[nft] Enable and disable approval', async ({helper}) => { - const {collectionId} = await helper.nft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - - const checkBeforeApproval = await helper.nft.allowanceForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address}); - expect(checkBeforeApproval).to.be.false; - - await helper.nft.setAllowanceForAll(alice, collectionId, {Substrate: bob.address}, true); - const checkAfterApproval = await helper.nft.allowanceForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address}); - expect(checkAfterApproval).to.be.true; - - await helper.nft.setAllowanceForAll(alice, collectionId, {Substrate: bob.address}, false); - const checkAfterDisapproval = await helper.nft.allowanceForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address}); - expect(checkAfterDisapproval).to.be.false; - }); - - itSub.ifWithPallets('[rft] Enable and disable approval', [Pallets.ReFungible], async ({helper}) => { - const {collectionId} = await helper.rft.mintCollection(alice, {name: 'col', description: 'descr', tokenPrefix: 'COL'}); - - const checkBeforeApproval = await helper.rft.allowanceForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address}); - expect(checkBeforeApproval).to.be.false; - - await helper.rft.setAllowanceForAll(alice, collectionId, {Substrate: bob.address}, true); - const checkAfterApproval = await helper.rft.allowanceForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address}); - expect(checkAfterApproval).to.be.true; - - await helper.rft.setAllowanceForAll(alice, collectionId, {Substrate: bob.address}, false); - const checkAfterDisapproval = await helper.rft.allowanceForAll(collectionId, {Substrate: alice.address}, {Substrate: bob.address}); - expect(checkAfterDisapproval).to.be.false; }); }); --- a/tests/src/eth/api/ContractHelpers.sol +++ b/tests/src/eth/api/ContractHelpers.sol @@ -183,9 +183,9 @@ /// Ethereum representation of Optional value with CrossAddress. struct OptionCrossAddress { - /// TODO: field description + /// Whether or not this CrossAdress is valid and has meaning. bool status; - /// TODO: field description + /// The underlying CrossAddress value. If the status is false, can be set to whatever. CrossAddress value; } --- a/tests/src/interfaces/augment-api-errors.ts +++ b/tests/src/interfaces/augment-api-errors.ts @@ -85,6 +85,10 @@ **/ AccountTokenLimitExceeded: AugmentedError; /** + * Only spending from eth mirror could be approved + **/ + AddressIsNotEthMirror: AugmentedError; + /** * Can't transfer tokens to ethereum zero address **/ AddressIsZero: AugmentedError; --- a/tests/src/interfaces/augment-api-tx.ts +++ b/tests/src/interfaces/augment-api-tx.ts @@ -1214,6 +1214,25 @@ **/ approve: AugmentedSubmittable<(spender: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [PalletEvmAccountBasicCrossAccountIdRepr, u32, u32, u128]>; /** + * Allow a non-permissioned address to transfer or burn an item from owner's eth mirror. + * + * # Permissions + * + * * Collection owner + * * Collection admin + * * Current item owner + * + * # Arguments + * + * * `from`: Owner's account eth mirror + * * `to`: Account to be approved to make specific transactions on non-owned tokens. + * * `collection_id`: ID of the collection the item belongs to. + * * `item_id`: ID of the item transactions on which are now approved. + * * `amount`: Number of pieces of the item approved for a transaction (maximum of 1 for NFTs). + * Set to 0 to revoke the approval. + **/ + approveFrom: AugmentedSubmittable<(from: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, to: PalletEvmAccountBasicCrossAccountIdRepr | { Substrate: any } | { Ethereum: any } | string | Uint8Array, collectionId: u32 | AnyNumber | Uint8Array, itemId: u32 | AnyNumber | Uint8Array, amount: u128 | AnyNumber | Uint8Array) => SubmittableExtrinsic, [PalletEvmAccountBasicCrossAccountIdRepr, PalletEvmAccountBasicCrossAccountIdRepr, u32, u32, u128]>; + /** * Destroy a token on behalf of the owner as a non-owner account. * * See also: [`approve`][`Pallet::approve`]. --- a/tests/src/interfaces/default/types.ts +++ b/tests/src/interfaces/default/types.ts @@ -1216,6 +1216,7 @@ readonly isTokenValueTooLow: boolean; readonly isApprovedValueTooLow: boolean; readonly isCantApproveMoreThanOwned: boolean; + readonly isAddressIsNotEthMirror: boolean; readonly isAddressIsZero: boolean; readonly isUnsupportedOperation: boolean; readonly isNotSufficientFounds: boolean; @@ -1231,7 +1232,7 @@ readonly isCollectionIsInternal: boolean; readonly isConfirmSponsorshipFail: boolean; readonly isUserIsNotCollectionAdmin: boolean; - readonly type: 'CollectionNotFound' | 'MustBeTokenOwner' | 'NoPermission' | 'CantDestroyNotEmptyCollection' | 'PublicMintingNotAllowed' | 'AddressNotInAllowlist' | 'CollectionNameLimitExceeded' | 'CollectionDescriptionLimitExceeded' | 'CollectionTokenPrefixLimitExceeded' | 'TotalCollectionsLimitExceeded' | 'CollectionAdminCountExceeded' | 'CollectionLimitBoundsExceeded' | 'OwnerPermissionsCantBeReverted' | 'TransferNotAllowed' | 'AccountTokenLimitExceeded' | 'CollectionTokenLimitExceeded' | 'MetadataFlagFrozen' | 'TokenNotFound' | 'TokenValueTooLow' | 'ApprovedValueTooLow' | 'CantApproveMoreThanOwned' | 'AddressIsZero' | 'UnsupportedOperation' | 'NotSufficientFounds' | 'UserIsNotAllowedToNest' | 'SourceCollectionIsNotAllowedToNest' | 'CollectionFieldSizeExceeded' | 'NoSpaceForProperty' | 'PropertyLimitReached' | 'PropertyKeyIsTooLong' | 'InvalidCharacterInPropertyKey' | 'EmptyPropertyKey' | 'CollectionIsExternal' | 'CollectionIsInternal' | 'ConfirmSponsorshipFail' | 'UserIsNotCollectionAdmin'; + readonly type: 'CollectionNotFound' | 'MustBeTokenOwner' | 'NoPermission' | 'CantDestroyNotEmptyCollection' | 'PublicMintingNotAllowed' | 'AddressNotInAllowlist' | 'CollectionNameLimitExceeded' | 'CollectionDescriptionLimitExceeded' | 'CollectionTokenPrefixLimitExceeded' | 'TotalCollectionsLimitExceeded' | 'CollectionAdminCountExceeded' | 'CollectionLimitBoundsExceeded' | 'OwnerPermissionsCantBeReverted' | 'TransferNotAllowed' | 'AccountTokenLimitExceeded' | 'CollectionTokenLimitExceeded' | 'MetadataFlagFrozen' | 'TokenNotFound' | 'TokenValueTooLow' | 'ApprovedValueTooLow' | 'CantApproveMoreThanOwned' | 'AddressIsNotEthMirror' | 'AddressIsZero' | 'UnsupportedOperation' | 'NotSufficientFounds' | 'UserIsNotAllowedToNest' | 'SourceCollectionIsNotAllowedToNest' | 'CollectionFieldSizeExceeded' | 'NoSpaceForProperty' | 'PropertyLimitReached' | 'PropertyKeyIsTooLong' | 'InvalidCharacterInPropertyKey' | 'EmptyPropertyKey' | 'CollectionIsExternal' | 'CollectionIsInternal' | 'ConfirmSponsorshipFail' | 'UserIsNotCollectionAdmin'; } /** @name PalletCommonEvent */ @@ -2306,6 +2307,14 @@ readonly itemId: u32; readonly amount: u128; } & Struct; + readonly isApproveFrom: boolean; + readonly asApproveFrom: { + readonly from: PalletEvmAccountBasicCrossAccountIdRepr; + readonly to: PalletEvmAccountBasicCrossAccountIdRepr; + readonly collectionId: u32; + readonly itemId: u32; + readonly amount: u128; + } & Struct; readonly isTransferFrom: boolean; readonly asTransferFrom: { readonly from: PalletEvmAccountBasicCrossAccountIdRepr; @@ -2345,7 +2354,7 @@ readonly collectionId: u32; readonly itemId: u32; } & Struct; - readonly type: 'CreateCollection' | 'CreateCollectionEx' | 'DestroyCollection' | 'AddToAllowList' | 'RemoveFromAllowList' | 'ChangeCollectionOwner' | 'AddCollectionAdmin' | 'RemoveCollectionAdmin' | 'SetCollectionSponsor' | 'ConfirmSponsorship' | 'RemoveCollectionSponsor' | 'CreateItem' | 'CreateMultipleItems' | 'SetCollectionProperties' | 'DeleteCollectionProperties' | 'SetTokenProperties' | 'DeleteTokenProperties' | 'SetTokenPropertyPermissions' | 'CreateMultipleItemsEx' | 'SetTransfersEnabledFlag' | 'BurnItem' | 'BurnFrom' | 'Transfer' | 'Approve' | 'TransferFrom' | 'SetCollectionLimits' | 'SetCollectionPermissions' | 'Repartition' | 'SetAllowanceForAll' | 'ForceRepairCollection' | 'ForceRepairItem'; + readonly type: 'CreateCollection' | 'CreateCollectionEx' | 'DestroyCollection' | 'AddToAllowList' | 'RemoveFromAllowList' | 'ChangeCollectionOwner' | 'AddCollectionAdmin' | 'RemoveCollectionAdmin' | 'SetCollectionSponsor' | 'ConfirmSponsorship' | 'RemoveCollectionSponsor' | 'CreateItem' | 'CreateMultipleItems' | 'SetCollectionProperties' | 'DeleteCollectionProperties' | 'SetTokenProperties' | 'DeleteTokenProperties' | 'SetTokenPropertyPermissions' | 'CreateMultipleItemsEx' | 'SetTransfersEnabledFlag' | 'BurnItem' | 'BurnFrom' | 'Transfer' | 'Approve' | 'ApproveFrom' | 'TransferFrom' | 'SetCollectionLimits' | 'SetCollectionPermissions' | 'Repartition' | 'SetAllowanceForAll' | 'ForceRepairCollection' | 'ForceRepairItem'; } /** @name PalletUniqueError */ --- a/tests/src/interfaces/lookup.ts +++ b/tests/src/interfaces/lookup.ts @@ -2264,6 +2264,13 @@ itemId: 'u32', amount: 'u128', }, + approve_from: { + from: 'PalletEvmAccountBasicCrossAccountIdRepr', + to: 'PalletEvmAccountBasicCrossAccountIdRepr', + collectionId: 'u32', + itemId: 'u32', + amount: 'u128', + }, transfer_from: { from: 'PalletEvmAccountBasicCrossAccountIdRepr', recipient: 'PalletEvmAccountBasicCrossAccountIdRepr', @@ -3280,7 +3287,7 @@ * Lookup423: pallet_common::pallet::Error **/ PalletCommonError: { - _enum: ['CollectionNotFound', 'MustBeTokenOwner', 'NoPermission', 'CantDestroyNotEmptyCollection', 'PublicMintingNotAllowed', 'AddressNotInAllowlist', 'CollectionNameLimitExceeded', 'CollectionDescriptionLimitExceeded', 'CollectionTokenPrefixLimitExceeded', 'TotalCollectionsLimitExceeded', 'CollectionAdminCountExceeded', 'CollectionLimitBoundsExceeded', 'OwnerPermissionsCantBeReverted', 'TransferNotAllowed', 'AccountTokenLimitExceeded', 'CollectionTokenLimitExceeded', 'MetadataFlagFrozen', 'TokenNotFound', 'TokenValueTooLow', 'ApprovedValueTooLow', 'CantApproveMoreThanOwned', 'AddressIsZero', 'UnsupportedOperation', 'NotSufficientFounds', 'UserIsNotAllowedToNest', 'SourceCollectionIsNotAllowedToNest', 'CollectionFieldSizeExceeded', 'NoSpaceForProperty', 'PropertyLimitReached', 'PropertyKeyIsTooLong', 'InvalidCharacterInPropertyKey', 'EmptyPropertyKey', 'CollectionIsExternal', 'CollectionIsInternal', 'ConfirmSponsorshipFail', 'UserIsNotCollectionAdmin'] + _enum: ['CollectionNotFound', 'MustBeTokenOwner', 'NoPermission', 'CantDestroyNotEmptyCollection', 'PublicMintingNotAllowed', 'AddressNotInAllowlist', 'CollectionNameLimitExceeded', 'CollectionDescriptionLimitExceeded', 'CollectionTokenPrefixLimitExceeded', 'TotalCollectionsLimitExceeded', 'CollectionAdminCountExceeded', 'CollectionLimitBoundsExceeded', 'OwnerPermissionsCantBeReverted', 'TransferNotAllowed', 'AccountTokenLimitExceeded', 'CollectionTokenLimitExceeded', 'MetadataFlagFrozen', 'TokenNotFound', 'TokenValueTooLow', 'ApprovedValueTooLow', 'CantApproveMoreThanOwned', 'AddressIsNotEthMirror', 'AddressIsZero', 'UnsupportedOperation', 'NotSufficientFounds', 'UserIsNotAllowedToNest', 'SourceCollectionIsNotAllowedToNest', 'CollectionFieldSizeExceeded', 'NoSpaceForProperty', 'PropertyLimitReached', 'PropertyKeyIsTooLong', 'InvalidCharacterInPropertyKey', 'EmptyPropertyKey', 'CollectionIsExternal', 'CollectionIsInternal', 'ConfirmSponsorshipFail', 'UserIsNotCollectionAdmin'] }, /** * Lookup425: pallet_fungible::pallet::Error --- a/tests/src/interfaces/types-lookup.ts +++ b/tests/src/interfaces/types-lookup.ts @@ -2493,6 +2493,14 @@ readonly itemId: u32; readonly amount: u128; } & Struct; + readonly isApproveFrom: boolean; + readonly asApproveFrom: { + readonly from: PalletEvmAccountBasicCrossAccountIdRepr; + readonly to: PalletEvmAccountBasicCrossAccountIdRepr; + readonly collectionId: u32; + readonly itemId: u32; + readonly amount: u128; + } & Struct; readonly isTransferFrom: boolean; readonly asTransferFrom: { readonly from: PalletEvmAccountBasicCrossAccountIdRepr; @@ -2532,7 +2540,7 @@ readonly collectionId: u32; readonly itemId: u32; } & Struct; - readonly type: 'CreateCollection' | 'CreateCollectionEx' | 'DestroyCollection' | 'AddToAllowList' | 'RemoveFromAllowList' | 'ChangeCollectionOwner' | 'AddCollectionAdmin' | 'RemoveCollectionAdmin' | 'SetCollectionSponsor' | 'ConfirmSponsorship' | 'RemoveCollectionSponsor' | 'CreateItem' | 'CreateMultipleItems' | 'SetCollectionProperties' | 'DeleteCollectionProperties' | 'SetTokenProperties' | 'DeleteTokenProperties' | 'SetTokenPropertyPermissions' | 'CreateMultipleItemsEx' | 'SetTransfersEnabledFlag' | 'BurnItem' | 'BurnFrom' | 'Transfer' | 'Approve' | 'TransferFrom' | 'SetCollectionLimits' | 'SetCollectionPermissions' | 'Repartition' | 'SetAllowanceForAll' | 'ForceRepairCollection' | 'ForceRepairItem'; + readonly type: 'CreateCollection' | 'CreateCollectionEx' | 'DestroyCollection' | 'AddToAllowList' | 'RemoveFromAllowList' | 'ChangeCollectionOwner' | 'AddCollectionAdmin' | 'RemoveCollectionAdmin' | 'SetCollectionSponsor' | 'ConfirmSponsorship' | 'RemoveCollectionSponsor' | 'CreateItem' | 'CreateMultipleItems' | 'SetCollectionProperties' | 'DeleteCollectionProperties' | 'SetTokenProperties' | 'DeleteTokenProperties' | 'SetTokenPropertyPermissions' | 'CreateMultipleItemsEx' | 'SetTransfersEnabledFlag' | 'BurnItem' | 'BurnFrom' | 'Transfer' | 'Approve' | 'ApproveFrom' | 'TransferFrom' | 'SetCollectionLimits' | 'SetCollectionPermissions' | 'Repartition' | 'SetAllowanceForAll' | 'ForceRepairCollection' | 'ForceRepairItem'; } /** @name UpDataStructsCollectionMode (236) */ @@ -3564,6 +3572,7 @@ readonly isTokenValueTooLow: boolean; readonly isApprovedValueTooLow: boolean; readonly isCantApproveMoreThanOwned: boolean; + readonly isAddressIsNotEthMirror: boolean; readonly isAddressIsZero: boolean; readonly isUnsupportedOperation: boolean; readonly isNotSufficientFounds: boolean; @@ -3579,7 +3588,7 @@ readonly isCollectionIsInternal: boolean; readonly isConfirmSponsorshipFail: boolean; readonly isUserIsNotCollectionAdmin: boolean; - readonly type: 'CollectionNotFound' | 'MustBeTokenOwner' | 'NoPermission' | 'CantDestroyNotEmptyCollection' | 'PublicMintingNotAllowed' | 'AddressNotInAllowlist' | 'CollectionNameLimitExceeded' | 'CollectionDescriptionLimitExceeded' | 'CollectionTokenPrefixLimitExceeded' | 'TotalCollectionsLimitExceeded' | 'CollectionAdminCountExceeded' | 'CollectionLimitBoundsExceeded' | 'OwnerPermissionsCantBeReverted' | 'TransferNotAllowed' | 'AccountTokenLimitExceeded' | 'CollectionTokenLimitExceeded' | 'MetadataFlagFrozen' | 'TokenNotFound' | 'TokenValueTooLow' | 'ApprovedValueTooLow' | 'CantApproveMoreThanOwned' | 'AddressIsZero' | 'UnsupportedOperation' | 'NotSufficientFounds' | 'UserIsNotAllowedToNest' | 'SourceCollectionIsNotAllowedToNest' | 'CollectionFieldSizeExceeded' | 'NoSpaceForProperty' | 'PropertyLimitReached' | 'PropertyKeyIsTooLong' | 'InvalidCharacterInPropertyKey' | 'EmptyPropertyKey' | 'CollectionIsExternal' | 'CollectionIsInternal' | 'ConfirmSponsorshipFail' | 'UserIsNotCollectionAdmin'; + readonly type: 'CollectionNotFound' | 'MustBeTokenOwner' | 'NoPermission' | 'CantDestroyNotEmptyCollection' | 'PublicMintingNotAllowed' | 'AddressNotInAllowlist' | 'CollectionNameLimitExceeded' | 'CollectionDescriptionLimitExceeded' | 'CollectionTokenPrefixLimitExceeded' | 'TotalCollectionsLimitExceeded' | 'CollectionAdminCountExceeded' | 'CollectionLimitBoundsExceeded' | 'OwnerPermissionsCantBeReverted' | 'TransferNotAllowed' | 'AccountTokenLimitExceeded' | 'CollectionTokenLimitExceeded' | 'MetadataFlagFrozen' | 'TokenNotFound' | 'TokenValueTooLow' | 'ApprovedValueTooLow' | 'CantApproveMoreThanOwned' | 'AddressIsNotEthMirror' | 'AddressIsZero' | 'UnsupportedOperation' | 'NotSufficientFounds' | 'UserIsNotAllowedToNest' | 'SourceCollectionIsNotAllowedToNest' | 'CollectionFieldSizeExceeded' | 'NoSpaceForProperty' | 'PropertyLimitReached' | 'PropertyKeyIsTooLong' | 'InvalidCharacterInPropertyKey' | 'EmptyPropertyKey' | 'CollectionIsExternal' | 'CollectionIsInternal' | 'ConfirmSponsorshipFail' | 'UserIsNotCollectionAdmin'; } /** @name PalletFungibleError (425) */ --- a/tests/src/util/playgrounds/unique.ts +++ b/tests/src/util/playgrounds/unique.ts @@ -633,6 +633,10 @@ let call = this.getApi() as any; for(const part of apiCall.slice(4).split('.')) { call = call[part]; + if (!call) { + const advice = part.includes('_') ? ' Looks like it needs to be converted to camel case.' : ''; + throw Error(`Function ${part} of api call ${apiCall} not found.${advice}`); + } } return call(...params); } @@ -1259,6 +1263,42 @@ } /** + * Set, change, or remove approved address to transfer the ownership of the NFT from eth mirror. + * + * @param signer keyring of signer + * @param collectionId ID of collection + * @param tokenId ID of token + * @param fromAddressObj Signer's Ethereum address containing her tokens + * @param toAddressObj Substrate or Ethereum address which gets approved use of the signer's tokens + * @param amount amount of token to be approved. For NFT must be set to 1n + * @returns ```true``` if extrinsic success, otherwise ```false``` + */ + async approveTokenFrom(signer: IKeyringPair, collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) { + const approveResult = await this.helper.executeExtrinsic( + signer, + 'api.tx.unique.approveFrom', [fromAddressObj, toAddressObj, collectionId, tokenId, amount], + true, // `Unable to approve token for ${label}`, + ); + + return this.helper.util.findCollectionInEvents(approveResult.result.events, collectionId, 'common', 'Approved'); + } + + /** + * Set, change, or remove approved address to transfer the ownership of the NFT from eth mirror. + * + * @param signer keyring of signer + * @param collectionId ID of collection + * @param tokenId ID of token + * @param toAddressObj Substrate or Ethereum address which gets approved use of the signer's tokens + * @param amount amount of token to be approved. For NFT must be set to 1n + * @returns ```true``` if extrinsic success, otherwise ```false``` + */ + async approveTokenFromEth(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) { + const ethMirror = CrossAccountId.fromKeyring(signer).toEthereum(); + return await this.approveTokenFrom(signer, collectionId, tokenId, ethMirror, toAddressObj, amount); + } + + /** * Get the amount of token pieces approved to transfer or burn. Normally 0. * * @param collectionId ID of collection @@ -1756,8 +1796,8 @@ * @example approveToken(aliceKeyring, 10, 5, {Substrate: "5DyN4Y92vZCjv38fg..."}) * @returns ```true``` if extrinsic success, otherwise ```false``` */ - approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId) { - return super.approveToken(signer, collectionId, tokenId, toAddressObj, 1n); + approveToken(signer: IKeyringPair, collectionId: number, tokenId: number, toAddressObj: ICrossAccountId, amount=1n) { + return super.approveToken(signer, collectionId, tokenId, toAddressObj, amount); } }