git.delta.rocks / unique-network / refs/commits / 4e55e3985dac

--- a/tests/package.json
+++ b/tests/package.json
@@ -64,6 +64,7 @@
     "testTransfer": "mocha --timeout 9999999 -r ts-node/register ./**/transfer.test.ts",
     "testBurnItem": "mocha --timeout 9999999 -r ts-node/register ./**/burnItem.test.ts",
     "testAdminTransferAndBurn": "mocha --timeout 9999999 -r ts-node/register ./**/adminTransferAndBurn.test.ts",
+    "testMintModes": "mocha --timeout 9999999 -r ts-node/register ./**/mintModes.test.ts",
     "testSetMintPermission": "mocha --timeout 9999999 -r ts-node/register ./**/setMintPermission.test.ts",
     "testSetPublicAccessMode": "mocha --timeout 9999999 -r ts-node/register ./**/setPublicAccessMode.test.ts",
     "testCreditFeesToTreasury": "mocha --timeout 9999999 -r ts-node/register ./**/creditFeesToTreasury.test.ts",

--- a/tests/src/fungible.test.ts
+++ b/tests/src/fungible.test.ts
@@ -15,18 +15,18 @@
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
 import {IKeyringPair} from '@polkadot/types/types';
-import {U128_MAX} from './util/helpers';
 import {itSub, usingPlaygrounds, expect} from './util/playgrounds';
 
