@acala-network/chopsticks-testing 0.5.10

package/lib/index.d.ts

@@ -0,0 +1,70 @@
+import { ApiPromise, WsProvider } from '@polkadot/api';
+import { Codec } from '@polkadot/types/types';
+import { HexString } from '@polkadot/util/types';
+import { Keyring } from '@polkadot/keyring';
+import { StorageValues } from '@acala-network/chopsticks/utils/set-storage';
+import { SubmittableExtrinsic } from '@polkadot/api-base/types';
+export type SetupOption = {
+    endpoint: string;
+    blockNumber?: number;
+    blockHash?: HexString;
+    wasmOverride?: string;
+    db?: string;
+};
+export declare const setupContext: ({ endpoint, blockNumber, blockHash, wasmOverride, db }: SetupOption) => Promise<{
+    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>;
+}>;
+type CodecOrArray = Codec | Codec[];
+export declare const expectEvent: (codec: CodecOrArray, event: any) => void;
+export declare const expectHuman: (codec: CodecOrArray) => Vi.Assertion<any>;
+export declare const expectJson: (codec: CodecOrArray) => Vi.Assertion<any>;
+export declare const expectHex: (codec: CodecOrArray) => Vi.Assertion<any>;
+export declare const matchJson: (codec: CodecOrArray) => void;
+export declare const matchHuman: (codec: CodecOrArray) => void;
+type EventFilter = string | {
+    method: string;
+    section: string;
+};
+export declare const matchEvents: (events: Promise<Codec[] | Codec>, ...filters: EventFilter[]) => Promise<void>;
+export declare const matchSystemEvents: ({ api }: {
+    api: ApiPromise;
+}, ...filters: EventFilter[]) => Promise<void>;
+export declare const matchUmp: ({ api }: {
+    api: ApiPromise;
+}) => Promise<void>;
+export declare const matchHrmp: ({ api }: {
+    api: ApiPromise;
+}) => Promise<void>;
+export declare const redact: (data: any | Promise<any>) => Promise<any>;
+export declare function defer<T>(): {
+    resolve: (value: any) => void;
+    reject: (reason: any) => void;
+    promise: Promise<T>;
+};
+export declare const sendTransaction: (tx: Promise<SubmittableExtrinsic<'promise'>>) => Promise<{
+    events: Promise<Codec[]>;
+}>;
+export declare const balance: (api: ApiPromise, address: string) => Promise<Record<string, import("@polkadot/types/types").AnyJson>>;
+export declare const testingPairs: (ss58Format?: number) => {
+    alice: import("@polkadot/keyring/types").KeyringPair;
+    bob: import("@polkadot/keyring/types").KeyringPair;
+    charlie: import("@polkadot/keyring/types").KeyringPair;
+    dave: import("@polkadot/keyring/types").KeyringPair;
+    eve: import("@polkadot/keyring/types").KeyringPair;
+    test1: import("@polkadot/keyring/types").KeyringPair;
+    test2: import("@polkadot/keyring/types").KeyringPair;
+    keyring: Keyring;
+};
+export {};

package/lib/index.js

