@acala-network/chopsticks-testing 0.7.0 → 0.7.2

package/lib/check.js

@@ -1,9 +1,12 @@
-import { expect } from 'vitest';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkHrmp = exports.checkUmp = exports.checkSystemEvents = exports.checkEvents = exports.check = exports.Checker = void 0;
+const vitest_1 = require("vitest");
 const processCodecOrArray = (codec, fn) => Array.isArray(codec) ? codec.map(fn) : fn(codec);
 const toHuman = (codec) => processCodecOrArray(codec, (c) => c?.toHuman?.() ?? c);
 const toHex = (codec) => processCodecOrArray(codec, (c) => c?.toHex?.() ?? c);
 const toJson = (codec) => processCodecOrArray(codec, (c) => c?.toJSON?.() ?? c);
-export class Checker {
+class Checker {
     #value;
     #pipeline = [];
     #format = 'json';
@@ -145,10 +148,11 @@ export class Checker {
         return value;
     }
     async toMatchSnapshot(msg) {
-        return expect(await this.value()).toMatchSnapshot(msg ?? this.#message);
+        return (0, vitest_1.expect)(await this.value()).toMatchSnapshot(msg ?? this.#message);
     }
 }
-export const check = (value, msg) => {
+exports.Checker = Checker;
+const check = (value, msg) => {
     if (value instanceof Checker) {
         if (msg) {
             return value.message(msg);
@@ -157,14 +161,19 @@ export const check = (value, msg) => {
     }
     return new Checker(value, msg);
 };
-export const checkEvents = ({ events }, ...filters) => check(events, 'events')
+exports.check = check;
+const checkEvents = ({ events }, ...filters) => (0, exports.check)(events, 'events')
     .filterEvents(...filters)
     .redact();
-export const checkSystemEvents = ({ api }, ...filters) => check(api.query.system.events(), 'system events')
+exports.checkEvents = checkEvents;
+const checkSystemEvents = ({ api }, ...filters) => (0, exports.check)(api.query.system.events(), 'system events')
     .filterEvents(...filters)
     .redact();
-export const checkUmp = ({ api }) => check(api.query.parachainSystem.upwardMessages(), 'ump').map((value) => api.createType('Vec<XcmVersionedXcm>', value).toJSON());
-export const checkHrmp = ({ api }) => check(api.query.parachainSystem.hrmpOutboundMessages(), 'hrmp').map((value) => value.map(({ recipient, data }) => ({
+exports.checkSystemEvents = checkSystemEvents;
+const checkUmp = ({ api }) => (0, exports.check)(api.query.parachainSystem.upwardMessages(), 'ump').map((value) => api.createType('Vec<XcmVersionedXcm>', value).toJSON());
+exports.checkUmp = checkUmp;
+const checkHrmp = ({ api }) => (0, exports.check)(api.query.parachainSystem.hrmpOutboundMessages(), 'hrmp').map((value) => value.map(({ recipient, data }) => ({
     data: api.createType('(XcmpMessageFormat, XcmVersionedXcm)', data),
     recipient,
 })));
+exports.checkHrmp = checkHrmp;

package/lib/index.d.ts

@@ -1,5 +1,6 @@
 import { ApiPromise, WsProvider } from '@polkadot/api';
 import { Codec } from '@polkadot/types/types';
+import { Config } from '@acala-network/chopsticks/schema';
 import { HexString } from '@polkadot/util/types';
 import { Keyring } from '@polkadot/keyring';
 import { StorageValues } from '@acala-network/chopsticks/utils/set-storage';
@@ -12,8 +13,13 @@ export type SetupOption = {
     wasmOverride?: string;
     db?: string;
     timeout?: number;
+    port?: number;
 };
-export declare const setupContext: ({ endpoint, blockNumber, blockHash, wasmOverride, db, timeout }: SetupOption) => Promise<{
+export type SetupConfig = Config & {
+    timeout?: number;
+};
+export declare const createConfig: ({ endpoint, blockNumber, blockHash, wasmOverride, db, timeout, port, }: SetupOption) => SetupConfig;
+export declare const setupContext: (option: SetupOption) => Promise<{
     url: string;
     chain: import("@acala-network/chopsticks").Blockchain;
     ws: WsProvider;
@@ -30,6 +36,41 @@ export declare const setupContext: ({ endpoint, blockNumber, blockHash, wasmOver
     teardown(): Promise<void>;
     pause(): Promise<unknown>;
 }>;
+export declare const setupContextWithConfig: ({ timeout, ...config }: SetupConfig) => Promise<{
+    url: string;
+    chain: import("@acala-network/chopsticks").Blockchain;
+    ws: WsProvider;
+    api: ApiPromise;
+    dev: {
+        newBlock: (param?: {
+            count?: number;
+            to?: number;
+        }) => Promise<string>;
+        setStorage: (values: StorageValues, blockHash?: string) => Promise<any>;
+        timeTravel: (date: string | number) => Promise<number>;
+        setHead: (hashOrNumber: string | number) => Promise<any>;
+    };
+    teardown(): Promise<void>;
+    pause(): Promise<unknown>;
+}>;
+export type NetworkContext = Awaited<ReturnType<typeof setupContext>>;
+export declare const setupNetworks: (networkOptions: Partial<Record<string, Config | string | undefined>>) => Promise<Record<string, {
+    url: string;
+    chain: import("@acala-network/chopsticks").Blockchain;
+    ws: WsProvider;
+    api: ApiPromise;
+    dev: {
+        newBlock: (param?: {
+            count?: number;
+            to?: number;
+        }) => Promise<string>;
+        setStorage: (values: StorageValues, blockHash?: string) => Promise<any>;
+        timeTravel: (date: string | number) => Promise<number>;
+        setHead: (hashOrNumber: string | number) => Promise<any>;
+    };
+    teardown(): Promise<void>;
+    pause(): Promise<unknown>;
+}>>;
 type CodecOrArray = Codec | Codec[];
 export declare const expectJson: (codec: CodecOrArray) => import("@vitest/expect").Assertion<any>;
 export declare const expectHex: (codec: CodecOrArray) => import("@vitest/expect").Assertion<any>;

package/lib/index.js

@@ -1,24 +1,50 @@
-import { ApiPromise, WsProvider } from '@polkadot/api';
-import { BuildBlockMode, setupWithServer } from '@acala-network/chopsticks';
-import { Keyring, createTestKeyring } from '@polkadot/keyring';
-import { expect } from 'vitest';
-export * from './check';
-export const setupContext = async ({ endpoint, blockNumber, blockHash, wasmOverride, db, timeout }) => {
-    // random port
-    const port = Math.floor(Math.random() * 10000) + 10000;
+"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(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);
+const createConfig = ({ endpoint, blockNumber, blockHash, wasmOverride, db, timeout, port, }) => {
+    // random port if not specified
+    port = port ?? Math.floor(Math.random() * 10000) + 10000;
     const config = {
         endpoint,
         port,
         block: blockNumber || blockHash,
         mockSignatureHost: true,
-        'build-block-mode': BuildBlockMode.Manual,
+        'build-block-mode': chopsticks_1.BuildBlockMode.Manual,
         db,
         'wasm-override': wasmOverride,
+        timeout,
     };
-    const { chain, listenPort, close } = await setupWithServer(config);
+    return config;
+};
+exports.createConfig = createConfig;
+const setupContext = async (option) => {
+    return (0, exports.setupContextWithConfig)((0, exports.createConfig)(option));
+};
+exports.setupContext = setupContext;
+const setupContextWithConfig = async ({ timeout, ...config }) => {
+    const { chain, listenPort, close } = await (0, chopsticks_1.setupWithServer)(config);
     const url = `ws://localhost:${listenPort}`;
-    const ws = new WsProvider(url, undefined, undefined, timeout);
-    const api = await ApiPromise.create({
+    const ws = new api_1.WsProvider(url, undefined, undefined, timeout);
+    const api = await api_1.ApiPromise.create({
         provider: ws,
         signedExtensions: {
             SetEvmOrigin: {
@@ -52,23 +78,58 @@ export const setupContext = async ({ endpoint, blockNumber, blockHash, wasmOverr
             await close();
         },
         async pause() {
-            await ws.send('dev_setBlockBuildMode', [BuildBlockMode.Instant]);
+            await ws.send('dev_setBlockBuildMode', [chopsticks_1.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
         },
     };
 };
+exports.setupContextWithConfig = setupContextWithConfig;
+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);
+        wasmOverriden ||= config['wasm-override'] != null;
+    }
+    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);
+        }
+    }
+    const parachainList = Object.values(parachains).map((i) => i.chain);
+    if (parachainList.length > 0) {
+        await (0, chopsticks_1.connectParachains)(parachainList);
+    }
+    if (wasmOverriden) {
+        // trigger runtime upgrade if needed (due to wasm override)
+        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)) {
+            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);
-export const expectJson = (codec) => {
-    return expect(toJson(codec));
+const expectJson = (codec) => {
+    return (0, vitest_1.expect)(toJson(codec));
 };
-export const expectHex = (codec) => {
-    return expect(toHex(codec));
+exports.expectJson = expectJson;
+const expectHex = (codec) => {
+    return (0, vitest_1.expect)(toHex(codec));
 };
+exports.expectHex = expectHex;
 const _matchEvents = async (msg, events, ...filters) => {
     let data = toHuman(await events).map(({ event: { index: _, ...event } }) => event);
     if (filters.length > 0) {
@@ -83,15 +144,17 @@ const _matchEvents = async (msg, events, ...filters) => {
             });
         });
     }
-    return expect(data).toMatchSnapshot(msg);
+    return (0, vitest_1.expect)(data).toMatchSnapshot(msg);
 };
-export const matchEvents = async (events, ...filters) => {
-    return _matchEvents('events', redact(events), ...filters);
+const matchEvents = async (events, ...filters) => {
+    return _matchEvents('events', (0, exports.redact)(events), ...filters);
 };
-export const matchSystemEvents = async ({ api }, ...filters) => {
-    await _matchEvents('system events', redact(api.query.system.events()), ...filters);
+exports.matchEvents = matchEvents;
+const matchSystemEvents = async ({ api }, ...filters) => {
+    await _matchEvents('system events', (0, exports.redact)(api.query.system.events()), ...filters);
 };
-export const redact = async (data) => {
+exports.matchSystemEvents = matchSystemEvents;
+const redact = async (data) => {
     const json = toHuman(await data);
     const process = (obj) => {
         if (obj == null) {
@@ -128,7 +191,8 @@ export const redact = async (data) => {
     };
     return process(json);
 };
-export function defer() {
+exports.redact = redact;
+function defer() {
     const deferred = {};
     deferred.promise = new Promise((resolve, reject) => {
         deferred.resolve = resolve;
@@ -136,7 +200,8 @@ export function defer() {
     });
     return deferred;
 }
-export const sendTransaction = async (tx) => {
+exports.defer = defer;
+const sendTransaction = async (tx) => {
     const signed = await tx;
     const deferred = defer();
     await signed.send((status) => {
@@ -152,10 +217,11 @@ export const sendTransaction = async (tx) => {
         events: deferred.promise,
     };
 };
-export const testingPairs = (keyringType = 'ed25519', ss58Format) => {
-    const keyringEth = createTestKeyring({ type: 'ethereum' });
+exports.sendTransaction = sendTransaction;
+const testingPairs = (keyringType = 'ed25519', ss58Format) => {
+    const keyringEth = (0, keyring_1.createTestKeyring)({ type: 'ethereum' });
     // default to ed25519 because sr25519 signature is non-deterministic
-    const keyring = new Keyring({ type: keyringType, ss58Format });
+    const keyring = new keyring_1.Keyring({ type: keyringType, ss58Format });
     return {
         alice: keyring.addFromUri('//Alice'),
         bob: keyring.addFromUri('//Bob'),
@@ -171,3 +237,4 @@ export const testingPairs = (keyringType = 'ed25519', ss58Format) => {
         keyringEth,
     };
 };
+exports.testingPairs = testingPairs;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acala-network/chopsticks-testing",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "author": "Bryan Chen <xlchen1291@gmail.com>",
   "license": "Apache-2.0",
   "scripts": {
@@ -8,7 +8,7 @@
     "build": "tsc -p ./tsconfig.json"
   },
   "dependencies": {
-    "@acala-network/chopsticks": "0.7.0"
+    "@acala-network/chopsticks": "0.7.2"
   },
   "peerDependencies": {
     "vitest": "^0.33.0"