difftreelog
test call fees
in: master
6 files changed
tests/src/eth/base.test.tsdiffbeforeafterboth--- /dev/null
+++ b/tests/src/eth/base.test.ts
@@ -0,0 +1,22 @@
+
+import { createEthAccount, createEthAccountWithBalance, deployFlipper, ethBalanceViaSub, GAS_ARGS, itWeb3, recordEthFee } from './util/helpers';
+import { expect } from 'chai';
+import { UNIQUE } from '../util/helpers';
+
+describe('Contract calls', () => {
+ itWeb3('Call of simple contract fee is less than 0.2 UNQ', async ({ web3, api }) => {
+ const deployer = await createEthAccountWithBalance(api, web3);
+ const flipper = await deployFlipper(web3 as any, deployer);
+
+ const cost = await recordEthFee(api, deployer, () => flipper.methods.flip());
+ expect(cost < BigInt(0.2 * Number(UNIQUE))).to.be.true;
+ });
+
+ itWeb3('Balance transfer fee is less than 0.2 UNQ', async ({ web3, api }) => {
+ const userA = await createEthAccountWithBalance(api, web3);
+ const userB = createEthAccount(web3);
+
+ const cost = await recordEthFee(api, userA, () => web3.eth.sendTransaction({ from: userA, to: userB, value: '1000000', ...GAS_ARGS }));
+ expect(cost - await ethBalanceViaSub(api, userB) < BigInt(0.2 * Number(UNIQUE))).to.be.true;
+ });
+});
\ No newline at end of file
tests/src/eth/fungible.test.tsdiffbeforeafterboth--- a/tests/src/eth/fungible.test.ts
+++ b/tests/src/eth/fungible.test.ts
@@ -4,8 +4,8 @@
//
import privateKey from '../substrate/privateKey';
-import { approveExpectSuccess, createCollectionExpectSuccess, createFungibleItemExpectSuccess, transferExpectSuccess, transferFromExpectSuccess } from '../util/helpers';
-import { collectionIdToAddress, createEthAccount, createEthAccountWithBalance, GAS_ARGS, itWeb3, normalizeEvents, recordEvents, subToEth, transferBalanceToEth } from './util/helpers';
+import { approveExpectSuccess, createCollectionExpectSuccess, createFungibleItemExpectSuccess, transferExpectSuccess, transferFromExpectSuccess, UNIQUE } from '../util/helpers';
+import { collectionIdToAddress, createEthAccount, createEthAccountWithBalance, GAS_ARGS, itWeb3, normalizeEvents, recordEthFee, recordEvents, subToEth, transferBalanceToEth } from './util/helpers';
import fungibleAbi from './fungibleAbi.json';
import { expect } from 'chai';
@@ -192,6 +192,64 @@
});
});
+describe('Fungible: Fees', () => {
+ itWeb3('approve() call fee is less than 0.2UNQ', async ({ web3, api }) => {
+ const collection = await createCollectionExpectSuccess({
+ mode: { type: 'Fungible', decimalPoints: 0 },
+ });
+ const alice = privateKey('//Alice');
+
+ const owner = await createEthAccountWithBalance(api, web3);
+ const spender = createEthAccount(web3);
+
+ await createFungibleItemExpectSuccess(alice, collection, { Value: 200n }, { ethereum: owner });
+
+ const address = collectionIdToAddress(collection);
+ const contract = new web3.eth.Contract(fungibleAbi as any, address, { from: owner, ...GAS_ARGS });
+
+ const cost = await recordEthFee(api, owner, () => contract.methods.approve(spender, 100).send({ from: owner }));
+ expect(cost < BigInt(0.2 * Number(UNIQUE)));
+ });
+
+ itWeb3('transferFrom() call fee is less than 0.2UNQ', async ({ web3, api }) => {
+ const collection = await createCollectionExpectSuccess({
+ mode: {type: 'Fungible', decimalPoints: 0},
+ });
+ const alice = privateKey('//Alice');
+
+ const owner = await createEthAccountWithBalance(api, web3);
+ const spender = await createEthAccountWithBalance(api, web3);
+
+ await createFungibleItemExpectSuccess(alice, collection, { Value: 200n }, { ethereum: owner });
+
+ const address = collectionIdToAddress(collection);
+ const contract = new web3.eth.Contract(fungibleAbi as any, address, { from: owner, ...GAS_ARGS });
+
+ await contract.methods.approve(spender, 100).send({ from: owner });
+
+ const cost = await recordEthFee(api, spender, () => contract.methods.transferFrom(owner, spender, 100).send({ from: spender }));
+ expect(cost < BigInt(0.2 * Number(UNIQUE)));
+ });
+
+ itWeb3('transfer() call fee is less than 0.2UNQ', async ({ web3, api }) => {
+ const collection = await createCollectionExpectSuccess({
+ mode: { type: 'Fungible', decimalPoints: 0 },
+ });
+ const alice = privateKey('//Alice');
+
+ const owner = await createEthAccountWithBalance(api, web3);
+ const receiver = createEthAccount(web3);
+
+ await createFungibleItemExpectSuccess(alice, collection, { Value: 200n }, { ethereum: owner });
+
+ const address = collectionIdToAddress(collection);
+ const contract = new web3.eth.Contract(fungibleAbi as any, address, { from: owner, ...GAS_ARGS });
+
+ const cost = await recordEthFee(api, owner, () => contract.methods.transfer(receiver, 100).send({ from: owner }));
+ expect(cost < BigInt(0.2 * Number(UNIQUE)));
+ });
+});
+
describe('Fungible: Substrate calls', () => {
itWeb3('Events emitted for approve()', async ({ web3 }) => {
const collection = await createCollectionExpectSuccess({
tests/src/eth/helpersSmoke.test.tsdiffbeforeafterboth--- a/tests/src/eth/helpersSmoke.test.ts
+++ b/tests/src/eth/helpersSmoke.test.ts
@@ -1,26 +1,24 @@
import { expect } from 'chai';
import waitNewBlocks from '../substrate/wait-new-blocks';
-import { createEthAccountWithBalance, deployFlipper, itWeb3, usingWeb3Http, contractHelpers } from './util/helpers';
+import { createEthAccountWithBalance, deployFlipper, itWeb3, contractHelpers } from './util/helpers';
-itWeb3('Contract owner is recorded', async ({ api, web3 }) => {
- await usingWeb3Http(async web3Http => {
- const owner = await createEthAccountWithBalance(api, web3Http);
+describe('Helpers sanity check', () => {
+ itWeb3('Contract owner is recorded', async ({ api, web3 }) => {
+ const owner = await createEthAccountWithBalance(api, web3);
- const flipper = await deployFlipper(web3Http, owner);
+ const flipper = await deployFlipper(web3, owner);
await waitNewBlocks(api, 1);
expect(await contractHelpers(web3, owner).methods.contractOwner(flipper.options.address).call()).to.be.equal(owner);
});
-});
-itWeb3('Flipper is working', async({api}) => {
- await usingWeb3Http(async web3Http => {
- const owner = await createEthAccountWithBalance(api, web3Http);
- const flipper = await deployFlipper(web3Http, owner);
+ itWeb3('Flipper is working', async ({ api, web3 }) => {
+ const owner = await createEthAccountWithBalance(api, web3);
+ const flipper = await deployFlipper(web3, owner);
await waitNewBlocks(api, 1);
expect(await flipper.methods.getValue().call()).to.be.false;
- await flipper.methods.flip().send({from: owner});
+ await flipper.methods.flip().send({ from: owner });
await waitNewBlocks(api, 1);
expect(await flipper.methods.getValue().call()).to.be.true;
});
tests/src/eth/nonFungible.test.tsdiffbeforeafterboth--- a/tests/src/eth/nonFungible.test.ts
+++ b/tests/src/eth/nonFungible.test.ts
@@ -4,8 +4,8 @@
//
import privateKey from '../substrate/privateKey';
-import { approveExpectSuccess, createCollectionExpectSuccess, createItemExpectSuccess, transferExpectSuccess, transferFromExpectSuccess } from '../util/helpers';
-import { collectionIdToAddress, createEthAccount, createEthAccountWithBalance, GAS_ARGS, itWeb3, normalizeEvents, recordEvents, subToEth, transferBalanceToEth } from './util/helpers';
+import { approveExpectSuccess, createCollectionExpectSuccess, createItemExpectSuccess, transferExpectSuccess, transferFromExpectSuccess, UNIQUE } from '../util/helpers';
+import { collectionIdToAddress, createEthAccount, createEthAccountWithBalance, GAS_ARGS, itWeb3, normalizeEvents, recordEthFee, recordEvents, subToEth, transferBalanceToEth } from './util/helpers';
import nonFungibleAbi from './nonFungibleAbi.json';
import { expect } from 'chai';
import waitNewBlocks from '../substrate/wait-new-blocks';
@@ -192,6 +192,64 @@
});
});
+describe('NFT: Fees', () => {
+ itWeb3('approve() call fee is less than 0.2UNQ', async ({ web3, api }) => {
+ const collection = await createCollectionExpectSuccess({
+ mode: { type: 'NFT' },
+ });
+ const alice = privateKey('//Alice');
+
+ const owner = await createEthAccountWithBalance(api, web3);
+ const spender = createEthAccount(web3);
+
+ const tokenId = await createItemExpectSuccess(alice, collection, 'NFT', { ethereum: owner });
+
+ const address = collectionIdToAddress(collection);
+ const contract = new web3.eth.Contract(nonFungibleAbi as any, address, { from: owner, ...GAS_ARGS });
+
+ const cost = await recordEthFee(api, owner, () => contract.methods.approve(spender, tokenId).send({ from: owner }));
+ expect(cost < BigInt(0.2 * Number(UNIQUE)));
+ });
+
+ itWeb3('transferFrom() call fee is less than 0.2UNQ', async ({ web3, api }) => {
+ const collection = await createCollectionExpectSuccess({
+ mode: { type: 'NFT' },
+ });
+ const alice = privateKey('//Alice');
+
+ const owner = await createEthAccountWithBalance(api, web3);
+ const spender = await createEthAccountWithBalance(api, web3);
+
+ const tokenId = await createItemExpectSuccess(alice, collection, 'NFT', { ethereum: owner });
+
+ const address = collectionIdToAddress(collection);
+ const contract = new web3.eth.Contract(nonFungibleAbi as any, address, { from: owner, ...GAS_ARGS });
+
+ await contract.methods.approve(spender, tokenId).send({ from: owner });
+
+ const cost = await recordEthFee(api, spender, () => contract.methods.transferFrom(owner, spender, tokenId).send({ from: spender }));
+ expect(cost < BigInt(0.2 * Number(UNIQUE)));
+ });
+
+ itWeb3('transfer() call fee is less than 0.2UNQ', async ({ web3, api }) => {
+ const collection = await createCollectionExpectSuccess({
+ mode: { type: 'NFT' },
+ });
+ const alice = privateKey('//Alice');
+
+ const owner = await createEthAccountWithBalance(api, web3);
+ const receiver = createEthAccount(web3);
+
+ const tokenId = await createItemExpectSuccess(alice, collection, 'NFT', { ethereum: owner });
+
+ const address = collectionIdToAddress(collection);
+ const contract = new web3.eth.Contract(nonFungibleAbi as any, address, { from: owner, ...GAS_ARGS });
+
+ const cost = await recordEthFee(api, owner, () => contract.methods.transfer(receiver, tokenId).send({ from: owner }));
+ expect(cost < BigInt(0.2 * Number(UNIQUE)));
+ });
+});
+
describe('NFT: Substrate calls', () => {
itWeb3('Events emitted for approve()', async ({ web3 }) => {
const collection = await createCollectionExpectSuccess({
tests/src/eth/util/helpers.tsdiffbeforeafterboth--- a/tests/src/eth/util/helpers.ts
+++ b/tests/src/eth/util/helpers.ts
@@ -17,6 +17,7 @@
import config from '../../config';
import privateKey from '../../substrate/privateKey';
import contractHelpersAbi from './contractHelpersAbi.json';
+import getBalance from '../../substrate/get-balance';
export const GAS_ARGS = { gas: 0x1000000, gasPrice: '0x01' };
@@ -221,4 +222,21 @@
export function contractHelpers(web3: Web3, caller: string) {
return new web3.eth.Contract(contractHelpersAbi as any, '0x842899ECF380553E8a4de75bF534cdf6fBF64049', {from: caller, ...GAS_ARGS});
+}
+
+export async function ethBalanceViaSub(api: ApiPromise, address: string): Promise<bigint> {
+ return (await getBalance(api, [evmToAddress(address)]))[0];
+}
+
+export async function recordEthFee(api: ApiPromise, user: string, call: () => Promise<any>): Promise<bigint> {
+ const before = await ethBalanceViaSub(api, user);
+
+ await call();
+
+ const after = await ethBalanceViaSub(api, user);
+
+ // Can't use .to.be.less, because chai doesn't supports bigint
+ expect(after < before).to.be.true;
+
+ return before - after;
}
\ No newline at end of file
tests/src/util/helpers.tsdiffbeforeafterboth1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56import { ApiPromise, Keyring } from '@polkadot/api';7import type { AccountId, EventRecord } from '@polkadot/types/interfaces';8import { IKeyringPair } from '@polkadot/types/types';9import { evmToAddress } from '@polkadot/util-crypto';10import { BigNumber } from 'bignumber.js';11import BN from 'bn.js';12import chai from 'chai';13import chaiAsPromised from 'chai-as-promised';14import { alicesPublicKey } from '../accounts';15import privateKey from '../substrate/privateKey';16import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from '../substrate/substrate-api';17import { ICollectionInterface } from '../types';18import { hexToStr, strToUTF16, utf16ToStr } from './util';1920chai.use(chaiAsPromised);21const expect = chai.expect;2223export type CrossAccountId = {24 substrate: string,25} | {26 ethereum: string,27};28export function normalizeAccountId(input: string | AccountId | CrossAccountId | IKeyringPair): CrossAccountId {29 if (typeof input === 'string')30 return { substrate: input };31 if ('address' in input) {32 return { substrate: input.address };33 }34 if ('ethereum' in input) {35 input.ethereum = input.ethereum.toLowerCase();36 return input;37 }38 if ('substrate' in input) {39 return input;40 }4142 // AccountId43 return {substrate: input.toString()};44}45export function toSubstrateAddress(input: string | CrossAccountId | IKeyringPair): string {46 input = normalizeAccountId(input);47 if ('substrate' in input) {48 return input.substrate;49 } else {50 return evmToAddress(input.ethereum);51 }52}5354export const U128_MAX = (1n << 128n) - 1n;5556type GenericResult = {57 success: boolean,58};5960interface CreateCollectionResult {61 success: boolean;62 collectionId: number;63}6465interface CreateItemResult {66 success: boolean;67 collectionId: number;68 itemId: number;69 recipient?: CrossAccountId;70}7172interface TransferResult {73 success: boolean;74 collectionId: number;75 itemId: number;76 sender?: CrossAccountId;77 recipient?: CrossAccountId;78 value: bigint;79}8081interface IReFungibleOwner {82 Fraction: BN;83 Owner: number[];84}8586interface ITokenDataType {87 Owner: IKeyringPair;88 ConstData: number[];89 VariableData: number[];90}9192interface IGetMessage {93 checkMsgNftMethod: string;94 checkMsgTrsMethod: string;95 checkMsgSysMethod: string;96}9798export interface IFungibleTokenDataType {99 Value: number;100}101102export interface IChainLimits {103 CollectionNumbersLimit: number;104 AccountTokenOwnershipLimit: number;105 CollectionsAdminsLimit: number;106 CustomDataLimit: number;107 NftSponsorTransferTimeout: number;108 FungibleSponsorTransferTimeout: number;109 RefungibleSponsorTransferTimeout: number;110 OffchainSchemaLimit: number;111 VariableOnChainSchemaLimit: number;112 ConstOnChainSchemaLimit: number;113}114115export interface IReFungibleTokenDataType {116 Owner: IReFungibleOwner[];117 ConstData: number[];118 VariableData: number[];119}120121export function nftEventMessage(events: EventRecord[]): IGetMessage {122 let checkMsgNftMethod = '';123 let checkMsgTrsMethod = '';124 let checkMsgSysMethod = '';125 events.forEach(({ event: { method, section } }) => {126 if (section === 'nft') {127 checkMsgNftMethod = method;128 } else if (section === 'treasury') {129 checkMsgTrsMethod = method;130 } else if (section === 'system') {131 checkMsgSysMethod = method;132 } else { return null; }133 });134 const result: IGetMessage = {135 checkMsgNftMethod,136 checkMsgTrsMethod,137 checkMsgSysMethod,138 };139 return result;140}141142export function getGenericResult(events: EventRecord[]): GenericResult {143 const result: GenericResult = {144 success: false,145 };146 events.forEach(({ event: { method } }) => {147 // console.log(` ${phase}: ${section}.${method}:: ${data}`);148 if (method === 'ExtrinsicSuccess') {149 result.success = true;150 }151 });152 return result;153}154155156157export function getCreateCollectionResult(events: EventRecord[]): CreateCollectionResult {158 let success = false;159 let collectionId = 0;160 events.forEach(({ event: { data, method, section } }) => {161 // console.log(` ${phase}: ${section}.${method}:: ${data}`);162 if (method == 'ExtrinsicSuccess') {163 success = true;164 } else if ((section == 'nft') && (method == 'CollectionCreated')) {165 collectionId = parseInt(data[0].toString());166 }167 });168 const result: CreateCollectionResult = {169 success,170 collectionId,171 };172 return result;173}174175export function getCreateItemResult(events: EventRecord[]): CreateItemResult {176 let success = false;177 let collectionId = 0;178 let itemId = 0;179 let recipient;180 events.forEach(({ event: { data, method, section } }) => {181 // console.log(` ${phase}: ${section}.${method}:: ${data}`);182 if (method == 'ExtrinsicSuccess') {183 success = true;184 } else if ((section == 'nft') && (method == 'ItemCreated')) {185 collectionId = parseInt(data[0].toString());186 itemId = parseInt(data[1].toString());187 recipient = data[2].toJSON();188 }189 });190 const result: CreateItemResult = {191 success,192 collectionId,193 itemId,194 recipient,195 };196 return result;197}198199export function getTransferResult(events: EventRecord[]): TransferResult {200 const result: TransferResult = {201 success: false,202 collectionId: 0,203 itemId: 0,204 value: 0n,205 };206207 events.forEach(({ event: { data, method, section } }) => {208 if (method === 'ExtrinsicSuccess') {209 result.success = true;210 } else if (section === 'nft' && method === 'Transfer') {211 result.collectionId = +data[0].toString();212 result.itemId = +data[1].toString();213 result.sender = data[2].toJSON() as CrossAccountId;214 result.recipient = data[3].toJSON() as CrossAccountId;215 result.value = BigInt(data[4].toString());216 }217 });218219 return result;220}221222interface Invalid {223 type: 'Invalid';224}225226interface Nft {227 type: 'NFT';228}229230interface Fungible {231 type: 'Fungible';232 decimalPoints: number;233}234235interface ReFungible {236 type: 'ReFungible';237}238239type CollectionMode = Nft | Fungible | ReFungible | Invalid;240241export type CreateCollectionParams = {242 mode: CollectionMode,243 name: string,244 description: string,245 tokenPrefix: string,246};247248const defaultCreateCollectionParams: CreateCollectionParams = {249 description: 'description',250 mode: { type: 'NFT' },251 name: 'name',252 tokenPrefix: 'prefix',253};254255export async function createCollectionExpectSuccess(params: Partial<CreateCollectionParams> = {}): Promise<number> {256 const { name, description, mode, tokenPrefix } = { ...defaultCreateCollectionParams, ...params };257258 let collectionId = 0;259 await usingApi(async (api) => {260 // Get number of collections before the transaction261 const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10);262263 // Run the CreateCollection transaction264 const alicePrivateKey = privateKey('//Alice');265266 let modeprm = {};267 if (mode.type === 'NFT') {268 modeprm = { nft: null };269 } else if (mode.type === 'Fungible') {270 modeprm = { fungible: mode.decimalPoints };271 } else if (mode.type === 'ReFungible') {272 modeprm = { refungible: null };273 } else if (mode.type === 'Invalid') {274 modeprm = { invalid: null };275 }276277 const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), modeprm);278 const events = await submitTransactionAsync(alicePrivateKey, tx);279 const result = getCreateCollectionResult(events);280281 // Get number of collections after the transaction282 const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10);283284 // Get the collection285 const collection: any = (await api.query.nft.collectionById(result.collectionId) as any).toJSON();286287 // What to expect288 // tslint:disable-next-line:no-unused-expression289 expect(result.success).to.be.true;290 expect(result.collectionId).to.be.equal(BcollectionCount);291 // tslint:disable-next-line:no-unused-expression292 expect(collection).to.be.not.null;293 expect(BcollectionCount).to.be.equal(AcollectionCount + 1, 'Error: NFT collection NOT created.');294 expect(collection.Owner).to.be.equal(toSubstrateAddress(alicesPublicKey));295 expect(utf16ToStr(collection.Name)).to.be.equal(name);296 expect(utf16ToStr(collection.Description)).to.be.equal(description);297 expect(hexToStr(collection.TokenPrefix)).to.be.equal(tokenPrefix);298299 collectionId = result.collectionId;300 });301302 return collectionId;303}304305export async function createCollectionExpectFailure(params: Partial<CreateCollectionParams> = {}) {306 const { name, description, mode, tokenPrefix } = { ...defaultCreateCollectionParams, ...params };307308 let modeprm = {};309 if (mode.type === 'NFT') {310 modeprm = { nft: null };311 } else if (mode.type === 'Fungible') {312 modeprm = { fungible: mode.decimalPoints };313 } else if (mode.type === 'ReFungible') {314 modeprm = { refungible: null };315 } else if (mode.type === 'Invalid') {316 modeprm = { invalid: null };317 }318319 await usingApi(async (api) => {320 // Get number of collections before the transaction321 const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());322323 // Run the CreateCollection transaction324 const alicePrivateKey = privateKey('//Alice');325 const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), modeprm);326 const events = await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;327 const result = getCreateCollectionResult(events);328329 // Get number of collections after the transaction330 const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());331332 // What to expect333 // tslint:disable-next-line:no-unused-expression334 expect(result.success).to.be.false;335 expect(BcollectionCount).to.be.equal(AcollectionCount, 'Error: Collection with incorrect data created.');336 });337}338339export async function findUnusedAddress(api: ApiPromise, seedAddition = ''): Promise<IKeyringPair> {340 let bal = new BigNumber(0);341 let unused;342 do {343 const randomSeed = 'seed' + Math.floor(Math.random() * Math.floor(10000)) + seedAddition;344 const keyring = new Keyring({ type: 'sr25519' });345 unused = keyring.addFromUri(`//${randomSeed}`);346 bal = new BigNumber((await api.query.system.account(unused.address)).data.free.toString());347 } while (bal.toFixed() != '0');348 return unused;349}350351export async function getAllowance(collectionId: number, tokenId: number, owner: string, approved: string) {352 return await usingApi(async (api) => {353 const bn = await api.query.nft.allowances(collectionId, [tokenId, owner, approved]) as unknown as BN;354 return BigInt(bn.toString());355 });356}357358export function findUnusedAddresses(api: ApiPromise, amount: number): Promise<IKeyringPair[]> {359 return Promise.all(new Array(amount).fill(null).map(() => findUnusedAddress(api, '_' + Date.now())));360}361362export async function findNotExistingCollection(api: ApiPromise): Promise<number> {363 const totalNumber = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10) as unknown as number;364 const newCollection: number = totalNumber + 1;365 return newCollection;366}367368function getDestroyResult(events: EventRecord[]): boolean {369 let success = false;370 events.forEach(({ event: { method } }) => {371 if (method == 'ExtrinsicSuccess') {372 success = true;373 }374 });375 return success;376}377378export async function destroyCollectionExpectFailure(collectionId: number, senderSeed = '//Alice') {379 await usingApi(async (api) => {380 // Run the DestroyCollection transaction381 const alicePrivateKey = privateKey(senderSeed);382 const tx = api.tx.nft.destroyCollection(collectionId);383 await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;384 });385}386387export async function destroyCollectionExpectSuccess(collectionId: number, senderSeed = '//Alice') {388 await usingApi(async (api) => {389 // Run the DestroyCollection transaction390 const alicePrivateKey = privateKey(senderSeed);391 const tx = api.tx.nft.destroyCollection(collectionId);392 const events = await submitTransactionAsync(alicePrivateKey, tx);393 const result = getDestroyResult(events);394395 // Get the collection396 const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();397398 // What to expect399 expect(result).to.be.true;400 expect(collection).to.be.null;401 });402}403404export async function queryCollectionLimits(collectionId: number) {405 return await usingApi(async (api) => {406 return ((await api.query.nft.collectionById(collectionId)).toJSON() as any).Limits;407 });408}409410export async function setCollectionLimitsExpectSuccess(sender: IKeyringPair, collectionId: number, limits: any) {411 await usingApi(async (api) => {412 const oldLimits = await queryCollectionLimits(collectionId);413 const newLimits = { ...oldLimits as any, ...limits };414 const tx = api.tx.nft.setCollectionLimits(collectionId, newLimits);415 const events = await submitTransactionAsync(sender, tx);416 const result = getGenericResult(events);417418 expect(result.success).to.be.true;419 });420}421422export async function setCollectionLimitsExpectFailure(sender: IKeyringPair, collectionId: number, limits: any) {423 await usingApi(async (api) => {424 const oldLimits = await queryCollectionLimits(collectionId);425 const newLimits = { ...oldLimits as any, ...limits };426 const tx = api.tx.nft.setCollectionLimits(collectionId, newLimits);427 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;428 const result = getGenericResult(events);429430 expect(result.success).to.be.false;431 });432}433434export async function setCollectionSponsorExpectSuccess(collectionId: number, sponsor: string, sender = '//Alice') {435 await usingApi(async (api) => {436437 // Run the transaction438 const senderPrivateKey = privateKey(sender);439 const tx = api.tx.nft.setCollectionSponsor(collectionId, sponsor);440 const events = await submitTransactionAsync(senderPrivateKey, tx);441 const result = getGenericResult(events);442443 // Get the collection444 const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();445446 // What to expect447 expect(result.success).to.be.true;448 expect(collection.Sponsorship).to.deep.equal({449 unconfirmed: sponsor,450 });451 });452}453454export async function removeCollectionSponsorExpectSuccess(collectionId: number, sender = '//Alice') {455 await usingApi(async (api) => {456457 // Run the transaction458 const alicePrivateKey = privateKey(sender);459 const tx = api.tx.nft.removeCollectionSponsor(collectionId);460 const events = await submitTransactionAsync(alicePrivateKey, tx);461 const result = getGenericResult(events);462463 // Get the collection464 const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();465466 // What to expect467 expect(result.success).to.be.true;468 expect(collection.Sponsorship).to.be.deep.equal({ disabled: null });469 });470}471472export async function removeCollectionSponsorExpectFailure(collectionId: number, senderSeed = '//Alice') {473 await usingApi(async (api) => {474475 // Run the transaction476 const alicePrivateKey = privateKey(senderSeed);477 const tx = api.tx.nft.removeCollectionSponsor(collectionId);478 await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;479 });480}481482export async function setCollectionSponsorExpectFailure(collectionId: number, sponsor: string, senderSeed = '//Alice') {483 await usingApi(async (api) => {484485 // Run the transaction486 const alicePrivateKey = privateKey(senderSeed);487 const tx = api.tx.nft.setCollectionSponsor(collectionId, sponsor);488 await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;489 });490}491492export async function confirmSponsorshipExpectSuccess(collectionId: number, senderSeed = '//Alice') {493 await usingApi(async (api) => {494495 // Run the transaction496 const sender = privateKey(senderSeed);497 const tx = api.tx.nft.confirmSponsorship(collectionId);498 const events = await submitTransactionAsync(sender, tx);499 const result = getGenericResult(events);500501 // Get the collection502 const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();503504 // What to expect505 expect(result.success).to.be.true;506 expect(collection.Sponsorship).to.be.deep.equal({507 confirmed: sender.address,508 });509 });510}511512513export async function confirmSponsorshipExpectFailure(collectionId: number, senderSeed = '//Alice') {514 await usingApi(async (api) => {515516 // Run the transaction517 const sender = privateKey(senderSeed);518 const tx = api.tx.nft.confirmSponsorship(collectionId);519 await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;520 });521}522523export async function enableContractSponsoringExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {524 await usingApi(async (api) => {525 const tx = api.tx.nft.enableContractSponsoring(contractAddress, enable);526 const events = await submitTransactionAsync(sender, tx);527 const result = getGenericResult(events);528529 expect(result.success).to.be.true;530 });531}532533export async function enableContractSponsoringExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {534 await usingApi(async (api) => {535 const tx = api.tx.nft.enableContractSponsoring(contractAddress, enable);536 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;537 const result = getGenericResult(events);538539 expect(result.success).to.be.false;540 });541}542543export async function setTransferFlagExpectSuccess(sender: IKeyringPair, collectionId: number, enabled: boolean) {544545 await usingApi(async (api) => {546547 const tx = api.tx.nft.setTransfersEnabledFlag (collectionId, enabled);548 const events = await submitTransactionAsync(sender, tx);549 const result = getGenericResult(events);550551 expect(result.success).to.be.true;552 }); 553}554555export async function setTransferFlagExpectFailure(sender: IKeyringPair, collectionId: number, enabled: boolean) {556557 await usingApi(async (api) => {558559 const tx = api.tx.nft.setTransfersEnabledFlag (collectionId, enabled);560 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;561 const result = getGenericResult(events);562563 expect(result.success).to.be.false;564 }); 565}566567export async function setContractSponsoringRateLimitExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {568 await usingApi(async (api) => {569 const tx = api.tx.nft.setContractSponsoringRateLimit(contractAddress, rateLimit);570 const events = await submitTransactionAsync(sender, tx);571 const result = getGenericResult(events);572573 expect(result.success).to.be.true;574 });575}576577export async function setContractSponsoringRateLimitExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {578 await usingApi(async (api) => {579 const tx = api.tx.nft.setContractSponsoringRateLimit(contractAddress, rateLimit);580 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;581 const result = getGenericResult(events);582583 expect(result.success).to.be.false;584 });585}586587export async function toggleContractWhitelistExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, value = true) {588 await usingApi(async (api) => {589 const tx = api.tx.nft.toggleContractWhiteList(contractAddress, value);590 const events = await submitTransactionAsync(sender, tx);591 const result = getGenericResult(events);592593 expect(result.success).to.be.true;594 });595}596597export async function isWhitelistedInContract(contractAddress: AccountId | string, user: string) {598 let whitelisted = false;599 await usingApi(async (api) => {600 whitelisted = (await api.query.nft.contractWhiteList(contractAddress, user)).toJSON() as boolean;601 });602 return whitelisted;603}604605export async function addToContractWhiteListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {606 await usingApi(async (api) => {607 const tx = api.tx.nft.addToContractWhiteList(contractAddress.toString(), user.toString());608 const events = await submitTransactionAsync(sender, tx);609 const result = getGenericResult(events);610611 expect(result.success).to.be.true;612 });613}614615export async function removeFromContractWhiteListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {616 await usingApi(async (api) => {617 const tx = api.tx.nft.removeFromContractWhiteList(contractAddress.toString(), user.toString());618 const events = await submitTransactionAsync(sender, tx);619 const result = getGenericResult(events);620621 expect(result.success).to.be.true;622 });623}624625export async function removeFromContractWhiteListExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {626 await usingApi(async (api) => {627 const tx = api.tx.nft.removeFromContractWhiteList(contractAddress.toString(), user.toString());628 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;629 const result = getGenericResult(events);630631 expect(result.success).to.be.false;632 });633}634635export async function setVariableMetaDataExpectSuccess(sender: IKeyringPair, collectionId: number, itemId: number, data: number[]) {636 await usingApi(async (api) => {637 const tx = api.tx.nft.setVariableMetaData(collectionId, itemId, '0x' + Buffer.from(data).toString('hex'));638 const events = await submitTransactionAsync(sender, tx);639 const result = getGenericResult(events);640641 expect(result.success).to.be.true;642 });643}644645export async function setVariableMetaDataExpectFailure(sender: IKeyringPair, collectionId: number, itemId: number, data: number[]) {646 await usingApi(async (api) => {647 const tx = api.tx.nft.setVariableMetaData(collectionId, itemId, '0x' + Buffer.from(data).toString('hex'));648 await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;649 });650}651652export async function setOffchainSchemaExpectSuccess(sender: IKeyringPair, collectionId: number, data: number[]) {653 await usingApi(async (api) => {654 const tx = api.tx.nft.setOffchainSchema(collectionId, '0x' + Buffer.from(data).toString('hex'));655 const events = await submitTransactionAsync(sender, tx);656 const result = getGenericResult(events);657658 expect(result.success).to.be.true;659 });660}661662export async function setOffchainSchemaExpectFailure(sender: IKeyringPair, collectionId: number, data: number[]) {663 await usingApi(async (api) => {664 const tx = api.tx.nft.setOffchainSchema(collectionId, '0x' + Buffer.from(data).toString('hex'));665 await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;666 });667}668669export interface CreateFungibleData {670 readonly Value: bigint;671}672673export interface CreateReFungibleData { }674export interface CreateNftData { }675676export type CreateItemData = {677 NFT: CreateNftData;678} | {679 Fungible: CreateFungibleData;680} | {681 ReFungible: CreateReFungibleData;682};683684export async function burnItemExpectSuccess(owner: IKeyringPair, collectionId: number, tokenId: number, value = 0) {685 await usingApi(async (api) => {686 const tx = api.tx.nft.burnItem(collectionId, tokenId, value);687 const events = await submitTransactionAsync(owner, tx);688 const result = getGenericResult(events);689 // Get the item690 const item: any = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON();691 // What to expect692 // tslint:disable-next-line:no-unused-expression693 expect(result.success).to.be.true;694 // tslint:disable-next-line:no-unused-expression695 expect(item).to.be.null;696 });697}698699export async function700approveExpectSuccess(701 collectionId: number,702 tokenId: number, owner: IKeyringPair, approved: IKeyringPair | CrossAccountId | string, amount: number | bigint = 1,703) {704 await usingApi(async (api: ApiPromise) => {705 approved = normalizeAccountId(approved);706 const allowanceBefore =707 await api.query.nft.allowances(collectionId, [tokenId, owner.address, toSubstrateAddress(approved)]) as unknown as BN;708 const approveNftTx = api.tx.nft.approve(approved, collectionId, tokenId, amount);709 const events = await submitTransactionAsync(owner, approveNftTx);710 const result = getCreateItemResult(events);711 // tslint:disable-next-line:no-unused-expression712 expect(result.success).to.be.true;713 const allowanceAfter =714 await api.query.nft.allowances(collectionId, [tokenId, owner.address, toSubstrateAddress(approved)]) as unknown as BN;715 expect(allowanceAfter.sub(allowanceBefore).toString()).to.be.equal(amount.toString());716 });717}718719export async function720transferFromExpectSuccess(721 collectionId: number,722 tokenId: number,723 accountApproved: IKeyringPair,724 accountFrom: IKeyringPair | CrossAccountId,725 accountTo: IKeyringPair | CrossAccountId,726 value: number | bigint = 1,727 type = 'NFT',728) {729 await usingApi(async (api: ApiPromise) => {730 const to = normalizeAccountId(accountTo);731 let balanceBefore = new BN(0);732 if (type === 'Fungible') {733 balanceBefore = await api.query.nft.balance(collectionId, toSubstrateAddress(to)) as unknown as BN;734 }735 const transferFromTx = api.tx.nft.transferFrom(normalizeAccountId(accountFrom), to, collectionId, tokenId, value);736 const events = await submitTransactionAsync(accountApproved, transferFromTx);737 const result = getCreateItemResult(events);738 // tslint:disable-next-line:no-unused-expression739 expect(result.success).to.be.true;740 if (type === 'NFT') {741 const nftItemData = (await api.query.nft.nftItemList(collectionId, tokenId) as any).toJSON() as ITokenDataType;742 expect(nftItemData.Owner).to.be.deep.equal(to);743 }744 if (type === 'Fungible') {745 const balanceAfter = (await api.query.nft.fungibleItemList(collectionId, toSubstrateAddress(to)) as any).Value as unknown as BN;746 expect(balanceAfter.sub(balanceBefore).toString()).to.be.equal(value.toString());747 }748 if (type === 'ReFungible') {749 const nftItemData =750 (await api.query.nft.reFungibleItemList(collectionId, tokenId) as any).toJSON() as IReFungibleTokenDataType;751 expect(nftItemData.Owner[0].Owner).to.be.deep.equal(normalizeAccountId(to));752 expect(nftItemData.Owner[0].Fraction).to.be.equal(value);753 }754 });755}756757export async function758transferFromExpectFail(759 collectionId: number,760 tokenId: number,761 accountApproved: IKeyringPair,762 accountFrom: IKeyringPair,763 accountTo: IKeyringPair,764 value: number | bigint = 1,765) {766 await usingApi(async (api: ApiPromise) => {767 const transferFromTx = api.tx.nft.transferFrom(normalizeAccountId(accountFrom.address), normalizeAccountId(accountTo.address), collectionId, tokenId, value);768 const events = await expect(submitTransactionExpectFailAsync(accountApproved, transferFromTx)).to.be.rejected;769 const result = getCreateCollectionResult(events);770 // tslint:disable-next-line:no-unused-expression771 expect(result.success).to.be.false;772 });773}774775/* eslint no-async-promise-executor: "off" */776async function getBlockNumber(api: ApiPromise): Promise<number> {777 return new Promise<number>(async (resolve) => {778 const unsubscribe = await api.rpc.chain.subscribeNewHeads((head) => {779 unsubscribe();780 resolve(head.number.toNumber());781 });782 });783}784785export async function addCollectionAdminExpectSuccess(sender: IKeyringPair, collectionId: number, address: IKeyringPair) {786 await usingApi(async (api) => {787 const changeAdminTx = api.tx.nft.addCollectionAdmin(collectionId, normalizeAccountId(address.address));788 const events = await submitTransactionAsync(sender, changeAdminTx);789 const result = getCreateCollectionResult(events);790 expect(result.success).to.be.true;791 });792}793794export async function795scheduleTransferExpectSuccess(796 collectionId: number,797 tokenId: number,798 sender: IKeyringPair,799 recipient: IKeyringPair,800 value: number | bigint = 1,801 blockTimeMs: number,802 blockSchedule: number,803) {804 await usingApi(async (api: ApiPromise) => {805 const blockNumber: number | undefined = await getBlockNumber(api);806 const expectedBlockNumber = blockNumber + blockSchedule;807808 expect(blockNumber).to.be.greaterThan(0);809 const transferTx = await api.tx.nft.transfer(normalizeAccountId(recipient.address), collectionId, tokenId, value); 810 const scheduleTx = await api.tx.scheduler.schedule(expectedBlockNumber, null, 0, transferTx);811812 await submitTransactionAsync(sender, scheduleTx);813814 const recipientBalanceBefore = new BigNumber((await api.query.system.account(recipient.address)).data.free.toString());815816 const nftItemDataBefore = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON() as any as ITokenDataType;817 expect(toSubstrateAddress(nftItemDataBefore.Owner)).to.be.equal(sender.address);818819 // sleep for 4 blocks820 await new Promise(resolve => setTimeout(resolve, blockTimeMs * (blockSchedule + 1)));821822 const recipientBalanceAfter = new BigNumber((await api.query.system.account(recipient.address)).data.free.toString());823824 const nftItemData = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON() as unknown as ITokenDataType;825 expect(toSubstrateAddress(nftItemData.Owner)).to.be.equal(recipient.address);826 expect(recipientBalanceAfter.toNumber()).to.be.equal(recipientBalanceBefore.toNumber());827 });828}829830831export async function832transferExpectSuccess(833 collectionId: number,834 tokenId: number,835 sender: IKeyringPair,836 recipient: IKeyringPair | CrossAccountId,837 value: number | bigint = 1,838 type = 'NFT',839) {840 await usingApi(async (api: ApiPromise) => {841 const to = normalizeAccountId(recipient);842843 let balanceBefore = new BN(0);844 if (type === 'Fungible') {845 balanceBefore = await api.query.nft.balance(collectionId, toSubstrateAddress(to)) as unknown as BN;846 }847 const transferTx = api.tx.nft.transfer(to, collectionId, tokenId, value);848 const events = await submitTransactionAsync(sender, transferTx);849 const result = getTransferResult(events);850 // tslint:disable-next-line:no-unused-expression851 expect(result.success).to.be.true;852 expect(result.collectionId).to.be.equal(collectionId);853 expect(result.itemId).to.be.equal(tokenId);854 expect(result.sender).to.be.deep.equal(normalizeAccountId(sender.address));855 expect(result.recipient).to.be.deep.equal(to);856 expect(result.value.toString()).to.be.equal(value.toString());857 if (type === 'NFT') {858 const nftItemData = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON() as unknown as ITokenDataType;859 expect(nftItemData.Owner).to.be.deep.equal(to);860 }861 if (type === 'Fungible') {862 const balanceAfter = (await api.query.nft.fungibleItemList(collectionId, toSubstrateAddress(to)) as any).Value as unknown as BN;863 expect(balanceAfter.sub(balanceBefore).toString()).to.be.equal(value.toString());864 }865 if (type === 'ReFungible') {866 const nftItemData =867 (await api.query.nft.reFungibleItemList(collectionId, tokenId)).toJSON() as unknown as IReFungibleTokenDataType;868 expect(nftItemData.Owner[0].Owner).to.be.deep.equal(to);869 expect(nftItemData.Owner[0].Fraction.toString()).to.be.equal(value.toString());870 }871 });872}873874export async function875transferExpectFailure(876 collectionId: number,877 tokenId: number,878 sender: IKeyringPair,879 recipient: IKeyringPair,880 value: number | bigint = 1,881) {882 await usingApi(async (api: ApiPromise) => {883 const transferTx = api.tx.nft.transfer(normalizeAccountId(recipient.address), collectionId, tokenId, value);884 const events = await expect(submitTransactionExpectFailAsync(sender, transferTx)).to.be.rejected;885 if (events && Array.isArray(events)) {886 const result = getCreateCollectionResult(events);887 // tslint:disable-next-line:no-unused-expression888 expect(result.success).to.be.false;889 }890 });891}892893export async function894approveExpectFail(895 collectionId: number,896 tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number | bigint = 1,897) {898 await usingApi(async (api: ApiPromise) => {899 const approveNftTx = api.tx.nft.approve(normalizeAccountId(approved.address), collectionId, tokenId, amount);900 const events = await expect(submitTransactionExpectFailAsync(owner, approveNftTx)).to.be.rejected;901 const result = getCreateCollectionResult(events);902 // tslint:disable-next-line:no-unused-expression903 expect(result.success).to.be.false;904 });905}906907export async function getFungibleBalance(908 collectionId: number,909 owner: string,910) {911 return await usingApi(async (api) => {912 const response = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON() as unknown as { Value: string };913 return BigInt(response.Value);914 });915}916917export async function createFungibleItemExpectSuccess(918 sender: IKeyringPair,919 collectionId: number,920 data: CreateFungibleData,921 owner: CrossAccountId | string = sender.address,922) {923 return await usingApi(async (api) => {924 const tx = api.tx.nft.createItem(collectionId, normalizeAccountId(owner), { Fungible: data });925926 const events = await submitTransactionAsync(sender, tx);927 const result = getCreateItemResult(events);928929 expect(result.success).to.be.true;930 return result.itemId;931 });932}933934export async function createItemExpectSuccess(sender: IKeyringPair, collectionId: number, createMode: string, owner: CrossAccountId | string = sender.address) {935 let newItemId = 0;936 await usingApi(async (api) => {937 const to = normalizeAccountId(owner);938 const AItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);939 const Aitem: any = (await api.query.nft.fungibleItemList(collectionId, toSubstrateAddress(to))).toJSON();940 const AItemBalance = new BigNumber(Aitem.Value);941942 let tx;943 if (createMode === 'Fungible') {944 const createData = { fungible: { value: 10 } };945 tx = api.tx.nft.createItem(collectionId, to, createData);946 } else if (createMode === 'ReFungible') {947 const createData = { refungible: { const_data: [], variable_data: [], pieces: 100 } };948 tx = api.tx.nft.createItem(collectionId, to, createData);949 } else {950 const createData = { nft: { const_data: [], variable_data: [] } };951 tx = api.tx.nft.createItem(collectionId, to, createData);952 }953954 const events = await submitTransactionAsync(sender, tx);955 const result = getCreateItemResult(events);956957 const BItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);958 const Bitem: any = (await api.query.nft.fungibleItemList(collectionId, toSubstrateAddress(to))).toJSON();959 const BItemBalance = new BigNumber(Bitem.Value);960961 // What to expect962 // tslint:disable-next-line:no-unused-expression963 expect(result.success).to.be.true;964 if (createMode === 'Fungible') {965 expect(BItemBalance.minus(AItemBalance).toNumber()).to.be.equal(10);966 } else {967 expect(BItemCount).to.be.equal(AItemCount + 1);968 }969 expect(collectionId).to.be.equal(result.collectionId);970 expect(BItemCount.toString()).to.be.equal(result.itemId.toString());971 expect(to).to.be.deep.equal(result.recipient);972 newItemId = result.itemId;973 });974 return newItemId;975}976977export async function createItemExpectFailure(sender: IKeyringPair, collectionId: number, createMode: string, owner: string = sender.address) {978 await usingApi(async (api) => {979 const tx = api.tx.nft.createItem(collectionId, normalizeAccountId(owner), createMode);980 981 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;982 const result = getCreateItemResult(events);983984 expect(result.success).to.be.false;985 });986}987988export async function setPublicAccessModeExpectSuccess(989 sender: IKeyringPair, collectionId: number,990 accessMode: 'Normal' | 'WhiteList',991) {992 await usingApi(async (api) => {993994 // Run the transaction995 const tx = api.tx.nft.setPublicAccessMode(collectionId, accessMode);996 const events = await submitTransactionAsync(sender, tx);997 const result = getGenericResult(events);998999 // Get the collection1000 const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();10011002 // What to expect1003 // tslint:disable-next-line:no-unused-expression1004 expect(result.success).to.be.true;1005 expect(collection.Access).to.be.equal(accessMode);1006 });1007}10081009export async function setPublicAccessModeExpectFail(1010 sender: IKeyringPair, collectionId: number,1011 accessMode: 'Normal' | 'WhiteList',1012) {1013 await usingApi(async (api) => {10141015 // Run the transaction1016 const tx = api.tx.nft.setPublicAccessMode(collectionId, accessMode);1017 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1018 const result = getGenericResult(events);10191020 // What to expect1021 // tslint:disable-next-line:no-unused-expression1022 expect(result.success).to.be.false;1023 });1024}10251026export async function enableWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number) {1027 await setPublicAccessModeExpectSuccess(sender, collectionId, 'WhiteList');1028}10291030export async function enableWhiteListExpectFail(sender: IKeyringPair, collectionId: number) {1031 await setPublicAccessModeExpectFail(sender, collectionId, 'WhiteList');1032}10331034export async function disableWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number) {1035 await setPublicAccessModeExpectSuccess(sender, collectionId, 'Normal');1036}10371038export async function setMintPermissionExpectSuccess(sender: IKeyringPair, collectionId: number, enabled: boolean) {1039 await usingApi(async (api) => {10401041 // Run the transaction1042 const tx = api.tx.nft.setMintPermission(collectionId, enabled);1043 const events = await submitTransactionAsync(sender, tx);1044 const result = getGenericResult(events);10451046 // Get the collection1047 const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();10481049 // What to expect1050 // tslint:disable-next-line:no-unused-expression1051 expect(result.success).to.be.true;1052 expect(collection.MintMode).to.be.equal(enabled);1053 });1054}10551056export async function enablePublicMintingExpectSuccess(sender: IKeyringPair, collectionId: number) {1057 await setMintPermissionExpectSuccess(sender, collectionId, true);1058}10591060export async function setMintPermissionExpectFailure(sender: IKeyringPair, collectionId: number, enabled: boolean) {1061 await usingApi(async (api) => {1062 // Run the transaction1063 const tx = api.tx.nft.setMintPermission(collectionId, enabled);1064 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1065 const result = getCreateCollectionResult(events);1066 // tslint:disable-next-line:no-unused-expression1067 expect(result.success).to.be.false;1068 });1069}10701071export async function setChainLimitsExpectFailure(sender: IKeyringPair, limits: IChainLimits) {1072 await usingApi(async (api) => {1073 // Run the transaction1074 const tx = api.tx.nft.setChainLimits(limits);1075 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1076 const result = getCreateCollectionResult(events);1077 // tslint:disable-next-line:no-unused-expression1078 expect(result.success).to.be.false;1079 });1080}10811082export async function isWhitelisted(collectionId: number, address: string) {1083 let whitelisted = false;1084 await usingApi(async (api) => {1085 whitelisted = (await api.query.nft.whiteList(collectionId, address)).toJSON() as unknown as boolean;1086 });1087 return whitelisted;1088}10891090export async function addToWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number, address: string | AccountId) {1091 await usingApi(async (api) => {10921093 const whiteListedBefore = (await api.query.nft.whiteList(collectionId, address)).toJSON();10941095 // Run the transaction1096 const tx = api.tx.nft.addToWhiteList(collectionId, normalizeAccountId(address));1097 const events = await submitTransactionAsync(sender, tx);1098 const result = getGenericResult(events);10991100 const whiteListedAfter = (await api.query.nft.whiteList(collectionId, address)).toJSON();11011102 // What to expect1103 // tslint:disable-next-line:no-unused-expression1104 expect(result.success).to.be.true;1105 // tslint:disable-next-line: no-unused-expression1106 expect(whiteListedBefore).to.be.false;1107 // tslint:disable-next-line: no-unused-expression1108 expect(whiteListedAfter).to.be.true;1109 });1110}11111112export async function addToWhiteListExpectFail(sender: IKeyringPair, collectionId: number, address: string | AccountId) {1113 await usingApi(async (api) => {1114 // Run the transaction1115 const tx = api.tx.nft.addToWhiteList(collectionId, normalizeAccountId(address));1116 const events = await expect(submitTransactionAsync(sender, tx)).to.be.rejected;1117 const result = getGenericResult(events);11181119 // What to expect1120 // tslint:disable-next-line:no-unused-expression1121 expect(result.success).to.be.false;1122 });1123}11241125export async function removeFromWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number, address: CrossAccountId) {1126 await usingApi(async (api) => {1127 // Run the transaction1128 const tx = api.tx.nft.removeFromWhiteList(collectionId, normalizeAccountId(address));1129 const events = await submitTransactionAsync(sender, tx);1130 const result = getGenericResult(events);11311132 // What to expect1133 // tslint:disable-next-line:no-unused-expression1134 expect(result.success).to.be.true;1135 });1136}11371138export async function removeFromWhiteListExpectFailure(sender: IKeyringPair, collectionId: number, address: CrossAccountId) {1139 await usingApi(async (api) => {1140 // Run the transaction1141 const tx = api.tx.nft.removeFromWhiteList(collectionId, normalizeAccountId(address));1142 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1143 const result = getGenericResult(events);11441145 // What to expect1146 // tslint:disable-next-line:no-unused-expression1147 expect(result.success).to.be.false;1148 });1149}11501151export const getDetailedCollectionInfo = async (api: ApiPromise, collectionId: number)1152 : Promise<ICollectionInterface | null> => {1153 return (await api.query.nft.collectionById(collectionId)).toJSON() as unknown as ICollectionInterface;1154};11551156export const getCreatedCollectionCount = async (api: ApiPromise): Promise<number> => {1157 // set global object - collectionsCount1158 return (await api.query.nft.createdCollectionCount() as unknown as BN).toNumber();1159};11601161export async function queryCollectionExpectSuccess(collectionId: number): Promise<ICollectionInterface> {1162 return await usingApi(async (api) => {1163 return (await api.query.nft.collectionById(collectionId)).toJSON() as unknown as ICollectionInterface;1164 });1165}1//2// This file is subject to the terms and conditions defined in3// file 'LICENSE', which is part of this source code package.4//56import { ApiPromise, Keyring } from '@polkadot/api';7import type { AccountId, EventRecord } from '@polkadot/types/interfaces';8import { IKeyringPair } from '@polkadot/types/types';9import { evmToAddress } from '@polkadot/util-crypto';10import { BigNumber } from 'bignumber.js';11import BN from 'bn.js';12import chai from 'chai';13import chaiAsPromised from 'chai-as-promised';14import { alicesPublicKey } from '../accounts';15import privateKey from '../substrate/privateKey';16import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from '../substrate/substrate-api';17import { ICollectionInterface } from '../types';18import { hexToStr, strToUTF16, utf16ToStr } from './util';1920chai.use(chaiAsPromised);21const expect = chai.expect;2223export type CrossAccountId = {24 substrate: string,25} | {26 ethereum: string,27};28export function normalizeAccountId(input: string | AccountId | CrossAccountId | IKeyringPair): CrossAccountId {29 if (typeof input === 'string')30 return { substrate: input };31 if ('address' in input) {32 return { substrate: input.address };33 }34 if ('ethereum' in input) {35 input.ethereum = input.ethereum.toLowerCase();36 return input;37 }38 if ('substrate' in input) {39 return input;40 }4142 // AccountId43 return {substrate: input.toString()};44}45export function toSubstrateAddress(input: string | CrossAccountId | IKeyringPair): string {46 input = normalizeAccountId(input);47 if ('substrate' in input) {48 return input.substrate;49 } else {50 return evmToAddress(input.ethereum);51 }52}5354export const U128_MAX = (1n << 128n) - 1n;5556const MICROUNIQUE = 1_000_000_000n;57const MILLIUNIQUE = 1_000n * MICROUNIQUE;58const CENTIUNIQUE = 10n * MILLIUNIQUE;59export const UNIQUE = 100n * CENTIUNIQUE;6061type GenericResult = {62 success: boolean,63};6465interface CreateCollectionResult {66 success: boolean;67 collectionId: number;68}6970interface CreateItemResult {71 success: boolean;72 collectionId: number;73 itemId: number;74 recipient?: CrossAccountId;75}7677interface TransferResult {78 success: boolean;79 collectionId: number;80 itemId: number;81 sender?: CrossAccountId;82 recipient?: CrossAccountId;83 value: bigint;84}8586interface IReFungibleOwner {87 Fraction: BN;88 Owner: number[];89}9091interface ITokenDataType {92 Owner: IKeyringPair;93 ConstData: number[];94 VariableData: number[];95}9697interface IGetMessage {98 checkMsgNftMethod: string;99 checkMsgTrsMethod: string;100 checkMsgSysMethod: string;101}102103export interface IFungibleTokenDataType {104 Value: number;105}106107export interface IChainLimits {108 CollectionNumbersLimit: number;109 AccountTokenOwnershipLimit: number;110 CollectionsAdminsLimit: number;111 CustomDataLimit: number;112 NftSponsorTransferTimeout: number;113 FungibleSponsorTransferTimeout: number;114 RefungibleSponsorTransferTimeout: number;115 OffchainSchemaLimit: number;116 VariableOnChainSchemaLimit: number;117 ConstOnChainSchemaLimit: number;118}119120export interface IReFungibleTokenDataType {121 Owner: IReFungibleOwner[];122 ConstData: number[];123 VariableData: number[];124}125126export function nftEventMessage(events: EventRecord[]): IGetMessage {127 let checkMsgNftMethod = '';128 let checkMsgTrsMethod = '';129 let checkMsgSysMethod = '';130 events.forEach(({ event: { method, section } }) => {131 if (section === 'nft') {132 checkMsgNftMethod = method;133 } else if (section === 'treasury') {134 checkMsgTrsMethod = method;135 } else if (section === 'system') {136 checkMsgSysMethod = method;137 } else { return null; }138 });139 const result: IGetMessage = {140 checkMsgNftMethod,141 checkMsgTrsMethod,142 checkMsgSysMethod,143 };144 return result;145}146147export function getGenericResult(events: EventRecord[]): GenericResult {148 const result: GenericResult = {149 success: false,150 };151 events.forEach(({ event: { method } }) => {152 // console.log(` ${phase}: ${section}.${method}:: ${data}`);153 if (method === 'ExtrinsicSuccess') {154 result.success = true;155 }156 });157 return result;158}159160161162export function getCreateCollectionResult(events: EventRecord[]): CreateCollectionResult {163 let success = false;164 let collectionId = 0;165 events.forEach(({ event: { data, method, section } }) => {166 // console.log(` ${phase}: ${section}.${method}:: ${data}`);167 if (method == 'ExtrinsicSuccess') {168 success = true;169 } else if ((section == 'nft') && (method == 'CollectionCreated')) {170 collectionId = parseInt(data[0].toString());171 }172 });173 const result: CreateCollectionResult = {174 success,175 collectionId,176 };177 return result;178}179180export function getCreateItemResult(events: EventRecord[]): CreateItemResult {181 let success = false;182 let collectionId = 0;183 let itemId = 0;184 let recipient;185 events.forEach(({ event: { data, method, section } }) => {186 // console.log(` ${phase}: ${section}.${method}:: ${data}`);187 if (method == 'ExtrinsicSuccess') {188 success = true;189 } else if ((section == 'nft') && (method == 'ItemCreated')) {190 collectionId = parseInt(data[0].toString());191 itemId = parseInt(data[1].toString());192 recipient = data[2].toJSON();193 }194 });195 const result: CreateItemResult = {196 success,197 collectionId,198 itemId,199 recipient,200 };201 return result;202}203204export function getTransferResult(events: EventRecord[]): TransferResult {205 const result: TransferResult = {206 success: false,207 collectionId: 0,208 itemId: 0,209 value: 0n,210 };211212 events.forEach(({ event: { data, method, section } }) => {213 if (method === 'ExtrinsicSuccess') {214 result.success = true;215 } else if (section === 'nft' && method === 'Transfer') {216 result.collectionId = +data[0].toString();217 result.itemId = +data[1].toString();218 result.sender = data[2].toJSON() as CrossAccountId;219 result.recipient = data[3].toJSON() as CrossAccountId;220 result.value = BigInt(data[4].toString());221 }222 });223224 return result;225}226227interface Invalid {228 type: 'Invalid';229}230231interface Nft {232 type: 'NFT';233}234235interface Fungible {236 type: 'Fungible';237 decimalPoints: number;238}239240interface ReFungible {241 type: 'ReFungible';242}243244type CollectionMode = Nft | Fungible | ReFungible | Invalid;245246export type CreateCollectionParams = {247 mode: CollectionMode,248 name: string,249 description: string,250 tokenPrefix: string,251};252253const defaultCreateCollectionParams: CreateCollectionParams = {254 description: 'description',255 mode: { type: 'NFT' },256 name: 'name',257 tokenPrefix: 'prefix',258};259260export async function createCollectionExpectSuccess(params: Partial<CreateCollectionParams> = {}): Promise<number> {261 const { name, description, mode, tokenPrefix } = { ...defaultCreateCollectionParams, ...params };262263 let collectionId = 0;264 await usingApi(async (api) => {265 // Get number of collections before the transaction266 const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10);267268 // Run the CreateCollection transaction269 const alicePrivateKey = privateKey('//Alice');270271 let modeprm = {};272 if (mode.type === 'NFT') {273 modeprm = { nft: null };274 } else if (mode.type === 'Fungible') {275 modeprm = { fungible: mode.decimalPoints };276 } else if (mode.type === 'ReFungible') {277 modeprm = { refungible: null };278 } else if (mode.type === 'Invalid') {279 modeprm = { invalid: null };280 }281282 const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), modeprm);283 const events = await submitTransactionAsync(alicePrivateKey, tx);284 const result = getCreateCollectionResult(events);285286 // Get number of collections after the transaction287 const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10);288289 // Get the collection290 const collection: any = (await api.query.nft.collectionById(result.collectionId) as any).toJSON();291292 // What to expect293 // tslint:disable-next-line:no-unused-expression294 expect(result.success).to.be.true;295 expect(result.collectionId).to.be.equal(BcollectionCount);296 // tslint:disable-next-line:no-unused-expression297 expect(collection).to.be.not.null;298 expect(BcollectionCount).to.be.equal(AcollectionCount + 1, 'Error: NFT collection NOT created.');299 expect(collection.Owner).to.be.equal(toSubstrateAddress(alicesPublicKey));300 expect(utf16ToStr(collection.Name)).to.be.equal(name);301 expect(utf16ToStr(collection.Description)).to.be.equal(description);302 expect(hexToStr(collection.TokenPrefix)).to.be.equal(tokenPrefix);303304 collectionId = result.collectionId;305 });306307 return collectionId;308}309310export async function createCollectionExpectFailure(params: Partial<CreateCollectionParams> = {}) {311 const { name, description, mode, tokenPrefix } = { ...defaultCreateCollectionParams, ...params };312313 let modeprm = {};314 if (mode.type === 'NFT') {315 modeprm = { nft: null };316 } else if (mode.type === 'Fungible') {317 modeprm = { fungible: mode.decimalPoints };318 } else if (mode.type === 'ReFungible') {319 modeprm = { refungible: null };320 } else if (mode.type === 'Invalid') {321 modeprm = { invalid: null };322 }323324 await usingApi(async (api) => {325 // Get number of collections before the transaction326 const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());327328 // Run the CreateCollection transaction329 const alicePrivateKey = privateKey('//Alice');330 const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), modeprm);331 const events = await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;332 const result = getCreateCollectionResult(events);333334 // Get number of collections after the transaction335 const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());336337 // What to expect338 // tslint:disable-next-line:no-unused-expression339 expect(result.success).to.be.false;340 expect(BcollectionCount).to.be.equal(AcollectionCount, 'Error: Collection with incorrect data created.');341 });342}343344export async function findUnusedAddress(api: ApiPromise, seedAddition = ''): Promise<IKeyringPair> {345 let bal = new BigNumber(0);346 let unused;347 do {348 const randomSeed = 'seed' + Math.floor(Math.random() * Math.floor(10000)) + seedAddition;349 const keyring = new Keyring({ type: 'sr25519' });350 unused = keyring.addFromUri(`//${randomSeed}`);351 bal = new BigNumber((await api.query.system.account(unused.address)).data.free.toString());352 } while (bal.toFixed() != '0');353 return unused;354}355356export async function getAllowance(collectionId: number, tokenId: number, owner: string, approved: string) {357 return await usingApi(async (api) => {358 const bn = await api.query.nft.allowances(collectionId, [tokenId, owner, approved]) as unknown as BN;359 return BigInt(bn.toString());360 });361}362363export function findUnusedAddresses(api: ApiPromise, amount: number): Promise<IKeyringPair[]> {364 return Promise.all(new Array(amount).fill(null).map(() => findUnusedAddress(api, '_' + Date.now())));365}366367export async function findNotExistingCollection(api: ApiPromise): Promise<number> {368 const totalNumber = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10) as unknown as number;369 const newCollection: number = totalNumber + 1;370 return newCollection;371}372373function getDestroyResult(events: EventRecord[]): boolean {374 let success = false;375 events.forEach(({ event: { method } }) => {376 if (method == 'ExtrinsicSuccess') {377 success = true;378 }379 });380 return success;381}382383export async function destroyCollectionExpectFailure(collectionId: number, senderSeed = '//Alice') {384 await usingApi(async (api) => {385 // Run the DestroyCollection transaction386 const alicePrivateKey = privateKey(senderSeed);387 const tx = api.tx.nft.destroyCollection(collectionId);388 await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;389 });390}391392export async function destroyCollectionExpectSuccess(collectionId: number, senderSeed = '//Alice') {393 await usingApi(async (api) => {394 // Run the DestroyCollection transaction395 const alicePrivateKey = privateKey(senderSeed);396 const tx = api.tx.nft.destroyCollection(collectionId);397 const events = await submitTransactionAsync(alicePrivateKey, tx);398 const result = getDestroyResult(events);399400 // Get the collection401 const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();402403 // What to expect404 expect(result).to.be.true;405 expect(collection).to.be.null;406 });407}408409export async function queryCollectionLimits(collectionId: number) {410 return await usingApi(async (api) => {411 return ((await api.query.nft.collectionById(collectionId)).toJSON() as any).Limits;412 });413}414415export async function setCollectionLimitsExpectSuccess(sender: IKeyringPair, collectionId: number, limits: any) {416 await usingApi(async (api) => {417 const oldLimits = await queryCollectionLimits(collectionId);418 const newLimits = { ...oldLimits as any, ...limits };419 const tx = api.tx.nft.setCollectionLimits(collectionId, newLimits);420 const events = await submitTransactionAsync(sender, tx);421 const result = getGenericResult(events);422423 expect(result.success).to.be.true;424 });425}426427export async function setCollectionLimitsExpectFailure(sender: IKeyringPair, collectionId: number, limits: any) {428 await usingApi(async (api) => {429 const oldLimits = await queryCollectionLimits(collectionId);430 const newLimits = { ...oldLimits as any, ...limits };431 const tx = api.tx.nft.setCollectionLimits(collectionId, newLimits);432 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;433 const result = getGenericResult(events);434435 expect(result.success).to.be.false;436 });437}438439export async function setCollectionSponsorExpectSuccess(collectionId: number, sponsor: string, sender = '//Alice') {440 await usingApi(async (api) => {441442 // Run the transaction443 const senderPrivateKey = privateKey(sender);444 const tx = api.tx.nft.setCollectionSponsor(collectionId, sponsor);445 const events = await submitTransactionAsync(senderPrivateKey, tx);446 const result = getGenericResult(events);447448 // Get the collection449 const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();450451 // What to expect452 expect(result.success).to.be.true;453 expect(collection.Sponsorship).to.deep.equal({454 unconfirmed: sponsor,455 });456 });457}458459export async function removeCollectionSponsorExpectSuccess(collectionId: number, sender = '//Alice') {460 await usingApi(async (api) => {461462 // Run the transaction463 const alicePrivateKey = privateKey(sender);464 const tx = api.tx.nft.removeCollectionSponsor(collectionId);465 const events = await submitTransactionAsync(alicePrivateKey, tx);466 const result = getGenericResult(events);467468 // Get the collection469 const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();470471 // What to expect472 expect(result.success).to.be.true;473 expect(collection.Sponsorship).to.be.deep.equal({ disabled: null });474 });475}476477export async function removeCollectionSponsorExpectFailure(collectionId: number, senderSeed = '//Alice') {478 await usingApi(async (api) => {479480 // Run the transaction481 const alicePrivateKey = privateKey(senderSeed);482 const tx = api.tx.nft.removeCollectionSponsor(collectionId);483 await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;484 });485}486487export async function setCollectionSponsorExpectFailure(collectionId: number, sponsor: string, senderSeed = '//Alice') {488 await usingApi(async (api) => {489490 // Run the transaction491 const alicePrivateKey = privateKey(senderSeed);492 const tx = api.tx.nft.setCollectionSponsor(collectionId, sponsor);493 await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;494 });495}496497export async function confirmSponsorshipExpectSuccess(collectionId: number, senderSeed = '//Alice') {498 await usingApi(async (api) => {499500 // Run the transaction501 const sender = privateKey(senderSeed);502 const tx = api.tx.nft.confirmSponsorship(collectionId);503 const events = await submitTransactionAsync(sender, tx);504 const result = getGenericResult(events);505506 // Get the collection507 const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();508509 // What to expect510 expect(result.success).to.be.true;511 expect(collection.Sponsorship).to.be.deep.equal({512 confirmed: sender.address,513 });514 });515}516517518export async function confirmSponsorshipExpectFailure(collectionId: number, senderSeed = '//Alice') {519 await usingApi(async (api) => {520521 // Run the transaction522 const sender = privateKey(senderSeed);523 const tx = api.tx.nft.confirmSponsorship(collectionId);524 await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;525 });526}527528export async function enableContractSponsoringExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {529 await usingApi(async (api) => {530 const tx = api.tx.nft.enableContractSponsoring(contractAddress, enable);531 const events = await submitTransactionAsync(sender, tx);532 const result = getGenericResult(events);533534 expect(result.success).to.be.true;535 });536}537538export async function enableContractSponsoringExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {539 await usingApi(async (api) => {540 const tx = api.tx.nft.enableContractSponsoring(contractAddress, enable);541 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;542 const result = getGenericResult(events);543544 expect(result.success).to.be.false;545 });546}547548export async function setTransferFlagExpectSuccess(sender: IKeyringPair, collectionId: number, enabled: boolean) {549550 await usingApi(async (api) => {551552 const tx = api.tx.nft.setTransfersEnabledFlag (collectionId, enabled);553 const events = await submitTransactionAsync(sender, tx);554 const result = getGenericResult(events);555556 expect(result.success).to.be.true;557 }); 558}559560export async function setTransferFlagExpectFailure(sender: IKeyringPair, collectionId: number, enabled: boolean) {561562 await usingApi(async (api) => {563564 const tx = api.tx.nft.setTransfersEnabledFlag (collectionId, enabled);565 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;566 const result = getGenericResult(events);567568 expect(result.success).to.be.false;569 }); 570}571572export async function setContractSponsoringRateLimitExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {573 await usingApi(async (api) => {574 const tx = api.tx.nft.setContractSponsoringRateLimit(contractAddress, rateLimit);575 const events = await submitTransactionAsync(sender, tx);576 const result = getGenericResult(events);577578 expect(result.success).to.be.true;579 });580}581582export async function setContractSponsoringRateLimitExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {583 await usingApi(async (api) => {584 const tx = api.tx.nft.setContractSponsoringRateLimit(contractAddress, rateLimit);585 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;586 const result = getGenericResult(events);587588 expect(result.success).to.be.false;589 });590}591592export async function toggleContractWhitelistExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, value = true) {593 await usingApi(async (api) => {594 const tx = api.tx.nft.toggleContractWhiteList(contractAddress, value);595 const events = await submitTransactionAsync(sender, tx);596 const result = getGenericResult(events);597598 expect(result.success).to.be.true;599 });600}601602export async function isWhitelistedInContract(contractAddress: AccountId | string, user: string) {603 let whitelisted = false;604 await usingApi(async (api) => {605 whitelisted = (await api.query.nft.contractWhiteList(contractAddress, user)).toJSON() as boolean;606 });607 return whitelisted;608}609610export async function addToContractWhiteListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {611 await usingApi(async (api) => {612 const tx = api.tx.nft.addToContractWhiteList(contractAddress.toString(), user.toString());613 const events = await submitTransactionAsync(sender, tx);614 const result = getGenericResult(events);615616 expect(result.success).to.be.true;617 });618}619620export async function removeFromContractWhiteListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {621 await usingApi(async (api) => {622 const tx = api.tx.nft.removeFromContractWhiteList(contractAddress.toString(), user.toString());623 const events = await submitTransactionAsync(sender, tx);624 const result = getGenericResult(events);625626 expect(result.success).to.be.true;627 });628}629630export async function removeFromContractWhiteListExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, user: AccountId | string) {631 await usingApi(async (api) => {632 const tx = api.tx.nft.removeFromContractWhiteList(contractAddress.toString(), user.toString());633 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;634 const result = getGenericResult(events);635636 expect(result.success).to.be.false;637 });638}639640export async function setVariableMetaDataExpectSuccess(sender: IKeyringPair, collectionId: number, itemId: number, data: number[]) {641 await usingApi(async (api) => {642 const tx = api.tx.nft.setVariableMetaData(collectionId, itemId, '0x' + Buffer.from(data).toString('hex'));643 const events = await submitTransactionAsync(sender, tx);644 const result = getGenericResult(events);645646 expect(result.success).to.be.true;647 });648}649650export async function setVariableMetaDataExpectFailure(sender: IKeyringPair, collectionId: number, itemId: number, data: number[]) {651 await usingApi(async (api) => {652 const tx = api.tx.nft.setVariableMetaData(collectionId, itemId, '0x' + Buffer.from(data).toString('hex'));653 await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;654 });655}656657export async function setOffchainSchemaExpectSuccess(sender: IKeyringPair, collectionId: number, data: number[]) {658 await usingApi(async (api) => {659 const tx = api.tx.nft.setOffchainSchema(collectionId, '0x' + Buffer.from(data).toString('hex'));660 const events = await submitTransactionAsync(sender, tx);661 const result = getGenericResult(events);662663 expect(result.success).to.be.true;664 });665}666667export async function setOffchainSchemaExpectFailure(sender: IKeyringPair, collectionId: number, data: number[]) {668 await usingApi(async (api) => {669 const tx = api.tx.nft.setOffchainSchema(collectionId, '0x' + Buffer.from(data).toString('hex'));670 await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;671 });672}673674export interface CreateFungibleData {675 readonly Value: bigint;676}677678export interface CreateReFungibleData { }679export interface CreateNftData { }680681export type CreateItemData = {682 NFT: CreateNftData;683} | {684 Fungible: CreateFungibleData;685} | {686 ReFungible: CreateReFungibleData;687};688689export async function burnItemExpectSuccess(owner: IKeyringPair, collectionId: number, tokenId: number, value = 0) {690 await usingApi(async (api) => {691 const tx = api.tx.nft.burnItem(collectionId, tokenId, value);692 const events = await submitTransactionAsync(owner, tx);693 const result = getGenericResult(events);694 // Get the item695 const item: any = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON();696 // What to expect697 // tslint:disable-next-line:no-unused-expression698 expect(result.success).to.be.true;699 // tslint:disable-next-line:no-unused-expression700 expect(item).to.be.null;701 });702}703704export async function705approveExpectSuccess(706 collectionId: number,707 tokenId: number, owner: IKeyringPair, approved: IKeyringPair | CrossAccountId | string, amount: number | bigint = 1,708) {709 await usingApi(async (api: ApiPromise) => {710 approved = normalizeAccountId(approved);711 const allowanceBefore =712 await api.query.nft.allowances(collectionId, [tokenId, owner.address, toSubstrateAddress(approved)]) as unknown as BN;713 const approveNftTx = api.tx.nft.approve(approved, collectionId, tokenId, amount);714 const events = await submitTransactionAsync(owner, approveNftTx);715 const result = getCreateItemResult(events);716 // tslint:disable-next-line:no-unused-expression717 expect(result.success).to.be.true;718 const allowanceAfter =719 await api.query.nft.allowances(collectionId, [tokenId, owner.address, toSubstrateAddress(approved)]) as unknown as BN;720 expect(allowanceAfter.sub(allowanceBefore).toString()).to.be.equal(amount.toString());721 });722}723724export async function725transferFromExpectSuccess(726 collectionId: number,727 tokenId: number,728 accountApproved: IKeyringPair,729 accountFrom: IKeyringPair | CrossAccountId,730 accountTo: IKeyringPair | CrossAccountId,731 value: number | bigint = 1,732 type = 'NFT',733) {734 await usingApi(async (api: ApiPromise) => {735 const to = normalizeAccountId(accountTo);736 let balanceBefore = new BN(0);737 if (type === 'Fungible') {738 balanceBefore = await api.query.nft.balance(collectionId, toSubstrateAddress(to)) as unknown as BN;739 }740 const transferFromTx = api.tx.nft.transferFrom(normalizeAccountId(accountFrom), to, collectionId, tokenId, value);741 const events = await submitTransactionAsync(accountApproved, transferFromTx);742 const result = getCreateItemResult(events);743 // tslint:disable-next-line:no-unused-expression744 expect(result.success).to.be.true;745 if (type === 'NFT') {746 const nftItemData = (await api.query.nft.nftItemList(collectionId, tokenId) as any).toJSON() as ITokenDataType;747 expect(nftItemData.Owner).to.be.deep.equal(to);748 }749 if (type === 'Fungible') {750 const balanceAfter = (await api.query.nft.fungibleItemList(collectionId, toSubstrateAddress(to)) as any).Value as unknown as BN;751 expect(balanceAfter.sub(balanceBefore).toString()).to.be.equal(value.toString());752 }753 if (type === 'ReFungible') {754 const nftItemData =755 (await api.query.nft.reFungibleItemList(collectionId, tokenId) as any).toJSON() as IReFungibleTokenDataType;756 expect(nftItemData.Owner[0].Owner).to.be.deep.equal(normalizeAccountId(to));757 expect(nftItemData.Owner[0].Fraction).to.be.equal(value);758 }759 });760}761762export async function763transferFromExpectFail(764 collectionId: number,765 tokenId: number,766 accountApproved: IKeyringPair,767 accountFrom: IKeyringPair,768 accountTo: IKeyringPair,769 value: number | bigint = 1,770) {771 await usingApi(async (api: ApiPromise) => {772 const transferFromTx = api.tx.nft.transferFrom(normalizeAccountId(accountFrom.address), normalizeAccountId(accountTo.address), collectionId, tokenId, value);773 const events = await expect(submitTransactionExpectFailAsync(accountApproved, transferFromTx)).to.be.rejected;774 const result = getCreateCollectionResult(events);775 // tslint:disable-next-line:no-unused-expression776 expect(result.success).to.be.false;777 });778}779780/* eslint no-async-promise-executor: "off" */781async function getBlockNumber(api: ApiPromise): Promise<number> {782 return new Promise<number>(async (resolve) => {783 const unsubscribe = await api.rpc.chain.subscribeNewHeads((head) => {784 unsubscribe();785 resolve(head.number.toNumber());786 });787 });788}789790export async function addCollectionAdminExpectSuccess(sender: IKeyringPair, collectionId: number, address: IKeyringPair) {791 await usingApi(async (api) => {792 const changeAdminTx = api.tx.nft.addCollectionAdmin(collectionId, normalizeAccountId(address.address));793 const events = await submitTransactionAsync(sender, changeAdminTx);794 const result = getCreateCollectionResult(events);795 expect(result.success).to.be.true;796 });797}798799export async function800scheduleTransferExpectSuccess(801 collectionId: number,802 tokenId: number,803 sender: IKeyringPair,804 recipient: IKeyringPair,805 value: number | bigint = 1,806 blockTimeMs: number,807 blockSchedule: number,808) {809 await usingApi(async (api: ApiPromise) => {810 const blockNumber: number | undefined = await getBlockNumber(api);811 const expectedBlockNumber = blockNumber + blockSchedule;812813 expect(blockNumber).to.be.greaterThan(0);814 const transferTx = await api.tx.nft.transfer(normalizeAccountId(recipient.address), collectionId, tokenId, value); 815 const scheduleTx = await api.tx.scheduler.schedule(expectedBlockNumber, null, 0, transferTx);816817 await submitTransactionAsync(sender, scheduleTx);818819 const recipientBalanceBefore = new BigNumber((await api.query.system.account(recipient.address)).data.free.toString());820821 const nftItemDataBefore = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON() as any as ITokenDataType;822 expect(toSubstrateAddress(nftItemDataBefore.Owner)).to.be.equal(sender.address);823824 // sleep for 4 blocks825 await new Promise(resolve => setTimeout(resolve, blockTimeMs * (blockSchedule + 1)));826827 const recipientBalanceAfter = new BigNumber((await api.query.system.account(recipient.address)).data.free.toString());828829 const nftItemData = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON() as unknown as ITokenDataType;830 expect(toSubstrateAddress(nftItemData.Owner)).to.be.equal(recipient.address);831 expect(recipientBalanceAfter.toNumber()).to.be.equal(recipientBalanceBefore.toNumber());832 });833}834835836export async function837transferExpectSuccess(838 collectionId: number,839 tokenId: number,840 sender: IKeyringPair,841 recipient: IKeyringPair | CrossAccountId,842 value: number | bigint = 1,843 type = 'NFT',844) {845 await usingApi(async (api: ApiPromise) => {846 const to = normalizeAccountId(recipient);847848 let balanceBefore = new BN(0);849 if (type === 'Fungible') {850 balanceBefore = await api.query.nft.balance(collectionId, toSubstrateAddress(to)) as unknown as BN;851 }852 const transferTx = api.tx.nft.transfer(to, collectionId, tokenId, value);853 const events = await submitTransactionAsync(sender, transferTx);854 const result = getTransferResult(events);855 // tslint:disable-next-line:no-unused-expression856 expect(result.success).to.be.true;857 expect(result.collectionId).to.be.equal(collectionId);858 expect(result.itemId).to.be.equal(tokenId);859 expect(result.sender).to.be.deep.equal(normalizeAccountId(sender.address));860 expect(result.recipient).to.be.deep.equal(to);861 expect(result.value.toString()).to.be.equal(value.toString());862 if (type === 'NFT') {863 const nftItemData = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON() as unknown as ITokenDataType;864 expect(nftItemData.Owner).to.be.deep.equal(to);865 }866 if (type === 'Fungible') {867 const balanceAfter = (await api.query.nft.fungibleItemList(collectionId, toSubstrateAddress(to)) as any).Value as unknown as BN;868 expect(balanceAfter.sub(balanceBefore).toString()).to.be.equal(value.toString());869 }870 if (type === 'ReFungible') {871 const nftItemData =872 (await api.query.nft.reFungibleItemList(collectionId, tokenId)).toJSON() as unknown as IReFungibleTokenDataType;873 expect(nftItemData.Owner[0].Owner).to.be.deep.equal(to);874 expect(nftItemData.Owner[0].Fraction.toString()).to.be.equal(value.toString());875 }876 });877}878879export async function880transferExpectFailure(881 collectionId: number,882 tokenId: number,883 sender: IKeyringPair,884 recipient: IKeyringPair,885 value: number | bigint = 1,886) {887 await usingApi(async (api: ApiPromise) => {888 const transferTx = api.tx.nft.transfer(normalizeAccountId(recipient.address), collectionId, tokenId, value);889 const events = await expect(submitTransactionExpectFailAsync(sender, transferTx)).to.be.rejected;890 if (events && Array.isArray(events)) {891 const result = getCreateCollectionResult(events);892 // tslint:disable-next-line:no-unused-expression893 expect(result.success).to.be.false;894 }895 });896}897898export async function899approveExpectFail(900 collectionId: number,901 tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number | bigint = 1,902) {903 await usingApi(async (api: ApiPromise) => {904 const approveNftTx = api.tx.nft.approve(normalizeAccountId(approved.address), collectionId, tokenId, amount);905 const events = await expect(submitTransactionExpectFailAsync(owner, approveNftTx)).to.be.rejected;906 const result = getCreateCollectionResult(events);907 // tslint:disable-next-line:no-unused-expression908 expect(result.success).to.be.false;909 });910}911912export async function getFungibleBalance(913 collectionId: number,914 owner: string,915) {916 return await usingApi(async (api) => {917 const response = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON() as unknown as { Value: string };918 return BigInt(response.Value);919 });920}921922export async function createFungibleItemExpectSuccess(923 sender: IKeyringPair,924 collectionId: number,925 data: CreateFungibleData,926 owner: CrossAccountId | string = sender.address,927) {928 return await usingApi(async (api) => {929 const tx = api.tx.nft.createItem(collectionId, normalizeAccountId(owner), { Fungible: data });930931 const events = await submitTransactionAsync(sender, tx);932 const result = getCreateItemResult(events);933934 expect(result.success).to.be.true;935 return result.itemId;936 });937}938939export async function createItemExpectSuccess(sender: IKeyringPair, collectionId: number, createMode: string, owner: CrossAccountId | string = sender.address) {940 let newItemId = 0;941 await usingApi(async (api) => {942 const to = normalizeAccountId(owner);943 const AItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);944 const Aitem: any = (await api.query.nft.fungibleItemList(collectionId, toSubstrateAddress(to))).toJSON();945 const AItemBalance = new BigNumber(Aitem.Value);946947 let tx;948 if (createMode === 'Fungible') {949 const createData = { fungible: { value: 10 } };950 tx = api.tx.nft.createItem(collectionId, to, createData);951 } else if (createMode === 'ReFungible') {952 const createData = { refungible: { const_data: [], variable_data: [], pieces: 100 } };953 tx = api.tx.nft.createItem(collectionId, to, createData);954 } else {955 const createData = { nft: { const_data: [], variable_data: [] } };956 tx = api.tx.nft.createItem(collectionId, to, createData);957 }958959 const events = await submitTransactionAsync(sender, tx);960 const result = getCreateItemResult(events);961962 const BItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);963 const Bitem: any = (await api.query.nft.fungibleItemList(collectionId, toSubstrateAddress(to))).toJSON();964 const BItemBalance = new BigNumber(Bitem.Value);965966 // What to expect967 // tslint:disable-next-line:no-unused-expression968 expect(result.success).to.be.true;969 if (createMode === 'Fungible') {970 expect(BItemBalance.minus(AItemBalance).toNumber()).to.be.equal(10);971 } else {972 expect(BItemCount).to.be.equal(AItemCount + 1);973 }974 expect(collectionId).to.be.equal(result.collectionId);975 expect(BItemCount.toString()).to.be.equal(result.itemId.toString());976 expect(to).to.be.deep.equal(result.recipient);977 newItemId = result.itemId;978 });979 return newItemId;980}981982export async function createItemExpectFailure(sender: IKeyringPair, collectionId: number, createMode: string, owner: string = sender.address) {983 await usingApi(async (api) => {984 const tx = api.tx.nft.createItem(collectionId, normalizeAccountId(owner), createMode);985 986 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;987 const result = getCreateItemResult(events);988989 expect(result.success).to.be.false;990 });991}992993export async function setPublicAccessModeExpectSuccess(994 sender: IKeyringPair, collectionId: number,995 accessMode: 'Normal' | 'WhiteList',996) {997 await usingApi(async (api) => {998999 // Run the transaction1000 const tx = api.tx.nft.setPublicAccessMode(collectionId, accessMode);1001 const events = await submitTransactionAsync(sender, tx);1002 const result = getGenericResult(events);10031004 // Get the collection1005 const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();10061007 // What to expect1008 // tslint:disable-next-line:no-unused-expression1009 expect(result.success).to.be.true;1010 expect(collection.Access).to.be.equal(accessMode);1011 });1012}10131014export async function setPublicAccessModeExpectFail(1015 sender: IKeyringPair, collectionId: number,1016 accessMode: 'Normal' | 'WhiteList',1017) {1018 await usingApi(async (api) => {10191020 // Run the transaction1021 const tx = api.tx.nft.setPublicAccessMode(collectionId, accessMode);1022 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1023 const result = getGenericResult(events);10241025 // What to expect1026 // tslint:disable-next-line:no-unused-expression1027 expect(result.success).to.be.false;1028 });1029}10301031export async function enableWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number) {1032 await setPublicAccessModeExpectSuccess(sender, collectionId, 'WhiteList');1033}10341035export async function enableWhiteListExpectFail(sender: IKeyringPair, collectionId: number) {1036 await setPublicAccessModeExpectFail(sender, collectionId, 'WhiteList');1037}10381039export async function disableWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number) {1040 await setPublicAccessModeExpectSuccess(sender, collectionId, 'Normal');1041}10421043export async function setMintPermissionExpectSuccess(sender: IKeyringPair, collectionId: number, enabled: boolean) {1044 await usingApi(async (api) => {10451046 // Run the transaction1047 const tx = api.tx.nft.setMintPermission(collectionId, enabled);1048 const events = await submitTransactionAsync(sender, tx);1049 const result = getGenericResult(events);10501051 // Get the collection1052 const collection: any = (await api.query.nft.collectionById(collectionId)).toJSON();10531054 // What to expect1055 // tslint:disable-next-line:no-unused-expression1056 expect(result.success).to.be.true;1057 expect(collection.MintMode).to.be.equal(enabled);1058 });1059}10601061export async function enablePublicMintingExpectSuccess(sender: IKeyringPair, collectionId: number) {1062 await setMintPermissionExpectSuccess(sender, collectionId, true);1063}10641065export async function setMintPermissionExpectFailure(sender: IKeyringPair, collectionId: number, enabled: boolean) {1066 await usingApi(async (api) => {1067 // Run the transaction1068 const tx = api.tx.nft.setMintPermission(collectionId, enabled);1069 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1070 const result = getCreateCollectionResult(events);1071 // tslint:disable-next-line:no-unused-expression1072 expect(result.success).to.be.false;1073 });1074}10751076export async function setChainLimitsExpectFailure(sender: IKeyringPair, limits: IChainLimits) {1077 await usingApi(async (api) => {1078 // Run the transaction1079 const tx = api.tx.nft.setChainLimits(limits);1080 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1081 const result = getCreateCollectionResult(events);1082 // tslint:disable-next-line:no-unused-expression1083 expect(result.success).to.be.false;1084 });1085}10861087export async function isWhitelisted(collectionId: number, address: string) {1088 let whitelisted = false;1089 await usingApi(async (api) => {1090 whitelisted = (await api.query.nft.whiteList(collectionId, address)).toJSON() as unknown as boolean;1091 });1092 return whitelisted;1093}10941095export async function addToWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number, address: string | AccountId) {1096 await usingApi(async (api) => {10971098 const whiteListedBefore = (await api.query.nft.whiteList(collectionId, address)).toJSON();10991100 // Run the transaction1101 const tx = api.tx.nft.addToWhiteList(collectionId, normalizeAccountId(address));1102 const events = await submitTransactionAsync(sender, tx);1103 const result = getGenericResult(events);11041105 const whiteListedAfter = (await api.query.nft.whiteList(collectionId, address)).toJSON();11061107 // What to expect1108 // tslint:disable-next-line:no-unused-expression1109 expect(result.success).to.be.true;1110 // tslint:disable-next-line: no-unused-expression1111 expect(whiteListedBefore).to.be.false;1112 // tslint:disable-next-line: no-unused-expression1113 expect(whiteListedAfter).to.be.true;1114 });1115}11161117export async function addToWhiteListExpectFail(sender: IKeyringPair, collectionId: number, address: string | AccountId) {1118 await usingApi(async (api) => {1119 // Run the transaction1120 const tx = api.tx.nft.addToWhiteList(collectionId, normalizeAccountId(address));1121 const events = await expect(submitTransactionAsync(sender, tx)).to.be.rejected;1122 const result = getGenericResult(events);11231124 // What to expect1125 // tslint:disable-next-line:no-unused-expression1126 expect(result.success).to.be.false;1127 });1128}11291130export async function removeFromWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number, address: CrossAccountId) {1131 await usingApi(async (api) => {1132 // Run the transaction1133 const tx = api.tx.nft.removeFromWhiteList(collectionId, normalizeAccountId(address));1134 const events = await submitTransactionAsync(sender, tx);1135 const result = getGenericResult(events);11361137 // What to expect1138 // tslint:disable-next-line:no-unused-expression1139 expect(result.success).to.be.true;1140 });1141}11421143export async function removeFromWhiteListExpectFailure(sender: IKeyringPair, collectionId: number, address: CrossAccountId) {1144 await usingApi(async (api) => {1145 // Run the transaction1146 const tx = api.tx.nft.removeFromWhiteList(collectionId, normalizeAccountId(address));1147 const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;1148 const result = getGenericResult(events);11491150 // What to expect1151 // tslint:disable-next-line:no-unused-expression1152 expect(result.success).to.be.false;1153 });1154}11551156export const getDetailedCollectionInfo = async (api: ApiPromise, collectionId: number)1157 : Promise<ICollectionInterface | null> => {1158 return (await api.query.nft.collectionById(collectionId)).toJSON() as unknown as ICollectionInterface;1159};11601161export const getCreatedCollectionCount = async (api: ApiPromise): Promise<number> => {1162 // set global object - collectionsCount1163 return (await api.query.nft.createdCollectionCount() as unknown as BN).toNumber();1164};11651166export async function queryCollectionExpectSuccess(collectionId: number): Promise<ICollectionInterface> {1167 return await usingApi(async (api) => {1168 return (await api.query.nft.collectionById(collectionId)).toJSON() as unknown as ICollectionInterface;1169 });1170}