-// todo:playgrounds get rid of globals
-let alice: IKeyringPair;
-let bob: IKeyringPair;
+const U128_MAX = (1n << 128n) - 1n;
 
 describe('integration test: Fungible functionality:', () => {
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+
   before(async () => {
     await usingPlaygrounds(async (helper, privateKey) => {
-      alice = privateKey('//Alice');
-      bob = privateKey('//Bob');
+      const donor = privateKey('//Alice');
+      [alice, bob] = await helper.arrange.createAccounts([100n, 10n], donor);
     });
   });
 
@@ -82,7 +82,7 @@
     expect(await collection.getBalance({Substrate: bob.address})).to.be.equal(60n);
     expect(await collection.getBalance(ethAcc)).to.be.equal(140n);
 
-    await expect(collection.transfer(alice, {Substrate: bob.address}, 350n)).to.eventually.be.rejected;
+    await expect(collection.transfer(alice, {Substrate: bob.address}, 350n)).to.eventually.be.rejectedWith(/common\.TokenValueTooLow/);
   });
 
   itSub('Tokens multiple creation', async ({helper}) => {

--- a/tests/src/inflation.test.ts
+++ b/tests/src/inflation.test.ts
@@ -14,42 +14,45 @@
 // You should have received a copy of the GNU General Public License
 // along with Unique Network. If not, see <http://www.gnu.org/licenses/>.
 
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
-import {default as usingApi, submitTransactionAsync, submitTransactionExpectFailAsync} from './substrate/substrate-api';
-
-chai.use(chaiAsPromised);
-const expect = chai.expect;
+import {IKeyringPair} from '@polkadot/types/types';
+import {expect, itSub, usingPlaygrounds} from './util/playgrounds';
 
+// todo:playgrounds requires sudo, look into on the later stage
 describe('integration test: Inflation', () => {
-  it('First year inflation is 10%', async () => {
-    await usingApi(async (api, privateKeyWrapper) => {
+  let superuser: IKeyringPair;
 
-      // Make sure non-sudo can't start inflation
-      const tx = api.tx.inflation.startInflation(1);
-      const bob = privateKeyWrapper('//Bob');
-      await expect(submitTransactionExpectFailAsync(bob, tx)).to.be.rejected;
+  before(async () => {
+    await usingPlaygrounds(async (_, privateKey) => {
+      superuser = privateKey('//Alice');
+    });
+  });
+  
+  itSub('First year inflation is 10%', async ({helper}) => {
+    // Make sure non-sudo can't start inflation
+    const [bob] = await helper.arrange.createAccounts([10n], superuser);
 
-      // Start inflation on relay block 1 (Alice is sudo)
-      const alice = privateKeyWrapper('//Alice');
-      const sudoTx = api.tx.sudo.sudo(tx as any);
-      await submitTransactionAsync(alice, sudoTx);
+    await expect(helper.executeExtrinsic(bob, 'api.tx.inflation.startInflation', [1])).to.be.rejectedWith(/BadOrigin/);
 
-      const blockInterval = (api.consts.inflation.inflationBlockInterval).toBigInt();
-      const totalIssuanceStart = (await api.query.inflation.startingYearTotalIssuance()).toBigInt();
-      const blockInflation = (await api.query.inflation.blockInflation()).toBigInt();
+    // Make sure superuser can't start inflation without explicit sudo
+    await expect(helper.executeExtrinsic(superuser, 'api.tx.inflation.startInflation', [1])).to.be.rejectedWith(/BadOrigin/);
 
-      const YEAR = 5259600n;  // 6-second block. Blocks in one year
-      // const YEAR = 2629800n; // 12-second block. Blocks in one year
+    // Start inflation on relay block 1 (Alice is sudo)
+    const tx = helper.constructApiCall('api.tx.inflation.startInflation', [1]);
+    await expect(helper.executeExtrinsic(superuser, 'api.tx.sudo.sudo', [tx])).to.not.be.rejected;
 
-      const totalExpectedInflation = totalIssuanceStart / 10n;
-      const totalActualInflation = blockInflation * YEAR / blockInterval;
+    const blockInterval = (helper.api!.consts.inflation.inflationBlockInterval as any).toBigInt();
+    const totalIssuanceStart = ((await helper.api!.query.inflation.startingYearTotalIssuance()) as any).toBigInt();
+    const blockInflation = (await helper.api!.query.inflation.blockInflation() as any).toBigInt();
 
-      const tolerance = 0.00001; // Relative difference per year between theoretical and actual inflation
-      const expectedInflation = totalExpectedInflation / totalActualInflation - 1n;
+    const YEAR = 5259600n;  // 6-second block. Blocks in one year
+    // const YEAR = 2629800n; // 12-second block. Blocks in one year
+
+    const totalExpectedInflation = totalIssuanceStart / 10n;
+    const totalActualInflation = blockInflation * YEAR / blockInterval;
+
+    const tolerance = 0.00001; // Relative difference per year between theoretical and actual inflation
+    const expectedInflation = totalExpectedInflation / totalActualInflation - 1n;
 
-      expect(Math.abs(Number(expectedInflation))).to.be.lessThanOrEqual(tolerance);
-    });
+    expect(Math.abs(Number(expectedInflation))).to.be.lessThanOrEqual(tolerance);
   });
-
 });

--- a/tests/src/refungible.test.ts
+++ b/tests/src/refungible.test.ts
@@ -17,17 +17,18 @@
 import {IKeyringPair} from '@polkadot/types/types';
 import {itSub, Pallets, requirePalletsOrSkip, usingPlaygrounds, expect} from './util/playgrounds';
 
-let alice: IKeyringPair;
-let bob: IKeyringPair;
 const MAX_REFUNGIBLE_PIECES = 1_000_000_000_000_000_000_000n;
 
 describe('integration test: Refungible functionality:', async () => {
+  let alice: IKeyringPair;
+  let bob: IKeyringPair;
+
   before(async function() {
     await usingPlaygrounds(async (helper, privateKey) => {
       requirePalletsOrSkip(this, helper, [Pallets.ReFungible]);
 
-      alice = privateKey('//Alice');
-      bob = privateKey('//Bob');
+      const donor = privateKey('//Alice');
+      [alice, bob] = await helper.arrange.createAccounts([100n, 10n], donor);
     });
   });
   
@@ -209,36 +210,38 @@
     const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
     const token = await collection.mintToken(alice, 100n);
     await token.repartition(alice, 200n);
-    const chainEvents = helper.chainLog.slice(-1)[0].events.map((x: any) => x.event);
-    expect(chainEvents).to.include.deep.members([{
-      method: 'ItemCreated',
+    const chainEvents = helper.chainLog.slice(-1)[0].events;
+    expect(chainEvents).to.deep.include({
       section: 'common',
-      index: '0x4202',
-      data: [ 
-        helper.api!.createType('u32', collection.collectionId).toHuman(), 
-        helper.api!.createType('u32', token.tokenId).toHuman(),
-        {Substrate: alice.address}, 
-        '100',
+      method: 'ItemCreated',
+      index: [66, 2],
+      data: [
+        collection.collectionId,
+        token.tokenId,
+        {substrate: alice.address}, 
+        100n,
       ],
-    }]);
+      phase: {applyExtrinsic: 2},
+    });
   });
 
   itSub('Repartition with decreased amount', async ({helper}) => {
     const collection = await helper.rft.mintCollection(alice, {name: 'test', description: 'test', tokenPrefix: 'test'});
     const token = await collection.mintToken(alice, 100n);
     await token.repartition(alice, 50n);
-    const chainEvents = helper.chainLog.slice(-1)[0].events.map((x: any) => x.event);
-    expect(chainEvents).to.include.deep.members([{
+    const chainEvents = helper.chainLog.slice(-1)[0].events;
+    expect(chainEvents).to.deep.include({
       method: 'ItemDestroyed',
       section: 'common',
-      index: '0x4203',
-      data: [ 
-        helper.api!.createType('u32', collection.collectionId).toHuman(), 
-        helper.api!.createType('u32', token.tokenId).toHuman(),
-        {Substrate: alice.address}, 
-        '50',
+      index: [66, 3],
+      data: [
+        collection.collectionId,
+        token.tokenId,
+        {substrate: alice.address}, 
+        50n,
       ],
-    }]);
+      phase: {applyExtrinsic: 2},
+    });
   });
   
   itSub('Create new collection with properties', async ({helper}) => {

no syntactic changes

--- a/tests/src/util/playgrounds/types.ts
+++ b/tests/src/util/playgrounds/types.ts
@@ -3,20 +3,31 @@
 
 import {IKeyringPair} from '@polkadot/types/types';
 
-export interface IChainEvent {
-  data: any;
+export interface IEvent {
+  section: string;
   method: string;
-  section: string;
+  index: [number, number] | string;
+  data: any[];
+  phase: {applyExtrinsic: number} | 'Initialization',
 }
 
 export interface ITransactionResult {
-    status: 'Fail' | 'Success';
-    result: {
-        events: {
-          event: IChainEvent
-        }[];
-    },
-    moduleError?: string;
+  status: 'Fail' | 'Success';
+  result: {
+      events: {
+        phase: any, // {ApplyExtrinsic: number} | 'Initialization',
+        event: IEvent;
+        // topics: any[];
+      }[];
+  },
+  moduleError?: string;
+}
+
+export interface ISubscribeBlockEventsData {
+  number: number;
+  hash: string;
+  timestamp: number; 
+  events: IEvent[];
 }
 
 export interface ILogger {

--- a/tests/src/util/playgrounds/unique.ts
+++ b/tests/src/util/playgrounds/unique.ts
@@ -9,7 +9,7 @@
 import {ApiInterfaceEvents} from '@polkadot/api/types';
 import {encodeAddress, decodeAddress, keccakAsHex, evmToAddress, addressToEvm} from '@polkadot/util-crypto';
 import {IKeyringPair} from '@polkadot/types/types';
-import {IApiListeners, IBlock, IChainEvent, IChainProperties, ICollectionCreationOptions, ICollectionLimits, ICollectionPermissions, ICrossAccountId, ICrossAccountIdLower, ILogger, INestingPermissions, IProperty, IStakingInfo, ISubstrateBalance, IToken, ITokenPropertyPermission, ITransactionResult, IUniqueHelperLog, TApiAllowedListeners, TEthereumAccount, TSigner, TSubstrateAccount, TUniqueNetworks} from './types';
+import {IApiListeners, IBlock, IEvent, IChainProperties, ICollectionCreationOptions, ICollectionLimits, ICollectionPermissions, ICrossAccountId, ICrossAccountIdLower, ILogger, INestingPermissions, IProperty, IStakingInfo, ISubstrateBalance, IToken, ITokenPropertyPermission, ITransactionResult, IUniqueHelperLog, TApiAllowedListeners, TEthereumAccount, TSigner, TSubstrateAccount, TUniqueNetworks} from './types';
 
 export const crossAccountIdFromLower = (lowerAddress: ICrossAccountIdLower): ICrossAccountId => {
   const address = {} as ICrossAccountId;
@@ -149,7 +149,7 @@
     return {success, tokens};
   }
 
-  static findCollectionInEvents(events: {event: IChainEvent}[], collectionId: number, expectedSection: string, expectedMethod: string) {
+  static findCollectionInEvents(events: {event: IEvent}[], collectionId: number, expectedSection: string, expectedMethod: string) {
     let eventId = null;
     events.forEach(({event: {data, method, section}}) => {
       if ((section === expectedSection) && (method === expectedMethod)) {
@@ -163,7 +163,7 @@
     return eventId === collectionId;
   }
 
-  static isTokenTransferSuccess(events: {event: IChainEvent}[], collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {
+  static isTokenTransferSuccess(events: {event: IEvent}[], collectionId: number, tokenId: number, fromAddressObj: ICrossAccountId, toAddressObj: ICrossAccountId, amount=1n) {
     const normalizeAddress = (address: string | ICrossAccountId) => {
       if(typeof address === 'string') return address;
       const obj = {} as any;
@@ -195,11 +195,64 @@
   }
 }
 
+class UniqueEventHelper {
+  private static extractIndex(index: any): [number, number] | string {
+    if(index.toRawType() === '[u8;2]') return [index[0], index[1]];
+    return index.toJSON();
+  }
+
+  private static extractSub(data: any, subTypes: any): {[key: string]: any} {
+    let obj: any = {};
+    let index = 0;
+
+    if (data.entries)
+      for(const [key, value] of data.entries()) {
+        obj[key] = this.extractData(value, subTypes[index]);
+        index++;
+      }
+    else obj = data.toJSON();
+
+    return obj;
+  }
+  
+  private static extractData(data: any, type: any): any {
+    if (['u16', 'u32'].indexOf(type.type) > -1) return data.toNumber();
+    if (['u64', 'u128', 'u256'].indexOf(type.type) > -1) return data.toBigInt();
+    if(type.hasOwnProperty('sub')) return this.extractSub(data, type.sub);
+    return data.toHuman();
+  }
+
+  public static extractEvents(records: ITransactionResult): IEvent[] {
+    const parsedEvents: IEvent[] = [];
+
+    records.result.events.forEach((record) => {
+      const {event, phase} = record;
+      const types = (event as any).typeDef;
 
+      const eventData: IEvent = {
+        section: event.section.toString(),
+        method: event.method.toString(),
+        index: this.extractIndex(event.index),
+        data: [],
+        phase: phase.toJSON(),
+      };
+
+      event.data.forEach((val: any, index: number) => {
+        eventData.data.push(this.extractData(val, types[index]));
+      });
+
+      parsedEvents.push(eventData);
+    });
+
+    return parsedEvents;
+  }
+}
+
 class ChainHelperBase {
   transactionStatus = UniqueUtil.transactionStatus;
   chainLogType = UniqueUtil.chainLogType;
   util: typeof UniqueUtil;
+  eventHelper: typeof UniqueEventHelper;
   logger: ILogger;
   api: ApiPromise | null;
   forcedNetwork: TUniqueNetworks | null;
@@ -208,6 +261,7 @@
 
   constructor(logger?: ILogger) {
     this.util = UniqueUtil;
+    this.eventHelper = UniqueEventHelper;
     if (typeof logger == 'undefined') logger = this.util.getDefaultLogger();
     this.logger = logger;
     this.api = null;
@@ -290,7 +344,7 @@
     return {api, network};
   }
 
-  getTransactionStatus(data: {events: {event: IChainEvent}[], status: any}) {
+  getTransactionStatus(data: {events: {event: IEvent}[], status: any}) {
     const {events, status} = data;
     if (status.isReady) {
       return this.transactionStatus.NOT_READY;
@@ -299,11 +353,11 @@
       return this.transactionStatus.NOT_READY;
     }
     if (status.isInBlock || status.isFinalized) {
-      const errors = events.filter(e => e.event.data.method === 'ExtrinsicFailed');
+      const errors = events.filter(e => e.event.method === 'ExtrinsicFailed');
       if (errors.length > 0) {
         return this.transactionStatus.FAIL;
       }
-      if (events.filter(e => e.event.data.method === 'ExtrinsicSuccess').length > 0) {
+      if (events.filter(e => e.event.method === 'ExtrinsicSuccess').length > 0) {
         return this.transactionStatus.SUCCESS;
       }
     }
@@ -332,13 +386,16 @@
             if (result.hasOwnProperty('dispatchError')) {
               const dispatchError = result['dispatchError'];
 
-              if (dispatchError && dispatchError.isModule) {
-                const modErr = dispatchError.asModule;
-                const errorMeta = dispatchError.registry.findMetaError(modErr);
+              if (dispatchError) {
+                if (dispatchError.isModule) {
+                  const modErr = dispatchError.asModule;
+                  const errorMeta = dispatchError.registry.findMetaError(modErr);
 
-                moduleError = `${errorMeta.section}.${errorMeta.name}`;
-              }
-              else {
+                  moduleError = `${errorMeta.section}.${errorMeta.name}`;
+                } else {
+                  moduleError = dispatchError.toHuman();
+                }
+              } else {
                 this.logger.log(result, this.logger.level.ERROR);
               }
             }
@@ -364,16 +421,16 @@
     return call(...params);
   }
 
-  async executeExtrinsic(sender: TSigner, extrinsic: string, params: any[], expectSuccess=false/*, failureMessage='expected success'*/) {
+  async executeExtrinsic(sender: TSigner, extrinsic: string, params: any[], expectSuccess=true/*, failureMessage='expected success'*/) {
     if(this.api === null) throw Error('API not initialized');
     if(!extrinsic.startsWith('api.tx.')) throw Error(`${extrinsic} is not transaction`);
 
     const startTime = (new Date()).getTime();
     let result: ITransactionResult;
-    let events = [];
+    let events: IEvent[] = [];
     try {
       result = await this.signTransaction(sender, this.constructApiCall(extrinsic, params), extrinsic) as ITransactionResult;
-      events = result.result.events.map((x: any) => x.toHuman());
+      events = this.eventHelper.extractEvents(result);
     }
     catch(e) {
       if(!(e as object).hasOwnProperty('status')) throw e;