@acala-network/chopsticks-testing 0.9.1-2 → 0.9.1-4

package/dist/cjs/index.js

@@ -1,27 +1,71 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createConfig: function() {
+        return createConfig;
+    },
+    defer: function() {
+        return defer;
+    },
+    expectHex: function() {
+        return expectHex;
+    },
+    expectJson: function() {
+        return expectJson;
+    },
+    matchEvents: function() {
+        return matchEvents;
+    },
+    matchSystemEvents: function() {
+        return matchSystemEvents;
+    },
+    redact: function() {
+        return redact;
+    },
+    sendTransaction: function() {
+        return sendTransaction;
+    },
+    setupContext: function() {
+        return setupContext;
+    },
+    setupContextWithConfig: function() {
+        return setupContextWithConfig;
+    },
+    setupNetworks: function() {
+        return setupNetworks;
+    },
+    testingPairs: function() {
+        return testingPairs;
     }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.testingPairs = exports.sendTransaction = exports.defer = exports.redact = exports.matchSystemEvents = exports.matchEvents = exports.expectHex = exports.expectJson = exports.setupNetworks = exports.setupContextWithConfig = exports.setupContext = exports.createConfig = void 0;
-const api_1 = require("@polkadot/api");
-const chopsticks_1 = require("@acala-network/chopsticks");
-const keyring_1 = require("@polkadot/keyring");
-const vitest_1 = require("vitest");
-__exportStar(require("./check"), exports);
-__exportStar(require("./signFake"), exports);
-const createConfig = ({ endpoint, blockNumber, blockHash, wasmOverride, db, timeout, port, maxMemoryBlockCount, resume, }) => {
+});
+const _api = require("@polkadot/api");
+const _chopsticks = require("@acala-network/chopsticks");
+const _keyring = require("@polkadot/keyring");
+const _vitest = require("vitest");
+_export_star(require("./check.js"), exports);
+_export_star(require("./signFake.js"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+const createConfig = ({ endpoint, blockNumber, blockHash, wasmOverride, db, timeout, port, maxMemoryBlockCount, resume })=>{
     // random port if not specified
     port = port ?? Math.floor(Math.random() * 10000) + 10000;
     const config = {
@@ -29,32 +73,30 @@ const createConfig = ({ endpoint, blockNumber, blockHash, wasmOverride, db, time
         port,
         block: blockNumber || blockHash,
         'mock-signature-host': true,
-        'build-block-mode': chopsticks_1.BuildBlockMode.Manual,
+        'build-block-mode': _chopsticks.BuildBlockMode.Manual,
         'max-memory-block-count': maxMemoryBlockCount ?? 100,
         db,
         'wasm-override': wasmOverride,
         timeout,
-        resume: resume ?? false,
+        resume: resume ?? false
     };
     return config;
 };
-exports.createConfig = createConfig;
-const setupContext = async (option) => {
-    return (0, exports.setupContextWithConfig)((0, exports.createConfig)(option));
+const setupContext = async (option)=>{
+    return setupContextWithConfig(createConfig(option));
 };
-exports.setupContext = setupContext;
-const setupContextWithConfig = async ({ timeout, ...config }) => {
-    const { chain, listenPort, close } = await (0, chopsticks_1.setupWithServer)(config);
+const setupContextWithConfig = async ({ timeout, ...config })=>{
+    const { chain, listenPort, close } = await (0, _chopsticks.setupWithServer)(config);
     const url = `ws://localhost:${listenPort}`;
-    const ws = new api_1.WsProvider(url, undefined, undefined, timeout);
-    const api = await api_1.ApiPromise.create({
+    const ws = new _api.WsProvider(url, undefined, undefined, timeout);
+    const api = await _api.ApiPromise.create({
         provider: ws,
         signedExtensions: {
             SetEvmOrigin: {
                 extrinsic: {},
-                payload: {},
-            },
-        },
+                payload: {}
+            }
+        }
     });
     await api.isReady;
     return {
@@ -63,82 +105,95 @@ const setupContextWithConfig = async ({ timeout, ...config }) => {
         ws,
         api,
         dev: {
-            newBlock: (param) => {
-                return ws.send('dev_newBlock', [param]);
+            newBlock: (param)=>{
+                return ws.send('dev_newBlock', [
+                    param
+                ]);
             },
-            setStorage: (values, blockHash) => {
-                return ws.send('dev_setStorage', [values, blockHash]);
+            setStorage: (values, blockHash)=>{
+                return ws.send('dev_setStorage', [
+                    values,
+                    blockHash
+                ]);
             },
-            timeTravel: (date) => {
-                return ws.send('dev_timeTravel', [date]);
-            },
-            setHead: (hashOrNumber) => {
-                return ws.send('dev_setHead', [hashOrNumber]);
+            timeTravel: (date)=>{
+                return ws.send('dev_timeTravel', [
+                    date
+                ]);
             },
+            setHead: (hashOrNumber)=>{
+                return ws.send('dev_setHead', [
+                    hashOrNumber
+                ]);
+            }
         },
-        async teardown() {
+        async teardown () {
             await api.disconnect();
             await close();
         },
-        async pause() {
-            await ws.send('dev_setBlockBuildMode', [chopsticks_1.BuildBlockMode.Instant]);
+        async pause () {
+            await ws.send('dev_setBlockBuildMode', [
+                _chopsticks.BuildBlockMode.Instant
+            ]);
             // log a bit later to ensure the message is visible
-            setTimeout(() => console.log(`Test paused. Polkadot.js apps URL: https://polkadot.js.org/apps/?rpc=${url}`), 100);
-            return new Promise((_resolve) => { }); // wait forever
-        },
+            setTimeout(()=>console.log(`Test paused. Polkadot.js apps URL: https://polkadot.js.org/apps/?rpc=${url}`), 100);
+            return new Promise((_resolve)=>{}) // wait forever
+            ;
+        }
     };
 };
-exports.setupContextWithConfig = setupContextWithConfig;
-const setupNetworks = async (networkOptions) => {
+const setupNetworks = async (networkOptions)=>{
     const ret = {};
     let wasmOverriden = false;
-    for (const [name, options] of Object.entries(networkOptions)) {
-        const config = typeof options === 'string' ? await (0, chopsticks_1.fetchConfig)(options) : options ?? (await (0, chopsticks_1.fetchConfig)(name));
-        ret[name] = await (0, exports.setupContextWithConfig)(config);
+    for (const [name, options] of Object.entries(networkOptions)){
+        const config = typeof options === 'string' ? await (0, _chopsticks.fetchConfig)(options) : options ?? await (0, _chopsticks.fetchConfig)(name);
+        ret[name] = await setupContextWithConfig(config);
         wasmOverriden ||= config['wasm-override'] != null;
     }
-    const relaychainName = Object.keys(ret).filter((x) => ['polkadot', 'kusama'].includes(x.toLocaleLowerCase()))[0];
+    const relaychainName = Object.keys(ret).filter((x)=>[
+            'polkadot',
+            'kusama'
+        ].includes(x.toLocaleLowerCase()))[0];
     const { [relaychainName]: relaychain, ...parachains } = ret;
     if (relaychain) {
-        for (const parachain of Object.values(parachains)) {
-            await (0, chopsticks_1.connectVertical)(relaychain.chain, parachain.chain);
+        for (const parachain of Object.values(parachains)){
+            await (0, _chopsticks.connectVertical)(relaychain.chain, parachain.chain);
         }
     }
-    const parachainList = Object.values(parachains).map((i) => i.chain);
+    const parachainList = Object.values(parachains).map((i)=>i.chain);
     if (parachainList.length > 0) {
-        await (0, chopsticks_1.connectParachains)(parachainList);
+        await (0, _chopsticks.connectParachains)(parachainList);
     }
     if (wasmOverriden) {
         // trigger runtime upgrade if needed (due to wasm override)
-        for (const chain of Object.values(ret)) {
+        for (const chain of Object.values(ret)){
             await chain.dev.newBlock();
         }
         // handle xcm version message if needed (due to wasm override triggered xcm version upgrade)
-        for (const chain of Object.values(ret)) {
+        for (const chain of Object.values(ret)){
             await chain.dev.newBlock();
         }
     }
     return ret;
 };
-exports.setupNetworks = setupNetworks;
-const processCodecOrArray = (codec, fn) => Array.isArray(codec) ? codec.map(fn) : fn(codec);
-const toHuman = (codec) => processCodecOrArray(codec, (c) => c?.toHuman?.() ?? c);
-const toJson = (codec) => processCodecOrArray(codec, (c) => c?.toJSON?.() ?? c);
-const toHex = (codec) => processCodecOrArray(codec, (c) => c?.toHex?.() ?? c);
-const expectJson = (codec) => {
-    return (0, vitest_1.expect)(toJson(codec));
+const processCodecOrArray = (codec, fn)=>Array.isArray(codec) ? codec.map(fn) : fn(codec);
+const toHuman = (codec)=>processCodecOrArray(codec, (c)=>c?.toHuman?.() ?? c);
+const toJson = (codec)=>processCodecOrArray(codec, (c)=>c?.toJSON?.() ?? c);
+const toHex = (codec)=>processCodecOrArray(codec, (c)=>c?.toHex?.() ?? c);
+const expectJson = (codec)=>{
+    return (0, _vitest.expect)(toJson(codec));
 };
-exports.expectJson = expectJson;
-const expectHex = (codec) => {
-    return (0, vitest_1.expect)(toHex(codec));
+const expectHex = (codec)=>{
+    return (0, _vitest.expect)(toHex(codec));
 };
-exports.expectHex = expectHex;
-const _matchEvents = async (msg, events, ...filters) => {
-    let data = toHuman(await events).map(({ event: { index: _, ...event } }) => event);
+const _matchEvents = async (msg, events, ...filters)=>{
+    let data = toHuman(await events).map(({ event: { index: _, ...event } })=>event);
     if (filters.length > 0) {
-        const filtersArr = Array.isArray(filters) ? filters : [filters];
-        data = data.filter((evt) => {
-            return filtersArr.some((filter) => {
+        const filtersArr = Array.isArray(filters) ? filters : [
+            filters
+        ];
+        data = data.filter((evt)=>{
+            return filtersArr.some((filter)=>{
                 if (typeof filter === 'string') {
                     return evt.section === filter;
                 }
@@ -147,19 +202,17 @@ const _matchEvents = async (msg, events, ...filters) => {
             });
         });
     }
-    return (0, vitest_1.expect)(data).toMatchSnapshot(msg);
+    return (0, _vitest.expect)(data).toMatchSnapshot(msg);
 };
-const matchEvents = async (events, ...filters) => {
-    return _matchEvents('events', (0, exports.redact)(events), ...filters);
+const matchEvents = async (events, ...filters)=>{
+    return _matchEvents('events', redact(events), ...filters);
 };
-exports.matchEvents = matchEvents;
-const matchSystemEvents = async ({ api }, ...filters) => {
-    await _matchEvents('system events', (0, exports.redact)(api.query.system.events()), ...filters);
+const matchSystemEvents = async ({ api }, ...filters)=>{
+    await _matchEvents('system events', redact(api.query.system.events()), ...filters);
 };
-exports.matchSystemEvents = matchSystemEvents;
-const redact = async (data) => {
+const redact = async (data)=>{
     const json = toHuman(await data);
-    const process = (obj) => {
+    const process = (obj)=>{
         if (obj == null) {
             return obj;
         }
@@ -188,26 +241,27 @@ const redact = async (data) => {
             return obj;
         }
         if (typeof obj === 'object') {
-            return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, process(v)]));
+            return Object.fromEntries(Object.entries(obj).map(([k, v])=>[
+                    k,
+                    process(v)
+                ]));
         }
         return obj;
     };
     return process(json);
 };
-exports.redact = redact;
 function defer() {
     const deferred = {};
-    deferred.promise = new Promise((resolve, reject) => {
+    deferred.promise = new Promise((resolve, reject)=>{
         deferred.resolve = resolve;
         deferred.reject = reject;
     });
     return deferred;
 }
-exports.defer = defer;
-const sendTransaction = async (tx) => {
+const sendTransaction = async (tx)=>{
     const signed = await tx;
     const deferred = defer();
-    await signed.send((status) => {
+    await signed.send((status)=>{
         console.log('tranaction status: ', status.status.toHuman());
         if (status.isInBlock || status.isFinalized) {
             deferred.resolve(status.events);
@@ -217,14 +271,18 @@ const sendTransaction = async (tx) => {
         }
     });
     return {
-        events: deferred.promise,
+        events: deferred.promise
     };
 };
-exports.sendTransaction = sendTransaction;
-const testingPairs = (keyringType = 'ed25519', ss58Format) => {
-    const keyringEth = (0, keyring_1.createTestKeyring)({ type: 'ethereum' });
+const testingPairs = (keyringType = 'ed25519', ss58Format)=>{
+    const keyringEth = (0, _keyring.createTestKeyring)({
+        type: 'ethereum'
+    });
     // default to ed25519 because sr25519 signature is non-deterministic
-    const keyring = new keyring_1.Keyring({ type: keyringType, ss58Format });
+    const keyring = new _keyring.Keyring({
+        type: keyringType,
+        ss58Format
+    });
     return {
         alice: keyring.addFromUri('//Alice'),
         bob: keyring.addFromUri('//Bob'),
@@ -237,7 +295,6 @@ const testingPairs = (keyringType = 'ed25519', ss58Format) => {
         dorothy: keyringEth.getPair('0x773539d4Ac0e786233D90A233654ccEE26a613D9'),
         ethan: keyringEth.getPair('0xFf64d3F6efE2317EE2807d223a0Bdc4c0c49dfDB'),
         keyring,
-        keyringEth,
+        keyringEth
     };
 };
-exports.testingPairs = testingPairs;

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/dist/cjs/signFake.js

@@ -1,22 +1,40 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.signFake = exports.signFakeWithApi = void 0;
-const signFakeWithApi = async (api, tx, addr, options = {}) => {
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    signFake: function() {
+        return signFake;
+    },
+    signFakeWithApi: function() {
+        return signFakeWithApi;
+    }
+});
+const signFakeWithApi = async (api, tx, addr, options = {})=>{
     const nonce = options.nonce ?? (await api.query.system.account(addr)).nonce;
-    (0, exports.signFake)(tx, addr, {
+    signFake(tx, addr, {
         nonce,
         genesisHash: api.genesisHash,
         runtimeVersion: api.runtimeVersion,
         blockHash: api.genesisHash,
-        ...options,
+        ...options
     });
 };
-exports.signFakeWithApi = signFakeWithApi;
-const signFake = (tx, addr, options) => {
+const signFake = (tx, addr, options)=>{
     const mockSignature = new Uint8Array(64);
     mockSignature.fill(0xcd);
-    mockSignature.set([0xde, 0xad, 0xbe, 0xef]);
+    mockSignature.set([
+        0xde,
+        0xad,
+        0xbe,
+        0xef
+    ]);
     tx.signFake(addr, options);
     tx.signature.set(mockSignature);
 };
-exports.signFake = signFake;