git.delta.rocks / unique-network / refs/commits / 6a168a1db3c2

9                "rpcPort": 9843,9                "rpcPort": 9843,
10                "port": 30444,10                "port": 30444,
11                "flags": [11                "flags": [
12                    "--rpc-port=9843",
13                    "-lparachain::candidate_validation=debug"12                    "-lparachain::candidate_validation=debug"
14                ]13                ]
15            },14            },
19                "rpcPort": 9854,18                "rpcPort": 9854,
20                "port": 30555,19                "port": 30555,
21                "flags": [20                "flags": [
22                    "--rpc-port=9854",
23                    "-lparachain::candidate_validation=debug"21                    "-lparachain::candidate_validation=debug"
24                ]22                ]
25            },23            },
29                "rpcPort": 9865,27                "rpcPort": 9865,
30                "port": 30666,28                "port": 30666,
31                "flags": [29                "flags": [
32                    "--rpc-port=9865",
33                    "-lparachain::candidate_validation=debug"30                    "-lparachain::candidate_validation=debug"
34                ]31                ]
35            },32            },
39                "rpcPort": 9876,36                "rpcPort": 9876,
40                "port": 30777,37                "port": 30777,
41                "flags": [38                "flags": [
42                    "--rpc-port=9876",
43                    "-lparachain::candidate_validation=debug"39                    "-lparachain::candidate_validation=debug"
44                ]40                ]
45            }41            }
70                    "name": "alice",66                    "name": "alice",
71                    "flags": [67                    "flags": [
72                        "--rpc-cors=all",68                        "--rpc-cors=all",
73                        "--rpc-port=9933",
74                        "--unsafe-rpc-external",69                        "--unsafe-rpc-external",
75                        "--unsafe-ws-external"70                        "--unsafe-ws-external"
76                    ]71                    ]
82                    "name": "bob",77                    "name": "bob",
83                    "flags": [78                    "flags": [
84                        "--rpc-cors=all",79                        "--rpc-cors=all",
85                        "--rpc-port=9934",
86                        "--unsafe-rpc-external",80                        "--unsafe-rpc-external",
87                        "--unsafe-ws-external"81                        "--unsafe-ws-external"
88                    ]82                    ]

328			.checked_add(data.len() as u32)328			.checked_add(data.len() as u32)
329			.ok_or(ArithmeticError::Overflow)?;329			.ok_or(ArithmeticError::Overflow)?;
330		ensure!(330		ensure!(
331			tokens_minted < collection.limits.token_limit(),331			tokens_minted <= collection.limits.token_limit(),
332			<CommonError<T>>::CollectionTokenLimitExceeded332			<CommonError<T>>::CollectionTokenLimitExceeded
333		);333		);
334		collection.consume_sstore()?;334		collection.consume_sstore()?;

60    'pallet-transaction-payment/std',60    'pallet-transaction-payment/std',
61    'pallet-transaction-payment-rpc-runtime-api/std',61    'pallet-transaction-payment-rpc-runtime-api/std',
62    'pallet-treasury/std',62    'pallet-treasury/std',
63    'pallet-vesting/std',63    # 'pallet-vesting/std',
64    'pallet-evm/std',64    'pallet-evm/std',
65    'pallet-evm-migration/std',65    'pallet-evm-migration/std',
66    'pallet-evm-contract-helpers/std',66    'pallet-evm-contract-helpers/std',
98    'xcm-builder/std',98    'xcm-builder/std',
99    'xcm-executor/std',99    'xcm-executor/std',
100
101    "orml-vesting/std",
100]102]
101limit-testing = ['pallet-nft/limit-testing', 'nft-data-structs/limit-testing']103limit-testing = ['pallet-nft/limit-testing', 'nft-data-structs/limit-testing']
102104
210git = 'https://github.com/paritytech/substrate.git'212git = 'https://github.com/paritytech/substrate.git'
211branch = 'polkadot-v0.9.12'213branch = 'polkadot-v0.9.12'
212214
213[dependencies.pallet-vesting]215# [dependencies.pallet-vesting]
214default-features = false216# default-features = false
215git = 'https://github.com/paritytech/substrate.git'217# git = 'https://github.com/paritytech/substrate.git'
216branch = 'polkadot-v0.9.12'218# branch = 'polkadot-v0.9.12'
217219
218[dependencies.sp-arithmetic]220[dependencies.sp-arithmetic]
219default-features = false221default-features = false
359branch = 'release-v0.9.12'361branch = 'release-v0.9.12'
360default-features = false362default-features = false
361363
364[dependencies.orml-vesting]
365git = "https://github.com/open-web3-stack/open-runtime-module-library"
366version = "0.4.1-dev" 
367default-features = false
362368
363################################################################################369################################################################################
364# local dependencies370# local dependencies

