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

difftreelog

Merge pull request #97 from usetech-llc/feature/NFTPAR-281_overflow_tests

Greg Zaitsev2021-02-12parents: #800a78f #22e2b6e.patch.diff
in: master
Fungible overflow tests

8 files changed

modifiedtests/package.jsondiffbeforeafterboth
--- a/tests/package.json
+++ b/tests/package.json
@@ -40,7 +40,8 @@
     "testSetMintPermission": "mocha --timeout 9999999 -r ts-node/register ./**/setMintPermission.test.ts",
     "testCreditFeesToTreasury": "mocha --timeout 9999999 -r ts-node/register ./**/creditFeesToTreasury.test.ts",
     "testEnableContractSponsoring": "mocha --timeout 9999999 -r ts-node/register ./**/enableContractSponsoring.test.ts",
-    "testSetContractSponsoringRateLimit": "mocha --timeout 9999999 -r ts-node/register ./**/setContractSponsoringRateLimit.test.ts"
+    "testSetContractSponsoringRateLimit": "mocha --timeout 9999999 -r ts-node/register ./**/setContractSponsoringRateLimit.test.ts",
+    "testOverflow": "mocha --timeout 9999999 -r ts-node/register ./**/overflow.test.ts"
   },
   "author": "",
   "license": "SEE LICENSE IN ../LICENSE",
modifiedtests/src/approve.test.tsdiffbeforeafterboth
--- a/tests/src/approve.test.ts
+++ b/tests/src/approve.test.ts
@@ -12,8 +12,11 @@
   approveExpectFail,
   approveExpectSuccess,
   createCollectionExpectSuccess,
+  createFungibleItemExpectSuccess,
   createItemExpectSuccess,
   destroyCollectionExpectSuccess,
+  transferFromExpectSuccess,
+  U128_MAX,
 } from './util/helpers';
 
 chai.use(chaiAsPromised);
addedtests/src/overflow.test.tsdiffbeforeafterboth
--- /dev/null
+++ b/tests/src/overflow.test.ts
@@ -0,0 +1,67 @@
+//
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE', which is part of this source code package.
+//
+
+import { IKeyringPair } from "@polkadot/types/types";
+import chai from 'chai';
+import chaiAsPromised from "chai-as-promised";
+import privateKey from "./substrate/privateKey";
+import usingApi from "./substrate/substrate-api";
+import { approveExpectFail, approveExpectSuccess, createCollectionExpectSuccess, createFungibleItemExpectSuccess, getAllowance, getFungibleBalance, transferExpectFail, transferExpectSuccess, transferFromExpectFail, transferFromExpectSuccess, U128_MAX } from "./util/helpers";
+
+chai.use(chaiAsPromised);
+const expect = chai.expect;
+
+describe('Integration Test fungible overflows', () => {
+    let alice: IKeyringPair;
+    let bob: IKeyringPair;
+    let charlie: IKeyringPair;
+
+    before(async () => {
+        await usingApi(async () => {
+            alice = privateKey('//Alice');
+            bob = privateKey('//Bob');
+            charlie = privateKey('//Charlie');
+        });
+    });
+
+    it('fails when overflows on transfer', async () => {
+        const fungibleCollectionId = await createCollectionExpectSuccess({ mode: { type: 'Fungible', decimalPoints: 0 } });
+
+        await createFungibleItemExpectSuccess(alice, fungibleCollectionId, { Value: U128_MAX });
+        await transferExpectSuccess(fungibleCollectionId, 0, alice, bob, U128_MAX, 'Fungible');
+
+        await createFungibleItemExpectSuccess(alice, fungibleCollectionId, { Value: 1n });
+        await transferExpectFail(fungibleCollectionId, 0, alice, bob, 1, 'Fungible');
+
+        expect(await getFungibleBalance(fungibleCollectionId, alice.address)).to.equal(1n);
+        expect(await getFungibleBalance(fungibleCollectionId, bob.address)).to.equal(U128_MAX);
+    });
+
+    it('fails on allowance overflow', async () => {
+        const fungibleCollectionId = await createCollectionExpectSuccess({ mode: { type: 'Fungible', decimalPoints: 0 } });
+
+        await createFungibleItemExpectSuccess(alice, fungibleCollectionId, { Value: U128_MAX });
+        await approveExpectSuccess(fungibleCollectionId, 0, alice, bob, U128_MAX);
+        await approveExpectFail(fungibleCollectionId, 0, alice, bob, U128_MAX);
+    });
+
+    it('fails when overflows on transferFrom', async () => {
+        const fungibleCollectionId = await createCollectionExpectSuccess({ mode: { type: 'Fungible', decimalPoints: 0 } });
+
+        await createFungibleItemExpectSuccess(alice, fungibleCollectionId, { Value: U128_MAX });
+        await approveExpectSuccess(fungibleCollectionId, 0, alice, bob, U128_MAX);
+        await transferFromExpectSuccess(fungibleCollectionId, 0, bob, alice, charlie, U128_MAX, 'Fungible');
+
+        expect(await getFungibleBalance(fungibleCollectionId, charlie.address)).to.equal(U128_MAX);
+        expect((await getAllowance(fungibleCollectionId, 0, alice.address, bob.address)).toString()).to.equal('0');
+
+        await createFungibleItemExpectSuccess(alice, fungibleCollectionId, { Value: U128_MAX });
+        await approveExpectSuccess(fungibleCollectionId, 0, alice, bob, 1n);
+        await transferFromExpectFail(fungibleCollectionId, 0, bob, alice, charlie, 1);
+
+        expect(await getFungibleBalance(fungibleCollectionId, charlie.address)).to.equal(U128_MAX);
+        expect((await getAllowance(fungibleCollectionId, 0, alice.address, bob.address)).toString()).to.equal('1');
+    });
+});
modifiedtests/src/removeFromContractWhiteList.test.tsdiffbeforeafterboth
--- a/tests/src/removeFromContractWhiteList.test.ts
+++ b/tests/src/removeFromContractWhiteList.test.ts
@@ -1,3 +1,8 @@
+//
+// This file is subject to the terms and conditions defined in
+// file 'LICENSE', which is part of this source code package.
+//
+
 import privateKey from "./substrate/privateKey";
 import usingApi from "./substrate/substrate-api";
 import { deployFlipper, toggleFlipValueExpectFailure, toggleFlipValueExpectSuccess } from "./util/contracthelpers";
modifiedtests/src/substrate/substrate-api.tsdiffbeforeafterboth
--- a/tests/src/substrate/substrate-api.ts
+++ b/tests/src/substrate/substrate-api.ts
@@ -18,9 +18,10 @@
   return { provider: wsProvider, types: rtt };
 }
 
-export default async function usingApi(action: (api: ApiPromise) => Promise<void>, settings: ApiOptions | undefined = undefined): Promise<void> {
+export default async function usingApi<T = void>(action: (api: ApiPromise) => Promise<T>, settings: ApiOptions | undefined = undefined): Promise<T> {
   settings = settings || defaultApiOptions();
   let api: ApiPromise = new ApiPromise(settings);
+  let result: T = null as unknown as T;
 
   // TODO: Remove, this is temporary: Filter unneeded API output 
   // (Jaco promised it will be removed in the next version)
@@ -32,15 +33,16 @@
 
   try {
     await promisifySubstrate(api, async () => {
-      if(api) {
+      if (api) {
         await api.isReadyOrError;
-        await action(api);
+        result = await action(api);
       }
     })();
   } finally {
     await api.disconnect();
     console.error = consoleErr;
   }
+  return result as T;
 }
 
 enum TransactionStatus {
modifiedtests/src/transferFrom.test.tsdiffbeforeafterboth
--- a/tests/src/transferFrom.test.ts
+++ b/tests/src/transferFrom.test.ts
@@ -11,8 +11,10 @@
   approveExpectFail,
   approveExpectSuccess,
   createCollectionExpectSuccess,
+  createFungibleItemExpectSuccess,
   createItemExpectSuccess,
   destroyCollectionExpectSuccess,
+  getAllowance,
   transferFromExpectFail,
   transferFromExpectSuccess,
   burnItemExpectSuccess,
@@ -48,6 +50,22 @@
         newReFungibleTokenId, Bob, Alice, Charlie, 100, 'ReFungible');
     });
   });