@@ -0,0 +1,193 @@
+import { ApiPromise, WsProvider } from '@polkadot/api';
+import { BuildBlockMode, setupWithServer } from '@acala-network/chopsticks';
+import { Keyring } from '@polkadot/keyring';
+import { expect } from 'vitest';
+export const setupContext = async ({ endpoint, blockNumber, blockHash, wasmOverride, db }) => {
+    // random port
+    const port = Math.floor(Math.random() * 10000) + 10000;
+    const config = {
+        endpoint,
+        port,
+        block: blockNumber || blockHash,
+        mockSignatureHost: true,
+        'build-block-mode': BuildBlockMode.Manual,
+        db,
+        'wasm-override': wasmOverride,
+    };
+    const { chain, listenPort, close } = await setupWithServer(config);
+    const ws = new WsProvider(`ws://localhost:${listenPort}`);
+    const api = await ApiPromise.create({
+        provider: ws,
+        signedExtensions: {
+            SetEvmOrigin: {
+                extrinsic: {},
+                payload: {},
+            },
+        },
+    });
+    await api.isReady;
+    return {
+        chain,
+        ws,
+        api,
+        dev: {
+            newBlock: (param) => {
+                return ws.send('dev_newBlock', [param]);
+            },
+            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]);
+            },
+        },
+        async teardown() {
+            await api.disconnect();
+            await close();
+        },
+    };
+};
+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 expectEvent = (codec, event) => {
+    return expect(toHuman(codec)).toEqual(expect.arrayContaining([expect.objectContaining(event)]));
+};
+export const expectHuman = (codec) => {
+    return expect(toHuman(codec));
+};
+export const expectJson = (codec) => {
+    return expect(toJson(codec));
+};
+export const expectHex = (codec) => {
+    return expect(toHex(codec));
+};
+export const matchJson = (codec) => {
+    return expect(toJson(codec)).toMatchSnapshot();
+};
+export const matchHuman = (codec) => {
+    return expect(toHuman(codec)).toMatchSnapshot();
+};
+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) => {
+                if (typeof filter === 'string') {
+                    return evt.section === filter;
+                }
+                const { section, method } = filter;
+                return evt.section === section && evt.method === method;
+            });
+        });
+    }
+    return expect(data).toMatchSnapshot(msg);
+};
+export const matchEvents = async (events, ...filters) => {
+    return _matchEvents('events', redact(events), ...filters);
+};
+export const matchSystemEvents = async ({ api }, ...filters) => {
+    await _matchEvents('system events', redact(api.query.system.events()), ...filters);
+};
+export const matchUmp = async ({ api }) => {
+    const ump = await api.query.parachainSystem.upwardMessages();
+    const decoded = ump.toJSON().map((msg) => api.createType('XcmVersionedXcm', msg));
+    expect(decoded).toMatchSnapshot('ump');
+};
+export const matchHrmp = async ({ api }) => {
+    const hrmp = await api.query.parachainSystem.hrmpOutboundMessages();
+    const decoded = hrmp.toJSON().map(({ recipient, data }) => ({
+        data: api.createType('(XcmpMessageFormat, XcmVersionedXcm)', data),
+        recipient,
+    }));
+    expect(decoded).toMatchSnapshot('hrmp');
+};
+export const redact = async (data) => {
+    const json = toHuman(await data);
+    const process = (obj) => {
+        if (obj == null) {
+            return obj;
+        }
+        if (Array.isArray(obj)) {
+            return obj.map(process);
+        }
+        if (typeof obj === 'number') {
+            const rounded = parseFloat(obj.toPrecision(2));
+            if (rounded === obj) {
+                return rounded;
+            }
+            return `(rounded ${rounded})`;
+        }
+        if (typeof obj === 'string') {
+            if (obj.match(/0x[0-9a-f]{64}/)) {
+                return '(hash)';
+            }
+            if (obj.match(/^[\d,]+$/)) {
+                const num = parseInt(obj.replace(/,/g, ''));
+                const rounded = parseFloat(num.toPrecision(2));
+                if (rounded === num) {
+                    return rounded;
+                }
+                return `(rounded ${rounded})`;
+            }
+            return obj;
+        }
+        if (typeof obj === 'object') {
+            return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, process(v)]));
+        }
+        return obj;
+    };
+    return process(json);
+};
+export function defer() {
+    const deferred = {};
+    deferred.promise = new Promise((resolve, reject) => {
+        deferred.resolve = resolve;
+        deferred.reject = reject;
+    });
+    return deferred;
+}
+export const sendTransaction = async (tx) => {
+    const signed = await tx;
+    const deferred = defer();
+    await signed.send((status) => {
+        if (status.isCompleted) {
+            deferred.resolve(status.events);
+        }
+        if (status.isError) {
+            deferred.reject(status.status);
+        }
+    });
+    return {
+        events: deferred.promise,
+    };
+};
+export const balance = async (api, address) => {
+    const account = await api.query.system.account(address);
+    return account.data.toJSON();
+};
+export const testingPairs = (ss58Format) => {
+    const keyring = new Keyring({ type: 'ed25519', ss58Format }); // cannot use sr25519 as it is non determinstic
+    const alice = keyring.addFromUri('//Alice');
+    const bob = keyring.addFromUri('//Bob');
+    const charlie = keyring.addFromUri('//Charlie');
+    const dave = keyring.addFromUri('//Dave');
+    const eve = keyring.addFromUri('//Eve');
+    const test1 = keyring.addFromUri('//test1');
+    const test2 = keyring.addFromUri('//test2');
+    return {
+        alice,
+        bob,
+        charlie,
+        dave,
+        eve,
+        test1,
+        test2,
+        keyring,
+    };
+};

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@acala-network/chopsticks-testing",
+  "version": "0.5.10",
+  "author": "Bryan Chen <xlchen1291@gmail.com>",
+  "license": "Apache-2.0",
+  "scripts": {
+    "clean": "rm -rf lib tsconfig.tsbuildinfo",
+    "build": "tsc -p ./tsconfig.json"
+  },
+  "dependencies": {
+    "@acala-network/chopsticks": "^0.5.10"
+  },
+  "peerDependencies": {
+    "vitest": "^0.29.2"
+  },
+  "devDependencies": {
+    "@types/chai": "^4",
+    "typescript": "^4.9.5"
+  },
+  "files": [
+    "lib"
+  ],
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./*": {
+      "types": "./lib/*.d.ts",
+      "default": "./lib/*.js"
+    },
+    "./package.json": "./package.json"
+  }
+}