22use sp_runtime::{22use sp_runtime::{
23	Permill, Perbill, Percent, create_runtime_str, generic, impl_opaque_keys,23	Permill, Perbill, Percent, create_runtime_str, generic, impl_opaque_keys,
24	traits::{24	traits::{
25		AccountIdLookup, ConvertInto, BlakeTwo256, Block as BlockT, IdentifyAccount, Verify,25		AccountIdLookup, BlakeTwo256, Block as BlockT, IdentifyAccount, Verify, AccountIdConversion,
26		AccountIdConversion,
27	},26	},
28	transaction_validity::{TransactionSource, TransactionValidity},27	transaction_validity::{TransactionSource, TransactionValidity},
70use fp_rpc::TransactionStatus;69use fp_rpc::TransactionStatus;
71use sp_core::crypto::Public;70use sp_core::crypto::Public;
72use sp_runtime::{71use sp_runtime::{
73	traits::{Dispatchable, PostDispatchInfoOf},72	traits::{BlockNumberProvider, Dispatchable, PostDispatchInfoOf},
74	transaction_validity::TransactionValidityError,73	transaction_validity::TransactionValidityError,
75};74};
7675
515	type Call = Call;514	type Call = Call;
516}515}
516
517pub struct RelayChainBlockNumberProvider<T>(sp_std::marker::PhantomData<T>);
518
519impl<T: cumulus_pallet_parachain_system::Config> BlockNumberProvider
520	for RelayChainBlockNumberProvider<T>
521{
522	type BlockNumber = BlockNumber;
523
524	fn current_block_number() -> Self::BlockNumber {
525		cumulus_pallet_parachain_system::Pallet::<T>::validation_data()
526			.map(|d| d.relay_parent_number)
527			.unwrap_or_default()
528	}
529}
517530
518parameter_types! {531parameter_types! {
519	pub const MinVestedTransfer: Balance = 10 * UNIQUE;532	pub const MinVestedTransfer: Balance = 10 * UNIQUE;
533	pub const MaxVestingSchedules: u32 = 28;
520}534}
521535
522impl pallet_vesting::Config for Runtime {536impl orml_vesting::Config for Runtime {
523	type Event = Event;537	type Event = Event;
524	type Currency = Balances;538	type Currency = pallet_balances::Pallet<Runtime>;
525	type BlockNumberToBalance = ConvertInto;539	type MinVestedTransfer = MinVestedTransfer;
526	type MinVestedTransfer = MinVestedTransfer;540	type VestedTransferOrigin = EnsureSigned<AccountId>;
527	type WeightInfo = ();541	type WeightInfo = ();
528	const MAX_VESTING_SCHEDULES: u32 = 28;542	type MaxVestingSchedules = MaxVestingSchedules;
543	type BlockNumberProvider = RelayChainBlockNumberProvider<Runtime>;
529}544}
530545
531parameter_types! {546parameter_types! {
841		Treasury: pallet_treasury::{Pallet, Call, Storage, Config, Event<T>} = 34,856		Treasury: pallet_treasury::{Pallet, Call, Storage, Config, Event<T>} = 34,
842		Sudo: pallet_sudo::{Pallet, Call, Storage, Config<T>, Event<T>} = 35,857		Sudo: pallet_sudo::{Pallet, Call, Storage, Config<T>, Event<T>} = 35,
843		System: system::{Pallet, Call, Storage, Config, Event<T>} = 36,858		System: system::{Pallet, Call, Storage, Config, Event<T>} = 36,
844		Vesting: pallet_vesting::{Pallet, Call, Config<T>, Storage, Event<T>} = 37,859		Vesting: orml_vesting::{Pallet, Storage, Call, Event<T>, Config<T>} = 37,
860		// Vesting: pallet_vesting::{Pallet, Call, Config<T>, Storage, Event<T>} = 37,
845		// Contracts: pallet_contracts::{Pallet, Call, Storage, Event<T>} = 38,861		// Contracts: pallet_contracts::{Pallet, Call, Storage, Event<T>} = 38,
846862
847		// XCM helpers.863		// XCM helpers.

1import {readFile} from 'fs/promises';1import {readFile} from 'fs/promises';
2import {getBalanceSingle, transferBalanceExpectSuccess} from '../../substrate/get-balance';2import {getBalanceSingle, transferBalanceExpectSuccess} from '../../substrate/get-balance';
3import privateKey from '../../substrate/privateKey';3import privateKey from '../../substrate/privateKey';
4import {createCollectionExpectSuccess, createFungibleItemExpectSuccess, createItemExpectSuccess, getTokenOwner, transferExpectSuccess, transferFromExpectSuccess} from '../../util/helpers';4import {addToAllowListExpectSuccess, confirmSponsorshipExpectSuccess, createCollectionExpectSuccess, createFungibleItemExpectSuccess, createItemExpectSuccess, getTokenOwner, setCollectionSponsorExpectSuccess, transferExpectSuccess, transferFromExpectSuccess} from '../../util/helpers';
5import {collectionIdToAddress, createEthAccountWithBalance, executeEthTxOnSub, GAS_ARGS, itWeb3, subToEth, subToEthLowercase} from '../util/helpers';5import {collectionIdToAddress, contractHelpers, createEthAccountWithBalance, executeEthTxOnSub, GAS_ARGS, itWeb3, subToEth, subToEthLowercase} from '../util/helpers';
6import {evmToAddress} from '@polkadot/util-crypto';6import {evmToAddress} from '@polkadot/util-crypto';
7import nonFungibleAbi from '../nonFungibleAbi.json';7import nonFungibleAbi from '../nonFungibleAbi.json';
8import fungibleAbi from '../fungibleAbi.json';8import fungibleAbi from '../fungibleAbi.json';
13describe('Matcher contract usage', () => {13describe('Matcher contract usage', () => {
14  itWeb3('With UNQ', async ({api, web3}) => {14  itWeb3('With UNQ', async ({api, web3}) => {
15    const matcherOwner = await createEthAccountWithBalance(api, web3);15    const matcherOwner = await createEthAccountWithBalance(api, web3);
16    const matcherContract = new web3.eth.Contract(JSON.parse((await readFile(`${__dirname}/MarketPlaceUNQ.abi`)).toString()), undefined, {16    const matcherContract = new web3.eth.Contract(JSON.parse((await readFile(`${__dirname}/MarketPlace.abi`)).toString()), undefined, {
17      from: matcherOwner,17      from: matcherOwner,
18      ...GAS_ARGS,18      ...GAS_ARGS,
19    });19    });
20    const matcher = await matcherContract.deploy({data: (await readFile(`${__dirname}/MarketPlaceUNQ.bin`)).toString()}).send({from: matcherOwner});20    const matcher = await matcherContract.deploy({data: (await readFile(`${__dirname}/MarketPlace.bin`)).toString(), arguments:[matcherOwner]}).send({from: matcherOwner});
21    const helpers = contractHelpers(web3, matcherOwner);
22    await helpers.methods.toggleSponsoring(matcher.options.address, true).send({from: matcherOwner});
23    await helpers.methods.setSponsoringRateLimit(matcher.options.address, 1).send({from: matcherOwner});
2124
22    const alice = privateKey('//Alice');25    const alice = privateKey('//Alice');
23    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});26    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
24    const evmCollection = new web3.eth.Contract(nonFungibleAbi as any, collectionIdToAddress(collectionId), {from: matcherOwner});27    const evmCollection = new web3.eth.Contract(nonFungibleAbi as any, collectionIdToAddress(collectionId), {from: matcherOwner});
28    await setCollectionSponsorExpectSuccess(collectionId, alice.address);
29    await confirmSponsorshipExpectSuccess(collectionId);
30
31    await helpers.methods.toggleAllowed(matcher.options.address, subToEth(alice.address), true).send({from: matcherOwner});
32    await addToAllowListExpectSuccess(alice, collectionId, evmToAddress(subToEth(alice.address)));
2533
26    const seller = privateKey('//Bob');34    const seller = privateKey('//Bob');
27
28    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT', seller.address);35    await helpers.methods.toggleAllowed(matcher.options.address, subToEth(seller.address), true).send({from: matcherOwner});
29
30    // To transfer item to matcher it first needs to be transfered to EVM account of bob
31    await transferExpectSuccess(collectionId, tokenId, seller, {Ethereum: subToEth(seller.address)});36    await addToAllowListExpectSuccess(alice, collectionId, evmToAddress(subToEth(seller.address)));
32    // Fees will be paid from EVM account, so we should have some balance here37
33    await transferBalanceExpectSuccess(api, seller, evmToAddress(subToEth(seller.address)), 10n ** 18n);38    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT', seller.address);
39
40    // To transfer item to matcher it first needs to be transfered to EVM account of bob
34    await transferBalanceExpectSuccess(api, alice, evmToAddress(subToEth(alice.address)), 10n ** 18n);41    await transferExpectSuccess(collectionId, tokenId, seller, {Ethereum: subToEth(seller.address)});
3542
36    // Token is owned by seller initially43    // Token is owned by seller initially
37    expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal({Ethereum: subToEthLowercase(seller.address)});44    expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal({Ethereum: subToEthLowercase(seller.address)});
3845
39    // Ask46    // Ask
40    {47    {
41      await executeEthTxOnSub(api, seller, evmCollection, m => m.approve(matcher.options.address, tokenId));48      await executeEthTxOnSub(api, seller, evmCollection, m => m.approve(matcher.options.address, tokenId));
42      await executeEthTxOnSub(api, seller, matcher, m => m.setAsk(PRICE, '0x0000000000000000000000000000000000000000', evmCollection.options.address, tokenId, 1));49      await executeEthTxOnSub(api, seller, matcher, m => m.addAsk(PRICE, '0x0000000000000000000000000000000000000001', evmCollection.options.address, tokenId));
43    }50    }
4451
45    // Token is transferred to matcher52    // Token is transferred to matcher
64    expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal({Substrate: alice.address});71    expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal({Substrate: alice.address});
65  });72  });
6673
74  // selling for custom tokens excluded from release
67  itWeb3('With custom ERC20', async ({api, web3}) => {75  itWeb3.skip('With custom ERC20', async ({api, web3}) => {
68    const matcherOwner = await createEthAccountWithBalance(api, web3);76    const matcherOwner = await createEthAccountWithBalance(api, web3);
69    const matcherContract = new web3.eth.Contract(JSON.parse((await readFile(`${__dirname}/MarketPlaceUNQ.abi`)).toString()), undefined, {77    const matcherContract = new web3.eth.Contract(JSON.parse((await readFile(`${__dirname}/MarketPlace.abi`)).toString()), undefined, {
70      from: matcherOwner,78      from: matcherOwner,
71      ...GAS_ARGS,79      ...GAS_ARGS,
72    });80    });
73    const matcher = await matcherContract.deploy({data: (await readFile(`${__dirname}/MarketPlaceUNQ.bin`)).toString()}).send({from: matcherOwner});81    const matcher = await matcherContract.deploy({data: (await readFile(`${__dirname}/MarketPlace.bin`)).toString(), arguments: [matcherOwner]}).send({from: matcherOwner});
7482
75    const alice = privateKey('//Alice');83    const alice = privateKey('//Alice');
76    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});84    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
131  itWeb3('With escrow', async ({api, web3}) => {139  itWeb3('With escrow', async ({api, web3}) => {
132    const matcherOwner = await createEthAccountWithBalance(api, web3);140    const matcherOwner = await createEthAccountWithBalance(api, web3);
133    const escrow = await createEthAccountWithBalance(api, web3);141    const escrow = await createEthAccountWithBalance(api, web3);
134    const matcherContract = new web3.eth.Contract(JSON.parse((await readFile(`${__dirname}/MarketPlaceKSM.abi`)).toString()), undefined, {142    const matcherContract = new web3.eth.Contract(JSON.parse((await readFile(`${__dirname}/MarketPlace.abi`)).toString()), undefined, {
135      from: matcherOwner,143      from: matcherOwner,
136      ...GAS_ARGS,144      ...GAS_ARGS,
137    });145    });
138    const matcher = await matcherContract.deploy({data: (await readFile(`${__dirname}/MarketPlaceKSM.bin`)).toString(), arguments: [escrow]}).send({from: matcherOwner});146    const matcher = await matcherContract.deploy({data: (await readFile(`${__dirname}/MarketPlace.bin`)).toString(), arguments: [matcherOwner]}).send({from: matcherOwner});
139147    await matcher.methods.setEscrow(escrow).send({from: matcherOwner});
140    const ksmToken = 11;148    const helpers = contractHelpers(web3, matcherOwner);
149    await helpers.methods.toggleSponsoring(matcher.options.address, true).send({from: matcherOwner});
150    await helpers.methods.setSponsoringRateLimit(matcher.options.address, 1).send({from: matcherOwner});
141151
142    const alice = privateKey('//Alice');152    const alice = privateKey('//Alice');
143    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});153    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
144    const evmCollection = new web3.eth.Contract(nonFungibleAbi as any, collectionIdToAddress(collectionId), {from: matcherOwner});154    const evmCollection = new web3.eth.Contract(nonFungibleAbi as any, collectionIdToAddress(collectionId), {from: matcherOwner});
155    await setCollectionSponsorExpectSuccess(collectionId, alice.address);
156    await confirmSponsorshipExpectSuccess(collectionId);
157
158    await helpers.methods.toggleAllowed(matcher.options.address, subToEth(alice.address), true).send({from: matcherOwner});
159    await addToAllowListExpectSuccess(alice, collectionId, evmToAddress(subToEth(alice.address)));
145160
146    const seller = privateKey('//Bob');161    const seller = privateKey('//Bob');
147
148    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT', seller.address);162    await helpers.methods.toggleAllowed(matcher.options.address, subToEth(seller.address), true).send({from: matcherOwner});
149
150    // To transfer item to matcher it first needs to be transfered to EVM account of bob
151    await transferExpectSuccess(collectionId, tokenId, seller, {Ethereum: subToEth(seller.address)});163    await addToAllowListExpectSuccess(alice, collectionId, evmToAddress(subToEth(seller.address)));
152    // Fees will be paid from EVM account, so we should have some balance here164
153    await transferBalanceExpectSuccess(api, seller, evmToAddress(subToEth(seller.address)), 10n ** 18n);165    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT', seller.address);
166
167    // To transfer item to matcher it first needs to be transfered to EVM account of bob
154    await transferBalanceExpectSuccess(api, alice, evmToAddress(subToEth(alice.address)), 10n ** 18n);168    await transferExpectSuccess(collectionId, tokenId, seller, {Ethereum: subToEth(seller.address)});
155169
156    // Token is owned by seller initially170    // Token is owned by seller initially
157    expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal({Ethereum: subToEthLowercase(seller.address)});171    expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal({Ethereum: subToEthLowercase(seller.address)});
158172
159    // Ask173    // Ask
160    {174    {
161      await executeEthTxOnSub(api, seller, evmCollection, m => m.approve(matcher.options.address, tokenId));175      await executeEthTxOnSub(api, seller, evmCollection, m => m.approve(matcher.options.address, tokenId));
162      await executeEthTxOnSub(api, seller, matcher, m => m.setAsk(PRICE, ksmToken, evmCollection.options.address, tokenId, 1));176      await executeEthTxOnSub(api, seller, matcher, m => m.addAsk(PRICE, '0x0000000000000000000000000000000000000001', evmCollection.options.address, tokenId));
163    }177    }
164178
165    // Token is transferred to matcher179    // Token is transferred to matcher
166    expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal({Ethereum: matcher.options.address.toLowerCase()});180    expect(await getTokenOwner(api, collectionId, tokenId)).to.be.deep.equal({Ethereum: matcher.options.address.toLowerCase()});
167181
168    // Give buyer KSM182    // Give buyer KSM
169    await matcher.methods.deposit(PRICE, ksmToken, subToEth(alice.address)).send({from: escrow});183    await matcher.methods.depositKSM(PRICE, subToEth(alice.address)).send({from: escrow});
170184
171    // Buy185    // Buy
172    {186    {
173      expect(await matcher.methods.escrowBalance(ksmToken, subToEth(seller.address)).call()).to.be.equal('0');187      expect(await matcher.methods.balanceKSM(subToEth(seller.address)).call()).to.be.equal('0');
174      expect(await matcher.methods.escrowBalance(ksmToken, subToEth(alice.address)).call()).to.be.equal(PRICE.toString());188      expect(await matcher.methods.balanceKSM(subToEth(alice.address)).call()).to.be.equal(PRICE.toString());
175189
176      await executeEthTxOnSub(api, alice, matcher, m => m.buy(evmCollection.options.address, tokenId));190      await executeEthTxOnSub(api, alice, matcher, m => m.buyKSM(evmCollection.options.address, tokenId, subToEth(alice.address), subToEth(alice.address)));
177191
178      // Price is removed from buyer balance, and added to seller192      // Price is removed from buyer balance, and added to seller
179      expect(await matcher.methods.escrowBalance(ksmToken, subToEth(alice.address)).call()).to.be.equal('0');193      expect(await matcher.methods.balanceKSM(subToEth(alice.address)).call()).to.be.equal('0');
180      expect(await matcher.methods.escrowBalance(ksmToken, subToEth(seller.address)).call()).to.be.equal(PRICE.toString());194      expect(await matcher.methods.balanceKSM(subToEth(seller.address)).call()).to.be.equal(PRICE.toString());
181    }195    }
182196
183    // Token is transferred to evm account of alice197    // Token is transferred to evm account of alice

78  });78  });
79});79});
8080
81describe('Sponsor timeout (NFT)', () => {81describe.skip('Sponsor timeout (NFT) (only for special chain limits test)', () => {
82  let alice: IKeyringPair;82  let alice: IKeyringPair;
83  let bob: IKeyringPair;83  let bob: IKeyringPair;
84  let charlie: IKeyringPair;84  let charlie: IKeyringPair;
91    });91    });
92  });92  });
9393
94  it('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {94  it.skip('Collection limits have greater timeout value than chain limits, collection limits are enforced', async () => {
95    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});95    const collectionId = await createCollectionExpectSuccess({mode: {type: 'NFT'}});
96    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 7});96    await setCollectionLimitsExpectSuccess(alice, collectionId, {sponsorTransferTimeout: 7});
97    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');97    const tokenId = await createItemExpectSuccess(alice, collectionId, 'NFT');
141  });141  });
142});142});
143143
144describe('Sponsor timeout (Fungible)', () => {144describe.skip('Sponsor timeout (Fungible) (only for special chain limits test)', () => {
145  let alice: IKeyringPair;145  let alice: IKeyringPair;
146  let bob: IKeyringPair;146  let bob: IKeyringPair;
147  let charlie: IKeyringPair;147  let charlie: IKeyringPair;
208  });208  });
209});209});
210210
211describe('Sponsor timeout (ReFungible)', () => {211describe.skip('Sponsor timeout (ReFungible) (only for special chain limits test)', () => {
212  let alice: IKeyringPair;212  let alice: IKeyringPair;
213  let bob: IKeyringPair;213  let bob: IKeyringPair;
214  let charlie: IKeyringPair;214  let charlie: IKeyringPair;

13chai.use(chaiAsPromised);13chai.use(chaiAsPromised);
14const expect = chai.expect;14const expect = chai.expect;
1515
16describe('Integration Test fungible overflows', () => {16describe.skip('Integration Test fungible overflows', () => {
17  let alice: IKeyringPair;17  let alice: IKeyringPair;
18  let bob: IKeyringPair;18  let bob: IKeyringPair;
19  let charlie: IKeyringPair;19  let charlie: IKeyringPair;

40      await setOffchainSchemaExpectSuccess(alice, collectionId, DATA);40      await setOffchainSchemaExpectSuccess(alice, collectionId, DATA);
41      const collection = await queryCollectionExpectSuccess(api, collectionId);41      const collection = await queryCollectionExpectSuccess(api, collectionId);
4242
43      expect(collection.offchainSchema).to.be.equal('0x' + Buffer.from(DATA).toString('hex'));43      expect('0x' + Buffer.from(collection.offchainSchema).toString('hex')).to.be.equal('0x' + Buffer.from(DATA).toString('hex'));
44    });44    });
45  });45  });
4646
51      await setOffchainSchemaExpectSuccess(bob, collectionId, DATA);51      await setOffchainSchemaExpectSuccess(bob, collectionId, DATA);
52      const collection = await queryCollectionExpectSuccess(api, collectionId);52      const collection = await queryCollectionExpectSuccess(api, collectionId);
5353
54      expect(collection.offchainSchema).to.be.equal('0x' + Buffer.from(DATA).toString('hex'));54      expect('0x' + Buffer.from(collection.offchainSchema).toString('hex')).to.be.equal('0x' + Buffer.from(DATA).toString('hex'));
55    });55    });
56  });56  });
57});57});

905  await usingApi(async (api: ApiPromise) => {905  await usingApi(async (api: ApiPromise) => {
906    const transferTx = api.tx.nft.transfer(normalizeAccountId(recipient.address), collectionId, tokenId, value);906    const transferTx = api.tx.nft.transfer(normalizeAccountId(recipient.address), collectionId, tokenId, value);
907    const events = await expect(submitTransactionExpectFailAsync(sender, transferTx)).to.be.rejected;907    const events = await expect(submitTransactionExpectFailAsync(sender, transferTx)).to.be.rejected;
908    if (events && Array.isArray(events)) {
909      const result = getCreateCollectionResult(events);908    const result = getGenericResult(events);
909    // if (events && Array.isArray(events)) {
910    //   const result = getCreateCollectionResult(events);
910      // tslint:disable-next-line:no-unused-expression911    // tslint:disable-next-line:no-unused-expression
911      expect(result.success).to.be.false;912    expect(result.success).to.be.false;
912    }913    //}
913  });914  });
914}915}
915916