+
+  it('Should reduce allowance if value is big', async () => {
+    await usingApi(async () => {
+      const alice = privateKey('//Alice');
+      const bob = privateKey('//Bob');
+      const charlie = privateKey('//Charlie');
+
+      // fungible
+      const fungibleCollectionId = await createCollectionExpectSuccess({mode: {type: 'Fungible', decimalPoints: 0}});
+      const newFungibleTokenId = await createFungibleItemExpectSuccess(alice, fungibleCollectionId, { Value: 500000n });
+
+      await approveExpectSuccess(fungibleCollectionId, newFungibleTokenId, alice, bob, 500000n);
+      await transferFromExpectSuccess(fungibleCollectionId, newFungibleTokenId, bob, alice, charlie, 500000n, 'Fungible');
+      expect((await getAllowance(fungibleCollectionId, newFungibleTokenId, alice.address, bob.address)).toString()).to.equal('0');
+    });
+  });
 });
 
 describe('Negative Integration Test transferFrom(from, recipient, collection_id, item_id, value):', () => {
modifiedtests/src/util/helpers.tsdiffbeforeafterboth
before · tests/src/util/helpers.ts
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 { Enum, Struct } from '@polkadot/types/codec';8import type { AccountId, EventRecord } from '@polkadot/types/interfaces';9import { u128 } from '@polkadot/types/primitive';10import { IKeyringPair } from '@polkadot/types/types';11import { BigNumber } from 'bignumber.js';12import BN from 'bn.js';13import chai from 'chai';14import chaiAsPromised from 'chai-as-promised';15import { alicesPublicKey, nullPublicKey } from '../accounts';16import privateKey from '../substrate/privateKey';17import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from '../substrate/substrate-api';18import { ICollectionInterface } from '../types';19import { hexToStr, strToUTF16, utf16ToStr } from './util';2021chai.use(chaiAsPromised);22const expect = chai.expect;2324type GenericResult = {25  success: boolean,26};2728interface CreateCollectionResult {29  success: boolean;30  collectionId: number;31}3233interface CreateItemResult {34  success: boolean;35  collectionId: number;36  itemId: number;37}3839interface IReFungibleOwner {40  Fraction: BN;41  Owner: number[];42}4344interface ITokenDataType {45  Owner: number[];46  ConstData: number[];47  VariableData: number[];48}4950interface IFungibleTokenDataType {51  Value: BN;52}5354export interface IReFungibleTokenDataType {55  Owner: IReFungibleOwner[];56  ConstData: number[];57  VariableData: number[];58}5960export function getGenericResult(events: EventRecord[]): GenericResult {61  const result: GenericResult = {62    success: false,63  };64  events.forEach(({ phase, event: { data, method, section } }) => {65    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);66    if (method === 'ExtrinsicSuccess') {67      result.success = true;68    }69  });70  return result;71}7273export function getCreateCollectionResult(events: EventRecord[]): CreateCollectionResult {74  let success = false;75  let collectionId: number = 0;76  events.forEach(({ phase, event: { data, method, section } }) => {77    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);78    if (method == 'ExtrinsicSuccess') {79      success = true;80    } else if ((section == 'nft') && (method == 'Created')) {81      collectionId = parseInt(data[0].toString());82    }83  });84  const result: CreateCollectionResult = {85    success,86    collectionId,87  };88  return result;89}9091export function getCreateItemResult(events: EventRecord[]): CreateItemResult {92  let success = false;93  let collectionId: number = 0;94  let itemId: number = 0;95  events.forEach(({ phase, event: { data, method, section } }) => {96    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);97    if (method == 'ExtrinsicSuccess') {98      success = true;99    } else if ((section == 'nft') && (method == 'ItemCreated')) {100      collectionId = parseInt(data[0].toString());101      itemId = parseInt(data[1].toString());102    }103  });104  const result: CreateItemResult = {105    success,106    collectionId,107    itemId,108  };109  return result;110}111112interface Invalid {113  type: 'Invalid';114}115116interface Nft {117  type: 'NFT';118}119120interface Fungible {121  type: 'Fungible';122  decimalPoints: number;123}124125interface ReFungible {126  type: 'ReFungible';127}128129type CollectionMode = Nft | Fungible | ReFungible | Invalid;130131export type CreateCollectionParams = {132  mode: CollectionMode,133  name: string,134  description: string,135  tokenPrefix: string,136};137138const defaultCreateCollectionParams: CreateCollectionParams = {139  description: 'description',140  mode: { type: 'NFT' },141  name: 'name',142  tokenPrefix: 'prefix',143}144145export async function createCollectionExpectSuccess(params: Partial<CreateCollectionParams> = {}): Promise<number> {146  const {name, description, mode, tokenPrefix } = {...defaultCreateCollectionParams, ...params};147148  let collectionId: number = 0;149  await usingApi(async (api) => {150    // Get number of collections before the transaction151    const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10);152153    // Run the CreateCollection transaction154    const alicePrivateKey = privateKey('//Alice');155156    let modeprm = {};157    if (mode.type === 'NFT') {158      modeprm = {nft: null};159    } else if (mode.type === 'Fungible') {160      modeprm = {fungible: mode.decimalPoints};161    } else if (mode.type === 'ReFungible') {162      modeprm = {refungible: null};163    } else if (mode.type === 'Invalid') {164      modeprm = {invalid: null};165    }166167    const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), modeprm);168    const events = await submitTransactionAsync(alicePrivateKey, tx);169    const result = getCreateCollectionResult(events);170171    // Get number of collections after the transaction172    const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10);173174    // Get the collection175    const collection: any = (await api.query.nft.collection(result.collectionId)).toJSON();176177    // What to expect178    // tslint:disable-next-line:no-unused-expression179    expect(result.success).to.be.true;180    expect(result.collectionId).to.be.equal(BcollectionCount);181    // tslint:disable-next-line:no-unused-expression182    expect(collection).to.be.not.null;183    expect(BcollectionCount).to.be.equal(AcollectionCount + 1, 'Error: NFT collection NOT created.');184    expect(collection.Owner).to.be.equal(alicesPublicKey);185    expect(utf16ToStr(collection.Name)).to.be.equal(name);186    expect(utf16ToStr(collection.Description)).to.be.equal(description);187    expect(hexToStr(collection.TokenPrefix)).to.be.equal(tokenPrefix);188189    collectionId = result.collectionId;190  });191192  return collectionId;193}194195export async function createCollectionExpectFailure(params: Partial<CreateCollectionParams> = {}) {196  const {name, description, mode, tokenPrefix } = {...defaultCreateCollectionParams, ...params};197198  let modeprm = {};199  if (mode.type === 'NFT') {200    modeprm = {nft: null};201  } else if (mode.type === 'Fungible') {202    modeprm = {fungible: mode.decimalPoints};203  } else if (mode.type === 'ReFungible') {204    modeprm = {refungible: null};205  } else if (mode.type === 'Invalid') {206    modeprm = {invalid: null};207  }208209  await usingApi(async (api) => {210    // Get number of collections before the transaction211    const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());212213    // Run the CreateCollection transaction214    const alicePrivateKey = privateKey('//Alice');215    const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), modeprm);216    const events = await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;217    const result = getCreateCollectionResult(events);218219    // Get number of collections after the transaction220    const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());221222    // What to expect223    // tslint:disable-next-line:no-unused-expression224    expect(result.success).to.be.false;225    expect(BcollectionCount).to.be.equal(AcollectionCount, 'Error: Collection with incorrect data created.');226  });227}228229export async function findUnusedAddress(api: ApiPromise, seedAddition = ''): Promise<IKeyringPair> {230  let bal = new BigNumber(0);231  let unused;232  do {233    const randomSeed = 'seed' +  Math.floor(Math.random() * Math.floor(10000)) + seedAddition;234    const keyring = new Keyring({ type: 'sr25519' });235    unused = keyring.addFromUri(`//${randomSeed}`);236    bal = new BigNumber((await api.query.system.account(unused.address)).data.free.toString());237  } while (bal.toFixed() != '0');238  return unused;239}240241export function findUnusedAddresses(api: ApiPromise, amount: number): Promise<IKeyringPair[]> {242  return Promise.all(new Array(amount).fill(null).map(() => findUnusedAddress(api, '_' + Date.now())));243}244245export async function findNotExistingCollection(api: ApiPromise): Promise<number> {246  const totalNumber = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10) as unknown as number;247  const newCollection: number = totalNumber + 1;248  return newCollection;249}250251function getDestroyResult(events: EventRecord[]): boolean {252  let success: boolean = false;253  events.forEach(({ phase, event: { data, method, section } }) => {254    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);255    if (method == 'ExtrinsicSuccess') {256      success = true;257    }258  });259  return success;260}261262export async function destroyCollectionExpectFailure(collectionId: number, senderSeed: string = '//Alice') {263  await usingApi(async (api) => {264    // Run the DestroyCollection transaction265    const alicePrivateKey = privateKey(senderSeed);266    const tx = api.tx.nft.destroyCollection(collectionId);267    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;268  });269}270271export async function destroyCollectionExpectSuccess(collectionId: number, senderSeed: string = '//Alice') {272  await usingApi(async (api) => {273    // Run the DestroyCollection transaction274    const alicePrivateKey = privateKey(senderSeed);275    const tx = api.tx.nft.destroyCollection(collectionId);276    const events = await submitTransactionAsync(alicePrivateKey, tx);277    const result = getDestroyResult(events);278279    // Get the collection280    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();281282    // What to expect283    expect(result).to.be.true;284    expect(collection).to.be.not.null;285    expect(collection.Owner).to.be.equal(nullPublicKey);286  });287}288289export async function setCollectionSponsorExpectSuccess(collectionId: number, sponsor: string) {290  await usingApi(async (api) => {291292    // Run the transaction293    const alicePrivateKey = privateKey('//Alice');294    const tx = api.tx.nft.setCollectionSponsor(collectionId, sponsor);295    const events = await submitTransactionAsync(alicePrivateKey, tx);296    const result = getGenericResult(events);297298    // Get the collection299    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();300301    // What to expect302    expect(result.success).to.be.true;303    expect(collection.Sponsor.toString()).to.be.equal(sponsor.toString());304    expect(collection.SponsorConfirmed).to.be.false;305  });306}307308export async function removeCollectionSponsorExpectSuccess(collectionId: number) {309  await usingApi(async (api) => {310311    // Run the transaction312    const alicePrivateKey = privateKey('//Alice');313    const tx = api.tx.nft.removeCollectionSponsor(collectionId);314    const events = await submitTransactionAsync(alicePrivateKey, tx);315    const result = getGenericResult(events);316317    // Get the collection318    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();319320    // What to expect321    expect(result.success).to.be.true;322    expect(collection.Sponsor).to.be.equal(nullPublicKey);323    expect(collection.SponsorConfirmed).to.be.false;324  });325}326327export async function removeCollectionSponsorExpectFailure(collectionId: number) {328  await usingApi(async (api) => {329330    // Run the transaction331    const alicePrivateKey = privateKey('//Alice');332    const tx = api.tx.nft.removeCollectionSponsor(collectionId);333    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;334  });335}336337export async function setCollectionSponsorExpectFailure(collectionId: number, sponsor: string, senderSeed: string = '//Alice') {338  await usingApi(async (api) => {339340    // Run the transaction341    const alicePrivateKey = privateKey(senderSeed);342    const tx = api.tx.nft.setCollectionSponsor(collectionId, sponsor);343    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;344  });345}346347export async function confirmSponsorshipExpectSuccess(collectionId: number, senderSeed: string = '//Alice') {348  await usingApi(async (api) => {349350    // Run the transaction351    const sender = privateKey(senderSeed);352    const tx = api.tx.nft.confirmSponsorship(collectionId);353    const events = await submitTransactionAsync(sender, tx);354    const result = getGenericResult(events);355356    // Get the collection357    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();358359    // What to expect360    expect(result.success).to.be.true;361    expect(collection.Sponsor).to.be.equal(sender.address);362    expect(collection.SponsorConfirmed).to.be.true;363  });364}365366367export async function confirmSponsorshipExpectFailure(collectionId: number, senderSeed: string = '//Alice') {368  await usingApi(async (api) => {369370    // Run the transaction371    const sender = privateKey(senderSeed);372    const tx = api.tx.nft.confirmSponsorship(collectionId);373    await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;374  });375}376377export async function enableContractSponsoringExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {378  await usingApi(async (api) => {379    const tx = api.tx.nft.enableContractSponsoring(contractAddress, enable);380    const events = await submitTransactionAsync(sender, tx);381    const result = getGenericResult(events);382383    expect(result.success).to.be.true;384  });385}386387export async function enableContractSponsoringExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {388  await usingApi(async (api) => {389    const tx = api.tx.nft.enableContractSponsoring(contractAddress, enable);390    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;391    const result = getGenericResult(events);392393    expect(result.success).to.be.false;394  });395}396397export async function setContractSponsoringRateLimitExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {398  await usingApi(async (api) => {399    const tx = api.tx.nft.setContractSponsoringRateLimit(contractAddress, rateLimit);400    const events = await submitTransactionAsync(sender, tx);401    const result = getGenericResult(events);402403    expect(result.success).to.be.true;404  });405}406407export async function setContractSponsoringRateLimitExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {408  await usingApi(async (api) => {409    const tx = api.tx.nft.setContractSponsoringRateLimit(contractAddress, rateLimit);410    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;411    const result = getGenericResult(events);412413    expect(result.success).to.be.false;414  });415}416417export async function toggleContractWhitelistExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, enabled: boolean) {418  await usingApi(async (api) => {419    const tx = api.tx.nft.toggleContractWhiteList(contractAddress, true);420    const events = await submitTransactionAsync(sender, tx);421    const result = getGenericResult(events);422423    expect(result.success).to.be.true;424  });425}426427export async function isWhitelistedInContract(contractAddress: AccountId | string, user: string) {428  let whitelisted: boolean = false;429  await usingApi(async (api) => {430    whitelisted = (await api.query.nft.contractWhiteList(contractAddress, user)).toJSON() as boolean;431  });432  return whitelisted;433}434435export async function addToContractWhiteListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: string) {436  await usingApi(async (api) => {437    const tx = api.tx.nft.addToContractWhiteList(contractAddress, user);438    const events = await submitTransactionAsync(sender, tx);439    const result = getGenericResult(events);440441    expect(result.success).to.be.true;442  });443}444445export async function removeFromContractWhiteListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: string) {446  await usingApi(async (api) => {447    const tx = api.tx.nft.removeFromContractWhiteList(contractAddress, user);448    const events = await submitTransactionAsync(sender, tx);449    const result = getGenericResult(events);450451    expect(result.success).to.be.true;452  });453}454455export async function removeFromContractWhiteListExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, user: string) {456  await usingApi(async (api) => {457    const tx = api.tx.nft.removeFromContractWhiteList(contractAddress, user);458    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;459    const result = getGenericResult(events);460461    expect(result.success).to.be.false;462  });463}464465export async function setVariableMetaDataExpectSuccess(sender: IKeyringPair, collectionId: number, itemId: number, data: number[]) {466  await usingApi(async (api) => {467    const tx = api.tx.nft.setVariableMetaData(collectionId, itemId, '0x' + Buffer.from(data).toString('hex'));468    const events = await submitTransactionAsync(sender, tx);469    const result = getGenericResult(events);470471    expect(result.success).to.be.true;472  });473}474475export async function setVariableMetaDataExpectFailure(sender: IKeyringPair, collectionId: number, itemId: number, data: number[]) {476  await usingApi(async (api) => {477    const tx = api.tx.nft.setVariableMetaData(collectionId, itemId, '0x' + Buffer.from(data).toString('hex'));478    await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;479  });480}481482export interface CreateFungibleData extends Struct {483  readonly value: u128;484}485486export interface CreateReFungibleData extends Struct {}487export interface CreateNftData extends Struct {}488489export interface CreateItemData extends Enum {490  NFT: CreateNftData;491  Fungible: CreateFungibleData;492  ReFungible: CreateReFungibleData;493}494495export async function burnItemExpectSuccess(owner: IKeyringPair, collectionId: number, tokenId: number, value = 0) {496  await usingApi(async (api) => {497    const tx = api.tx.nft.burnItem(collectionId, tokenId, value);498    const events = await submitTransactionAsync(owner, tx);499    const result = getGenericResult(events);500    // Get the item501    const item: any = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON();502    // What to expect503    // tslint:disable-next-line:no-unused-expression504    expect(result.success).to.be.true;505    // tslint:disable-next-line:no-unused-expression506    expect(item).to.be.not.null;507    expect(item.Owner).to.be.equal(nullPublicKey);508  });509}510511export async function512approveExpectSuccess(collectionId: number,513                     tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number = 1) { //alice,bob514  await usingApi(async (api: ApiPromise) => {515    const allowanceBefore =516      await api.query.nft.allowances(collectionId, [tokenId, owner.address, approved.address]) as unknown as BN;517    const approveNftTx = await api.tx.nft.approve(approved.address, collectionId, tokenId, amount);518    const events = await submitTransactionAsync(owner, approveNftTx);519    const result = getCreateItemResult(events);520    // tslint:disable-next-line:no-unused-expression521    expect(result.success).to.be.true;522    const allowanceAfter =523      await api.query.nft.allowances(collectionId, [tokenId, owner.address, approved.address]) as unknown as BN;524    expect(allowanceAfter.toNumber() - allowanceBefore.toNumber()).to.be.equal(amount);525  });526}527528export async function529transferFromExpectSuccess(collectionId: number,530                          tokenId: number,531                          accountApproved: IKeyringPair, //bob532                          accountFrom: IKeyringPair, //alice533                          accountTo: IKeyringPair, //charlie534                          value: number = 1,535                          type: string = 'NFT') {536  await usingApi(async (api: ApiPromise) => {537    let balanceBefore = new BN(0);538    if (type === 'Fungible') {539      balanceBefore = await api.query.nft.balance(collectionId, accountTo.address) as unknown as BN;540    }541    const transferFromTx = await api.tx.nft.transferFrom(542      accountFrom.address, accountTo.address, collectionId, tokenId, value);543    const events = await submitTransactionAsync(accountApproved, transferFromTx);544    const result = getCreateItemResult(events);545    // tslint:disable-next-line:no-unused-expression546    expect(result.success).to.be.true;547    if (type === 'NFT') {548      const nftItemData = await api.query.nft.nftItemList(collectionId, tokenId) as unknown as ITokenDataType;549      expect(nftItemData.Owner.toString()).to.be.equal(accountTo.address);550    }551    if (type === 'Fungible') {552      const balanceAfter = await api.query.nft.balance(collectionId, accountTo.address) as unknown as BN;553      expect(balanceAfter.sub(balanceBefore).toNumber()).to.be.equal(value);554    }555    if (type === 'ReFungible') {556      const nftItemData =557        await api.query.nft.reFungibleItemList(collectionId, tokenId) as unknown as IReFungibleTokenDataType;558      expect(nftItemData.Owner[0].Owner.toString()).to.be.equal(accountTo.address);559      expect(nftItemData.Owner[0].Fraction.toNumber()).to.be.equal(value);560    }561  });562}563564export async function565transferFromExpectFail(collectionId: number,566                       tokenId: number,567                       accountApproved: IKeyringPair,568                       accountFrom: IKeyringPair,569                       accountTo: IKeyringPair,570                       value: number = 1) {571  await usingApi(async (api: ApiPromise) => {572    const transferFromTx = await api.tx.nft.transferFrom(573      accountFrom.address, accountTo.address, collectionId, tokenId, value);574    const events = await expect(submitTransactionExpectFailAsync(accountApproved, transferFromTx)).to.be.rejected;575    const result = getCreateCollectionResult(events);576    // tslint:disable-next-line:no-unused-expression577    expect(result.success).to.be.false;578  });579}580581export async function582transferExpectSuccess(collectionId: number,583                      tokenId: number,584                      sender: IKeyringPair,585                      recipient: IKeyringPair,586                      value: number = 1,587                      type: string = 'NFT') {588  await usingApi(async (api: ApiPromise) => {589    let balanceBefore = new BN(0);590    if (type === 'Fungible') {591      balanceBefore = await api.query.nft.balance(collectionId, recipient.address) as unknown as BN;592    }593    const transferTx = await api.tx.nft.transfer(recipient.address, collectionId, tokenId, value);594    const events = await submitTransactionAsync(sender, transferTx);595    const result = getCreateItemResult(events);596    // tslint:disable-next-line:no-unused-expression597    expect(result.success).to.be.true;598    if (type === 'NFT') {599      const nftItemData = await api.query.nft.nftItemList(collectionId, tokenId) as unknown as ITokenDataType;600      expect(nftItemData.Owner.toString()).to.be.equal(recipient.address);601    }602    if (type === 'Fungible') {603      const balanceAfter = await api.query.nft.balance(collectionId, recipient.address) as unknown as BN;604      expect(balanceAfter.sub(balanceBefore).toNumber()).to.be.equal(value);605    }606    if (type === 'ReFungible') {607      const nftItemData =608        await api.query.nft.reFungibleItemList(collectionId, tokenId) as unknown as IReFungibleTokenDataType;609      expect(nftItemData.Owner[0].Owner.toString()).to.be.equal(recipient.address);610      expect(nftItemData.Owner[0].Fraction.toNumber()).to.be.equal(value);611    }612  });613}614615export async function616transferExpectFail(collectionId: number,617                   tokenId: number,618                   sender: IKeyringPair,619                   recipient: IKeyringPair,620                   value: number = 1,621                   type: string = 'NFT') {622  await usingApi(async (api: ApiPromise) => {623    const transferTx = await api.tx.nft.transfer(recipient.address, collectionId, tokenId, value);624    const events = await expect(submitTransactionExpectFailAsync(sender, transferTx)).to.be.rejected;625    if (events && Array.isArray(events)) {626      const result = getCreateCollectionResult(events);627      // tslint:disable-next-line:no-unused-expression628      expect(result.success).to.be.false;629    }630  });631}632633export async function634approveExpectFail(collectionId: number,635                  tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number = 1) {636  await usingApi(async (api: ApiPromise) => {637    const approveNftTx = await api.tx.nft.approve(approved.address, collectionId, tokenId, amount);638    const events = await expect(submitTransactionExpectFailAsync(owner, approveNftTx)).to.be.rejected;639    const result = getCreateCollectionResult(events);640    // tslint:disable-next-line:no-unused-expression641    expect(result.success).to.be.false;642  });643}644645export async function createItemExpectSuccess(646  sender: IKeyringPair, collectionId: number, createMode: string, owner: string = '') {647  let newItemId: number = 0;648  await usingApi(async (api) => {649    const AItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);650    const Aitem: any = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON();651    const AItemBalance = new BigNumber(Aitem.Value);652653    if (owner === '') {654      owner = sender.address;655    }656657    let tx;658    if (createMode === 'Fungible') {659      const createData = {fungible: {value: 10}};660      tx = api.tx.nft.createItem(collectionId, owner, createData);661    } else if (createMode === 'ReFungible') {662      const createData = {refungible: {const_data: [], variable_data: [], pieces: 100}};663      tx = api.tx.nft.createItem(collectionId, owner, createData);664    } else {665      tx = api.tx.nft.createItem(collectionId, owner, createMode);666    }667    const events = await submitTransactionAsync(sender, tx);668    const result = getCreateItemResult(events);669670    const BItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);671    const Bitem: any = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON();672    const BItemBalance = new BigNumber(Bitem.Value);673674    // What to expect675    // tslint:disable-next-line:no-unused-expression676    expect(result.success).to.be.true;677    if (createMode === 'Fungible') {678      expect(BItemBalance.minus(AItemBalance).toNumber()).to.be.equal(10);679    } else {680      expect(BItemCount).to.be.equal(AItemCount + 1);681    }682    expect(collectionId).to.be.equal(result.collectionId);683    expect(BItemCount).to.be.equal(result.itemId);684    newItemId = result.itemId;685  });686  return newItemId;687}688689export async function createItemExpectFailure(690  sender: IKeyringPair, collectionId: number, createMode: string, owner: string = sender.address) {691  await usingApi(async (api) => {692    const tx = api.tx.nft.createItem(collectionId, owner, createMode);693    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;694    const result = getCreateItemResult(events);695696    expect(result.success).to.be.false;697  });698}699700export async function setPublicAccessModeExpectSuccess(701  sender: IKeyringPair, collectionId: number,702  accessMode: 'Normal' | 'WhiteList',703) {704  await usingApi(async (api) => {705706    // Run the transaction707    const tx = api.tx.nft.setPublicAccessMode(collectionId, accessMode);708    const events = await submitTransactionAsync(sender, tx);709    const result = getGenericResult(events);710711    // Get the collection712    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();713714    // What to expect715    // tslint:disable-next-line:no-unused-expression716    expect(result.success).to.be.true;717    expect(collection.Access).to.be.equal(accessMode);718  });719}720721export async function enableWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number) {722  await setPublicAccessModeExpectSuccess(sender, collectionId, 'WhiteList');723}724725export async function disableWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number) {726  await setPublicAccessModeExpectSuccess(sender, collectionId, 'Normal');727}728729export async function setMintPermissionExpectSuccess(sender: IKeyringPair, collectionId: number, enabled: boolean) {730  await usingApi(async (api) => {731732    // Run the transaction733    const tx = api.tx.nft.setMintPermission(collectionId, enabled);734    const events = await submitTransactionAsync(sender, tx);735    const result = getGenericResult(events);736737    // Get the collection738    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();739740    // What to expect741    // tslint:disable-next-line:no-unused-expression742    expect(result.success).to.be.true;743    expect(collection.MintMode).to.be.equal(enabled);744  });745}746747export async function enablePublicMintingExpectSuccess(sender: IKeyringPair, collectionId: number) {748  await setMintPermissionExpectSuccess(sender, collectionId, true);749}750751export async function setMintPermissionExpectFailure(sender: IKeyringPair, collectionId: number, enabled: boolean) {752  await usingApi(async (api) => {753    // Run the transaction754    const tx = api.tx.nft.setMintPermission(collectionId, enabled);755    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;756    const result = getCreateCollectionResult(events);757    // tslint:disable-next-line:no-unused-expression758    expect(result.success).to.be.false;759  });760}761762export async function isWhitelisted(collectionId: number, address: string) {763  let whitelisted: boolean = false;764  await usingApi(async (api) => {765    whitelisted = (await api.query.nft.whiteList(collectionId, address)).toJSON() as unknown as boolean;766  });767  return whitelisted;768}769770export async function addToWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number, address: string) {771  await usingApi(async (api) => {772773    const whiteListedBefore = (await api.query.nft.whiteList(collectionId, address)).toJSON();774775    // Run the transaction776    const tx = api.tx.nft.addToWhiteList(collectionId, address);777    const events = await submitTransactionAsync(sender, tx);778    const result = getGenericResult(events);779780    const whiteListedAfter = (await api.query.nft.whiteList(collectionId, address)).toJSON();781782    // What to expect783    // tslint:disable-next-line:no-unused-expression784    expect(result.success).to.be.true;785    // tslint:disable-next-line: no-unused-expression786    expect(whiteListedBefore).to.be.false;787    // tslint:disable-next-line: no-unused-expression788    expect(whiteListedAfter).to.be.true;789  });790}791792export async function removeFromWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number, address: string) {793  await usingApi(async (api) => {794    // Run the transaction795    const tx = api.tx.nft.removeFromWhiteList(collectionId, address);796    const events = await submitTransactionAsync(sender, tx);797    const result = getGenericResult(events);798799    // What to expect800    // tslint:disable-next-line:no-unused-expression801    expect(result.success).to.be.true;802  });803}804805export async function removeFromWhiteListExpectFailure(sender: IKeyringPair, collectionId: number, address: string) {806  await usingApi(async (api) => {807    // Run the transaction808    const tx = api.tx.nft.removeFromWhiteList(collectionId, address);809    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;810    const result = getGenericResult(events);811812    // What to expect813    // tslint:disable-next-line:no-unused-expression814    expect(result.success).to.be.false;815  });816}817818export const getDetailedCollectionInfo = async (api: ApiPromise, collectionId: number)819  : Promise<ICollectionInterface | null> => {820  return await api.query.nft.collection(collectionId) as unknown as ICollectionInterface;821};822823export const getCreatedCollectionCount = async (api: ApiPromise): Promise<number> => {824  // set global object - collectionsCount825  return (await api.query.nft.createdCollectionCount() as unknown as BN).toNumber();826};
after · tests/src/util/helpers.ts
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 { Enum, Struct } from '@polkadot/types/codec';8import type { AccountId, EventRecord } from '@polkadot/types/interfaces';9import { u128 } from '@polkadot/types/primitive';10import { IKeyringPair } from '@polkadot/types/types';11import { BigNumber } from 'bignumber.js';12import BN from 'bn.js';13import chai from 'chai';14import chaiAsPromised from 'chai-as-promised';15import { alicesPublicKey, nullPublicKey } from '../accounts';16import privateKey from '../substrate/privateKey';17import { default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync } from '../substrate/substrate-api';18import { ICollectionInterface } from '../types';19import { hexToStr, strToUTF16, utf16ToStr } from './util';2021chai.use(chaiAsPromised);22const expect = chai.expect;2324export const U128_MAX = (1n << 128n) - 1n;2526type GenericResult = {27  success: boolean,28};2930interface CreateCollectionResult {31  success: boolean;32  collectionId: number;33}3435interface CreateItemResult {36  success: boolean;37  collectionId: number;38  itemId: number;39}4041interface IReFungibleOwner {42  Fraction: BN;43  Owner: number[];44}4546interface ITokenDataType {47  Owner: number[];48  ConstData: number[];49  VariableData: number[];50}5152interface IFungibleTokenDataType {53  Value: BN;54}5556export interface IReFungibleTokenDataType {57  Owner: IReFungibleOwner[];58  ConstData: number[];59  VariableData: number[];60}6162export function getGenericResult(events: EventRecord[]): GenericResult {63  const result: GenericResult = {64    success: false,65  };66  events.forEach(({ phase, event: { data, method, section } }) => {67    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);68    if (method === 'ExtrinsicSuccess') {69      result.success = true;70    }71  });72  return result;73}7475export function getCreateCollectionResult(events: EventRecord[]): CreateCollectionResult {76  let success = false;77  let collectionId: number = 0;78  events.forEach(({ phase, event: { data, method, section } }) => {79    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);80    if (method == 'ExtrinsicSuccess') {81      success = true;82    } else if ((section == 'nft') && (method == 'Created')) {83      collectionId = parseInt(data[0].toString());84    }85  });86  const result: CreateCollectionResult = {87    success,88    collectionId,89  };90  return result;91}9293export function getCreateItemResult(events: EventRecord[]): CreateItemResult {94  let success = false;95  let collectionId: number = 0;96  let itemId: number = 0;97  events.forEach(({ phase, event: { data, method, section } }) => {98    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);99    if (method == 'ExtrinsicSuccess') {100      success = true;101    } else if ((section == 'nft') && (method == 'ItemCreated')) {102      collectionId = parseInt(data[0].toString());103      itemId = parseInt(data[1].toString());104    }105  });106  const result: CreateItemResult = {107    success,108    collectionId,109    itemId,110  };111  return result;112}113114interface Invalid {115  type: 'Invalid';116}117118interface Nft {119  type: 'NFT';120}121122interface Fungible {123  type: 'Fungible';124  decimalPoints: number;125}126127interface ReFungible {128  type: 'ReFungible';129}130131type CollectionMode = Nft | Fungible | ReFungible | Invalid;132133export type CreateCollectionParams = {134  mode: CollectionMode,135  name: string,136  description: string,137  tokenPrefix: string,138};139140const defaultCreateCollectionParams: CreateCollectionParams = {141  description: 'description',142  mode: { type: 'NFT' },143  name: 'name',144  tokenPrefix: 'prefix',145}146147export async function createCollectionExpectSuccess(params: Partial<CreateCollectionParams> = {}): Promise<number> {148  const {name, description, mode, tokenPrefix } = {...defaultCreateCollectionParams, ...params};149150  let collectionId: number = 0;151  await usingApi(async (api) => {152    // Get number of collections before the transaction153    const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10);154155    // Run the CreateCollection transaction156    const alicePrivateKey = privateKey('//Alice');157158    let modeprm = {};159    if (mode.type === 'NFT') {160      modeprm = {nft: null};161    } else if (mode.type === 'Fungible') {162      modeprm = {fungible: mode.decimalPoints};163    } else if (mode.type === 'ReFungible') {164      modeprm = {refungible: null};165    } else if (mode.type === 'Invalid') {166      modeprm = {invalid: null};167    }168169    const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), modeprm);170    const events = await submitTransactionAsync(alicePrivateKey, tx);171    const result = getCreateCollectionResult(events);172173    // Get number of collections after the transaction174    const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10);175176    // Get the collection177    const collection: any = (await api.query.nft.collection(result.collectionId)).toJSON();178179    // What to expect180    // tslint:disable-next-line:no-unused-expression181    expect(result.success).to.be.true;182    expect(result.collectionId).to.be.equal(BcollectionCount);183    // tslint:disable-next-line:no-unused-expression184    expect(collection).to.be.not.null;185    expect(BcollectionCount).to.be.equal(AcollectionCount + 1, 'Error: NFT collection NOT created.');186    expect(collection.Owner).to.be.equal(alicesPublicKey);187    expect(utf16ToStr(collection.Name)).to.be.equal(name);188    expect(utf16ToStr(collection.Description)).to.be.equal(description);189    expect(hexToStr(collection.TokenPrefix)).to.be.equal(tokenPrefix);190191    collectionId = result.collectionId;192  });193194  return collectionId;195}196197export async function createCollectionExpectFailure(params: Partial<CreateCollectionParams> = {}) {198  const {name, description, mode, tokenPrefix } = {...defaultCreateCollectionParams, ...params};199200  let modeprm = {};201  if (mode.type === 'NFT') {202    modeprm = {nft: null};203  } else if (mode.type === 'Fungible') {204    modeprm = {fungible: mode.decimalPoints};205  } else if (mode.type === 'ReFungible') {206    modeprm = {refungible: null};207  } else if (mode.type === 'Invalid') {208    modeprm = {invalid: null};209  }210211  await usingApi(async (api) => {212    // Get number of collections before the transaction213    const AcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());214215    // Run the CreateCollection transaction216    const alicePrivateKey = privateKey('//Alice');217    const tx = api.tx.nft.createCollection(strToUTF16(name), strToUTF16(description), strToUTF16(tokenPrefix), modeprm);218    const events = await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;219    const result = getCreateCollectionResult(events);220221    // Get number of collections after the transaction222    const BcollectionCount = parseInt((await api.query.nft.createdCollectionCount()).toString());223224    // What to expect225    // tslint:disable-next-line:no-unused-expression226    expect(result.success).to.be.false;227    expect(BcollectionCount).to.be.equal(AcollectionCount, 'Error: Collection with incorrect data created.');228  });229}230231export async function findUnusedAddress(api: ApiPromise, seedAddition = ''): Promise<IKeyringPair> {232  let bal = new BigNumber(0);233  let unused;234  do {235    const randomSeed = 'seed' +  Math.floor(Math.random() * Math.floor(10000)) + seedAddition;236    const keyring = new Keyring({ type: 'sr25519' });237    unused = keyring.addFromUri(`//${randomSeed}`);238    bal = new BigNumber((await api.query.system.account(unused.address)).data.free.toString());239  } while (bal.toFixed() != '0');240  return unused;241}242243export async function getAllowance(collectionId: number, tokenId: number, owner: string, approved: string) {244  return await usingApi(async (api) => {245    const bn = await api.query.nft.allowances(collectionId, [tokenId, owner, approved]) as unknown as BN;246    return BigInt(bn.toString());247  });248}249250export function findUnusedAddresses(api: ApiPromise, amount: number): Promise<IKeyringPair[]> {251  return Promise.all(new Array(amount).fill(null).map(() => findUnusedAddress(api, '_' + Date.now())));252}253254export async function findNotExistingCollection(api: ApiPromise): Promise<number> {255  const totalNumber = parseInt((await api.query.nft.createdCollectionCount()).toString(), 10) as unknown as number;256  const newCollection: number = totalNumber + 1;257  return newCollection;258}259260function getDestroyResult(events: EventRecord[]): boolean {261  let success: boolean = false;262  events.forEach(({ phase, event: { data, method, section } }) => {263    // console.log(`    ${phase}: ${section}.${method}:: ${data}`);264    if (method == 'ExtrinsicSuccess') {265      success = true;266    }267  });268  return success;269}270271export async function destroyCollectionExpectFailure(collectionId: number, senderSeed: string = '//Alice') {272  await usingApi(async (api) => {273    // Run the DestroyCollection transaction274    const alicePrivateKey = privateKey(senderSeed);275    const tx = api.tx.nft.destroyCollection(collectionId);276    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;277  });278}279280export async function destroyCollectionExpectSuccess(collectionId: number, senderSeed: string = '//Alice') {281  await usingApi(async (api) => {282    // Run the DestroyCollection transaction283    const alicePrivateKey = privateKey(senderSeed);284    const tx = api.tx.nft.destroyCollection(collectionId);285    const events = await submitTransactionAsync(alicePrivateKey, tx);286    const result = getDestroyResult(events);287288    // Get the collection289    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();290291    // What to expect292    expect(result).to.be.true;293    expect(collection).to.be.not.null;294    expect(collection.Owner).to.be.equal(nullPublicKey);295  });296}297298export async function setCollectionSponsorExpectSuccess(collectionId: number, sponsor: string) {299  await usingApi(async (api) => {300301    // Run the transaction302    const alicePrivateKey = privateKey('//Alice');303    const tx = api.tx.nft.setCollectionSponsor(collectionId, sponsor);304    const events = await submitTransactionAsync(alicePrivateKey, tx);305    const result = getGenericResult(events);306307    // Get the collection308    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();309310    // What to expect311    expect(result.success).to.be.true;312    expect(collection.Sponsor.toString()).to.be.equal(sponsor.toString());313    expect(collection.SponsorConfirmed).to.be.false;314  });315}316317export async function removeCollectionSponsorExpectSuccess(collectionId: number) {318  await usingApi(async (api) => {319320    // Run the transaction321    const alicePrivateKey = privateKey('//Alice');322    const tx = api.tx.nft.removeCollectionSponsor(collectionId);323    const events = await submitTransactionAsync(alicePrivateKey, tx);324    const result = getGenericResult(events);325326    // Get the collection327    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();328329    // What to expect330    expect(result.success).to.be.true;331    expect(collection.Sponsor).to.be.equal(nullPublicKey);332    expect(collection.SponsorConfirmed).to.be.false;333  });334}335336export async function removeCollectionSponsorExpectFailure(collectionId: number) {337  await usingApi(async (api) => {338339    // Run the transaction340    const alicePrivateKey = privateKey('//Alice');341    const tx = api.tx.nft.removeCollectionSponsor(collectionId);342    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;343  });344}345346export async function setCollectionSponsorExpectFailure(collectionId: number, sponsor: string, senderSeed: string = '//Alice') {347  await usingApi(async (api) => {348349    // Run the transaction350    const alicePrivateKey = privateKey(senderSeed);351    const tx = api.tx.nft.setCollectionSponsor(collectionId, sponsor);352    await expect(submitTransactionExpectFailAsync(alicePrivateKey, tx)).to.be.rejected;353  });354}355356export async function confirmSponsorshipExpectSuccess(collectionId: number, senderSeed: string = '//Alice') {357  await usingApi(async (api) => {358359    // Run the transaction360    const sender = privateKey(senderSeed);361    const tx = api.tx.nft.confirmSponsorship(collectionId);362    const events = await submitTransactionAsync(sender, tx);363    const result = getGenericResult(events);364365    // Get the collection366    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();367368    // What to expect369    expect(result.success).to.be.true;370    expect(collection.Sponsor).to.be.equal(sender.address);371    expect(collection.SponsorConfirmed).to.be.true;372  });373}374375376export async function confirmSponsorshipExpectFailure(collectionId: number, senderSeed: string = '//Alice') {377  await usingApi(async (api) => {378379    // Run the transaction380    const sender = privateKey(senderSeed);381    const tx = api.tx.nft.confirmSponsorship(collectionId);382    await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;383  });384}385386export async function enableContractSponsoringExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {387  await usingApi(async (api) => {388    const tx = api.tx.nft.enableContractSponsoring(contractAddress, enable);389    const events = await submitTransactionAsync(sender, tx);390    const result = getGenericResult(events);391392    expect(result.success).to.be.true;393  });394}395396export async function enableContractSponsoringExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, enable: boolean) {397  await usingApi(async (api) => {398    const tx = api.tx.nft.enableContractSponsoring(contractAddress, enable);399    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;400    const result = getGenericResult(events);401402    expect(result.success).to.be.false;403  });404}405406export async function setContractSponsoringRateLimitExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {407  await usingApi(async (api) => {408    const tx = api.tx.nft.setContractSponsoringRateLimit(contractAddress, rateLimit);409    const events = await submitTransactionAsync(sender, tx);410    const result = getGenericResult(events);411412    expect(result.success).to.be.true;413  });414}415416export async function setContractSponsoringRateLimitExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, rateLimit: number) {417  await usingApi(async (api) => {418    const tx = api.tx.nft.setContractSponsoringRateLimit(contractAddress, rateLimit);419    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;420    const result = getGenericResult(events);421422    expect(result.success).to.be.false;423  });424}425426export async function toggleContractWhitelistExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, enabled: boolean) {427  await usingApi(async (api) => {428    const tx = api.tx.nft.toggleContractWhiteList(contractAddress, true);429    const events = await submitTransactionAsync(sender, tx);430    const result = getGenericResult(events);431432    expect(result.success).to.be.true;433  });434}435436export async function isWhitelistedInContract(contractAddress: AccountId | string, user: string) {437  let whitelisted: boolean = false;438  await usingApi(async (api) => {439    whitelisted = (await api.query.nft.contractWhiteList(contractAddress, user)).toJSON() as boolean;440  });441  return whitelisted;442}443444export async function addToContractWhiteListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: string) {445  await usingApi(async (api) => {446    const tx = api.tx.nft.addToContractWhiteList(contractAddress, user);447    const events = await submitTransactionAsync(sender, tx);448    const result = getGenericResult(events);449450    expect(result.success).to.be.true;451  });452}453454export async function removeFromContractWhiteListExpectSuccess(sender: IKeyringPair, contractAddress: AccountId | string, user: string) {455  await usingApi(async (api) => {456    const tx = api.tx.nft.removeFromContractWhiteList(contractAddress, user);457    const events = await submitTransactionAsync(sender, tx);458    const result = getGenericResult(events);459460    expect(result.success).to.be.true;461  });462}463464export async function removeFromContractWhiteListExpectFailure(sender: IKeyringPair, contractAddress: AccountId | string, user: string) {465  await usingApi(async (api) => {466    const tx = api.tx.nft.removeFromContractWhiteList(contractAddress, user);467    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;468    const result = getGenericResult(events);469470    expect(result.success).to.be.false;471  });472}473474export async function setVariableMetaDataExpectSuccess(sender: IKeyringPair, collectionId: number, itemId: number, data: number[]) {475  await usingApi(async (api) => {476    const tx = api.tx.nft.setVariableMetaData(collectionId, itemId, '0x' + Buffer.from(data).toString('hex'));477    const events = await submitTransactionAsync(sender, tx);478    const result = getGenericResult(events);479480    expect(result.success).to.be.true;481  });482}483484export async function setVariableMetaDataExpectFailure(sender: IKeyringPair, collectionId: number, itemId: number, data: number[]) {485  await usingApi(async (api) => {486    const tx = api.tx.nft.setVariableMetaData(collectionId, itemId, '0x' + Buffer.from(data).toString('hex'));487    await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;488  });489}490491export interface CreateFungibleData {492  readonly Value: bigint;493}494495export interface CreateReFungibleData { }496export interface CreateNftData { }497498export type CreateItemData = {499  NFT: CreateNftData;500} | {501  Fungible: CreateFungibleData;502} | {503  ReFungible: CreateReFungibleData;504};505506export async function burnItemExpectSuccess(owner: IKeyringPair, collectionId: number, tokenId: number, value = 0) {507  await usingApi(async (api) => {508    const tx = api.tx.nft.burnItem(collectionId, tokenId, value);509    const events = await submitTransactionAsync(owner, tx);510    const result = getGenericResult(events);511    // Get the item512    const item: any = (await api.query.nft.nftItemList(collectionId, tokenId)).toJSON();513    // What to expect514    // tslint:disable-next-line:no-unused-expression515    expect(result.success).to.be.true;516    // tslint:disable-next-line:no-unused-expression517    expect(item).to.be.not.null;518    expect(item.Owner).to.be.equal(nullPublicKey);519  });520}521522export async function523approveExpectSuccess(collectionId: number,524                     tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number | bigint = 1) {525  await usingApi(async (api: ApiPromise) => {526    const allowanceBefore =527      await api.query.nft.allowances(collectionId, [tokenId, owner.address, approved.address]) as unknown as BN;528    const approveNftTx = await api.tx.nft.approve(approved.address, collectionId, tokenId, amount);529    const events = await submitTransactionAsync(owner, approveNftTx);530    const result = getCreateItemResult(events);531    // tslint:disable-next-line:no-unused-expression532    expect(result.success).to.be.true;533    const allowanceAfter =534      await api.query.nft.allowances(collectionId, [tokenId, owner.address, approved.address]) as unknown as BN;535    expect(allowanceAfter.sub(allowanceBefore).toString()).to.be.equal(amount.toString());536  });537}538539export async function540transferFromExpectSuccess(collectionId: number,541                          tokenId: number,542                          accountApproved: IKeyringPair,543                          accountFrom: IKeyringPair,544                          accountTo: IKeyringPair,545                          value: number | bigint = 1,546                          type: string = 'NFT') {547  await usingApi(async (api: ApiPromise) => {548    let balanceBefore = new BN(0);549    if (type === 'Fungible') {550      balanceBefore = await api.query.nft.balance(collectionId, accountTo.address) as unknown as BN;551    }552    const transferFromTx = await api.tx.nft.transferFrom(553      accountFrom.address, accountTo.address, collectionId, tokenId, value);554    const events = await submitTransactionAsync(accountApproved, transferFromTx);555    const result = getCreateItemResult(events);556    // tslint:disable-next-line:no-unused-expression557    expect(result.success).to.be.true;558    if (type === 'NFT') {559      const nftItemData = await api.query.nft.nftItemList(collectionId, tokenId) as unknown as ITokenDataType;560      expect(nftItemData.Owner.toString()).to.be.equal(accountTo.address);561    }562    if (type === 'Fungible') {563      const balanceAfter = await api.query.nft.balance(collectionId, accountTo.address) as unknown as BN;564      expect(balanceAfter.sub(balanceBefore).toString()).to.be.equal(value.toString());565    }566    if (type === 'ReFungible') {567      const nftItemData =568        await api.query.nft.reFungibleItemList(collectionId, tokenId) as unknown as IReFungibleTokenDataType;569      expect(nftItemData.Owner[0].Owner.toString()).to.be.equal(accountTo.address);570      expect(nftItemData.Owner[0].Fraction.toNumber()).to.be.equal(value);571    }572  });573}574575export async function576transferFromExpectFail(collectionId: number,577                       tokenId: number,578                       accountApproved: IKeyringPair,579                       accountFrom: IKeyringPair,580                       accountTo: IKeyringPair,581                       value: number | bigint = 1) {582  await usingApi(async (api: ApiPromise) => {583    const transferFromTx = await api.tx.nft.transferFrom(584      accountFrom.address, accountTo.address, collectionId, tokenId, value);585    const events = await expect(submitTransactionExpectFailAsync(accountApproved, transferFromTx)).to.be.rejected;586    const result = getCreateCollectionResult(events);587    // tslint:disable-next-line:no-unused-expression588    expect(result.success).to.be.false;589  });590}591592export async function593transferExpectSuccess(collectionId: number,594                      tokenId: number,595                      sender: IKeyringPair,596                      recipient: IKeyringPair,597                      value: number | bigint = 1,598                      type: string = 'NFT') {599  await usingApi(async (api: ApiPromise) => {600    let balanceBefore = new BN(0);601    if (type === 'Fungible') {602      balanceBefore = await api.query.nft.balance(collectionId, recipient.address) as unknown as BN;603    }604    const transferTx = await api.tx.nft.transfer(recipient.address, collectionId, tokenId, value);605    const events = await submitTransactionAsync(sender, transferTx);606    const result = getCreateItemResult(events);607    // tslint:disable-next-line:no-unused-expression608    expect(result.success).to.be.true;609    if (type === 'NFT') {610      const nftItemData = await api.query.nft.nftItemList(collectionId, tokenId) as unknown as ITokenDataType;611      expect(nftItemData.Owner.toString()).to.be.equal(recipient.address);612    }613    if (type === 'Fungible') {614      const balanceAfter = await api.query.nft.balance(collectionId, recipient.address) as unknown as BN;615      expect(balanceAfter.sub(balanceBefore).toString()).to.be.equal(value.toString());616    }617    if (type === 'ReFungible') {618      const nftItemData =619        await api.query.nft.reFungibleItemList(collectionId, tokenId) as unknown as IReFungibleTokenDataType;620      expect(nftItemData.Owner[0].Owner.toString()).to.be.equal(recipient.address);621      expect(nftItemData.Owner[0].Fraction.toNumber()).to.be.equal(value);622    }623  });624}625626export async function627transferExpectFail(collectionId: number,628                   tokenId: number,629                   sender: IKeyringPair,630                   recipient: IKeyringPair,631                   value: number | bigint = 1,632                   type: string = 'NFT') {633  await usingApi(async (api: ApiPromise) => {634    const transferTx = await api.tx.nft.transfer(recipient.address, collectionId, tokenId, value);635    const events = await expect(submitTransactionExpectFailAsync(sender, transferTx)).to.be.rejected;636    if (events && Array.isArray(events)) {637      const result = getCreateCollectionResult(events);638      // tslint:disable-next-line:no-unused-expression639      expect(result.success).to.be.false;640    }641  });642}643644export async function645approveExpectFail(collectionId: number,646                  tokenId: number, owner: IKeyringPair, approved: IKeyringPair, amount: number | bigint = 1) {647  await usingApi(async (api: ApiPromise) => {648    const approveNftTx = await api.tx.nft.approve(approved.address, collectionId, tokenId, amount);649    const events = await expect(submitTransactionExpectFailAsync(owner, approveNftTx)).to.be.rejected;650    const result = getCreateCollectionResult(events);651    // tslint:disable-next-line:no-unused-expression652    expect(result.success).to.be.false;653  });654}655656export async function getFungibleBalance(657  collectionId: number,658  owner: string,659) {660  return await usingApi(async (api) => {661    const response = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON() as unknown as {Value: string};662    return BigInt(response.Value);663  });664}665666export async function createFungibleItemExpectSuccess(667  sender: IKeyringPair,668  collectionId: number,669  data: CreateFungibleData,670  owner: string = sender.address,671) {672  return await usingApi(async (api) => {673    const tx = api.tx.nft.createItem(collectionId, owner, { Fungible: data });674675    const events = await submitTransactionAsync(sender, tx);676    const result = getCreateItemResult(events);677678    expect(result.success).to.be.true;679    return result.itemId;680  });681}682683export async function createItemExpectSuccess(684  sender: IKeyringPair, collectionId: number, createMode: string, owner: string = '') {685  let newItemId: number = 0;686  await usingApi(async (api) => {687    const AItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);688    const Aitem: any = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON();689    const AItemBalance = new BigNumber(Aitem.Value);690691    if (owner === '') {692      owner = sender.address;693    }694695    let tx;696    if (createMode === 'Fungible') {697      const createData = {fungible: {value: 10}};698      tx = api.tx.nft.createItem(collectionId, owner, createData);699    } else if (createMode === 'ReFungible') {700      const createData = {refungible: {const_data: [], variable_data: [], pieces: 100}};701      tx = api.tx.nft.createItem(collectionId, owner, createData);702    } else {703      tx = api.tx.nft.createItem(collectionId, owner, createMode);704    }705    const events = await submitTransactionAsync(sender, tx);706    const result = getCreateItemResult(events);707708    const BItemCount = parseInt((await api.query.nft.itemListIndex(collectionId)).toString(), 10);709    const Bitem: any = (await api.query.nft.fungibleItemList(collectionId, owner)).toJSON();710    const BItemBalance = new BigNumber(Bitem.Value);711712    // What to expect713    // tslint:disable-next-line:no-unused-expression714    expect(result.success).to.be.true;715    if (createMode === 'Fungible') {716      expect(BItemBalance.minus(AItemBalance).toNumber()).to.be.equal(10);717    } else {718      expect(BItemCount).to.be.equal(AItemCount + 1);719    }720    expect(collectionId).to.be.equal(result.collectionId);721    expect(BItemCount).to.be.equal(result.itemId);722    newItemId = result.itemId;723  });724  return newItemId;725}726727export async function createItemExpectFailure(728  sender: IKeyringPair, collectionId: number, createMode: string, owner: string = sender.address) {729  await usingApi(async (api) => {730    const tx = api.tx.nft.createItem(collectionId, owner, createMode);731    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;732    const result = getCreateItemResult(events);733734    expect(result.success).to.be.false;735  });736}737738export async function setPublicAccessModeExpectSuccess(739  sender: IKeyringPair, collectionId: number,740  accessMode: 'Normal' | 'WhiteList',741) {742  await usingApi(async (api) => {743744    // Run the transaction745    const tx = api.tx.nft.setPublicAccessMode(collectionId, accessMode);746    const events = await submitTransactionAsync(sender, tx);747    const result = getGenericResult(events);748749    // Get the collection750    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();751752    // What to expect753    // tslint:disable-next-line:no-unused-expression754    expect(result.success).to.be.true;755    expect(collection.Access).to.be.equal(accessMode);756  });757}758759export async function enableWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number) {760  await setPublicAccessModeExpectSuccess(sender, collectionId, 'WhiteList');761}762763export async function disableWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number) {764  await setPublicAccessModeExpectSuccess(sender, collectionId, 'Normal');765}766767export async function setMintPermissionExpectSuccess(sender: IKeyringPair, collectionId: number, enabled: boolean) {768  await usingApi(async (api) => {769770    // Run the transaction771    const tx = api.tx.nft.setMintPermission(collectionId, enabled);772    const events = await submitTransactionAsync(sender, tx);773    const result = getGenericResult(events);774775    // Get the collection776    const collection: any = (await api.query.nft.collection(collectionId)).toJSON();777778    // What to expect779    // tslint:disable-next-line:no-unused-expression780    expect(result.success).to.be.true;781    expect(collection.MintMode).to.be.equal(enabled);782  });783}784785export async function enablePublicMintingExpectSuccess(sender: IKeyringPair, collectionId: number) {786  await setMintPermissionExpectSuccess(sender, collectionId, true);787}788789export async function setMintPermissionExpectFailure(sender: IKeyringPair, collectionId: number, enabled: boolean) {790  await usingApi(async (api) => {791    // Run the transaction792    const tx = api.tx.nft.setMintPermission(collectionId, enabled);793    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;794    const result = getCreateCollectionResult(events);795    // tslint:disable-next-line:no-unused-expression796    expect(result.success).to.be.false;797  });798}799800export async function isWhitelisted(collectionId: number, address: string) {801  let whitelisted: boolean = false;802  await usingApi(async (api) => {803    whitelisted = (await api.query.nft.whiteList(collectionId, address)).toJSON() as unknown as boolean;804  });805  return whitelisted;806}807808export async function addToWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number, address: string) {809  await usingApi(async (api) => {810811    const whiteListedBefore = (await api.query.nft.whiteList(collectionId, address)).toJSON();812813    // Run the transaction814    const tx = api.tx.nft.addToWhiteList(collectionId, address);815    const events = await submitTransactionAsync(sender, tx);816    const result = getGenericResult(events);817818    const whiteListedAfter = (await api.query.nft.whiteList(collectionId, address)).toJSON();819820    // What to expect821    // tslint:disable-next-line:no-unused-expression822    expect(result.success).to.be.true;823    // tslint:disable-next-line: no-unused-expression824    expect(whiteListedBefore).to.be.false;825    // tslint:disable-next-line: no-unused-expression826    expect(whiteListedAfter).to.be.true;827  });828}829830export async function removeFromWhiteListExpectSuccess(sender: IKeyringPair, collectionId: number, address: string) {831  await usingApi(async (api) => {832    // Run the transaction833    const tx = api.tx.nft.removeFromWhiteList(collectionId, address);834    const events = await submitTransactionAsync(sender, tx);835    const result = getGenericResult(events);836837    // What to expect838    // tslint:disable-next-line:no-unused-expression839    expect(result.success).to.be.true;840  });841}842843export async function removeFromWhiteListExpectFailure(sender: IKeyringPair, collectionId: number, address: string) {844  await usingApi(async (api) => {845    // Run the transaction846    const tx = api.tx.nft.removeFromWhiteList(collectionId, address);847    const events = await expect(submitTransactionExpectFailAsync(sender, tx)).to.be.rejected;848    const result = getGenericResult(events);849850    // What to expect851    // tslint:disable-next-line:no-unused-expression852    expect(result.success).to.be.false;853  });854}855856export const getDetailedCollectionInfo = async (api: ApiPromise, collectionId: number)857  : Promise<ICollectionInterface | null> => {858  return await api.query.nft.collection(collectionId) as unknown as ICollectionInterface;859};860861export const getCreatedCollectionCount = async (api: ApiPromise): Promise<number> => {862  // set global object - collectionsCount863  return (await api.query.nft.createdCollectionCount() as unknown as BN).toNumber();864};
modifiedtests/yarn.lockdiffbeforeafterboth
--- a/tests/yarn.lock
+++ b/tests/yarn.lock
@@ -4710,7 +4710,7 @@
   dependencies:
     ci-info "^2.0.0"
 
-is-core-module@^2.1.0:
+is-core-module@^2.2.0:
   version "2.2.0"
   resolved "https://registry.yarnpkg.com/is-core-module/-/is-core-module-2.2.0.tgz#97037ef3d52224d85163f5597b2b63d9afed981a"
   integrity sha512-XRAfAdyyY5F5cOXn7hYQDqh2Xmii+DEfIcQGxK/uNwMHhIkPWO0g8msXcbzLe+MpGoR951MlqM/2iIlU4vKDdQ==
@@ -7110,11 +7110,11 @@
   integrity sha1-LGN/53yJOv0qZj/iGqkIAGjiBSo=
 
 resolve@^1.1.6, resolve@^1.10.0, resolve@^1.10.1, resolve@^1.13.1, resolve@^1.17.0, resolve@^1.18.1, resolve@^1.19.0, resolve@^1.3.2:
-  version "1.19.0"
-  resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.19.0.tgz#1af5bf630409734a067cae29318aac7fa29a267c"
-  integrity sha512-rArEXAgsBG4UgRGcynxWIWKFvh/XZCcS8UJdHhwy91zwAvCZIbcs+vAbflgBnNjYMs/i/i+/Ux6IZhML1yPvxg==
+  version "1.20.0"
+  resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.20.0.tgz#629a013fb3f70755d6f0b7935cc1c2c5378b1975"
+  integrity sha512-wENBPt4ySzg4ybFQW2TT1zMQucPK95HSh/nq2CFTZVOGut2+pQvSsgtda4d26YrYcr067wjbmzOG8byDPBX63A==
   dependencies:
-    is-core-module "^2.1.0"
+    is-core-module "^2.2.0"
     path-parse "^1.0.6"
 
 responselike@^1.0.2: