@acala-network/chopsticks-utils 0.9.2-2

package/dist/cjs/index.js

@@ -0,0 +1,204 @@
+"use strict";
+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;
+    },
+    sendTransaction: function() {
+        return sendTransaction;
+    },
+    setupContext: function() {
+        return setupContext;
+    },
+    setupContextWithConfig: function() {
+        return setupContextWithConfig;
+    },
+    setupNetworks: function() {
+        return setupNetworks;
+    },
+    testingPairs: function() {
+        return testingPairs;
+    }
+});
+const _api = require("@polkadot/api");
+const _chopsticks = require("@acala-network/chopsticks");
+const _keyring = require("@polkadot/keyring");
+_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, runtimeLogLevel })=>{
+    // random port if not specified
+    port = port ?? Math.floor(Math.random() * 10000) + 10000;
+    const config = {
+        endpoint,
+        port,
+        block: blockNumber || blockHash,
+        'mock-signature-host': true,
+        'build-block-mode': _chopsticks.BuildBlockMode.Manual,
+        'max-memory-block-count': maxMemoryBlockCount ?? 100,
+        'runtime-log-level': runtimeLogLevel,
+        db,
+        'wasm-override': wasmOverride,
+        timeout,
+        resume: resume ?? false
+    };
+    return config;
+};
+const setupContext = async (option)=>{
+    return setupContextWithConfig(createConfig(option));
+};
+const setupContextWithConfig = async ({ timeout, ...config })=>{
+    const { chain, listenPort, close } = await (0, _chopsticks.setupWithServer)(config);
+    const url = `ws://localhost:${listenPort}`;
+    const ws = new _api.WsProvider(url, 3_000, undefined, timeout);
+    const api = await _api.ApiPromise.create({
+        provider: ws,
+        noInitWarn: true
+    });
+    return {
+        url,
+        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();
+        },
+        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
+            ;
+        }
+    };
+};
+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.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]: relaychain, ...parachains } = ret;
+    if (relaychain) {
+        for (const parachain of Object.values(parachains)){
+            await (0, _chopsticks.connectVertical)(relaychain.chain, parachain.chain);
+        }
+    }
+    const parachainList = Object.values(parachains).map((i)=>i.chain);
+    if (parachainList.length > 0) {
+        await (0, _chopsticks.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;
+};
+function defer() {
+    const deferred = {};
+    deferred.promise = new Promise((resolve, reject)=>{
+        deferred.resolve = resolve;
+        deferred.reject = reject;
+    });
+    return deferred;
+}
+const sendTransaction = async (tx)=>{
+    const signed = await tx;
+    const deferred = defer();
+    await signed.send((status)=>{
+        console.log('tranaction status: ', status.status.toHuman());
+        if (status.isInBlock || status.isFinalized) {
+            deferred.resolve(status.events);
+        }
+        if (status.isError) {
+            deferred.reject(status.status);
+        }
+    });
+    return {
+        events: deferred.promise
+    };
+};
+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.Keyring({
+        type: keyringType,
+        ss58Format
+    });
+    return {
+        alice: keyring.addFromUri('//Alice'),
+        bob: keyring.addFromUri('//Bob'),
+        charlie: keyring.addFromUri('//Charlie'),
+        dave: keyring.addFromUri('//Dave'),
+        eve: keyring.addFromUri('//Eve'),
+        alith: keyringEth.getPair('0xf24FF3a9CF04c71Dbc94D0b566f7A27B94566cac'),
+        baltathar: keyringEth.getPair('0x3Cd0A705a2DC65e5b1E1205896BaA2be8A07c6e0'),
+        charleth: keyringEth.getPair('0x798d4Ba9baf0064Ec19eB4F0a1a45785ae9D6DFc'),
+        dorothy: keyringEth.getPair('0x773539d4Ac0e786233D90A233654ccEE26a613D9'),
+        ethan: keyringEth.getPair('0xFf64d3F6efE2317EE2807d223a0Bdc4c0c49dfDB'),
+        keyring,
+        keyringEth
+    };
+};

package/dist/cjs/package.json

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

package/dist/cjs/signFake.js

@@ -0,0 +1,40 @@
+"use strict";
+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;
+    signFake(tx, addr, {
+        nonce,
+        genesisHash: api.genesisHash,
+        runtimeVersion: api.runtimeVersion,
+        blockHash: api.genesisHash,
+        ...options
+    });
+};
+const signFake = (tx, addr, options)=>{
+    const mockSignature = new Uint8Array(64);
+    mockSignature.fill(0xcd);
+    mockSignature.set([
+        0xde,
+        0xad,
+        0xbe,
+        0xef
+    ]);
+    tx.signFake(addr, options);
+    tx.signature.set(mockSignature);
+};

package/dist/esm/index.js

@@ -0,0 +1,158 @@
+import { ApiPromise, WsProvider } from '@polkadot/api';
+import { BuildBlockMode, connectParachains, connectVertical, fetchConfig, setupWithServer } from '@acala-network/chopsticks';
+import { Keyring, createTestKeyring } from '@polkadot/keyring';
+export * from './signFake.js';
+export const createConfig = ({ endpoint, blockNumber, blockHash, wasmOverride, db, timeout, port, maxMemoryBlockCount, resume, runtimeLogLevel })=>{
+    // random port if not specified
+    port = port ?? Math.floor(Math.random() * 10000) + 10000;
+    const config = {
+        endpoint,
+        port,
+        block: blockNumber || blockHash,
+        'mock-signature-host': true,
+        'build-block-mode': BuildBlockMode.Manual,
+        'max-memory-block-count': maxMemoryBlockCount ?? 100,
+        'runtime-log-level': runtimeLogLevel,
+        db,
+        'wasm-override': wasmOverride,
+        timeout,
+        resume: resume ?? false
+    };
+    return config;
+};
+export const setupContext = async (option)=>{
+    return setupContextWithConfig(createConfig(option));
+};
+export const setupContextWithConfig = async ({ timeout, ...config })=>{
+    const { chain, listenPort, close } = await setupWithServer(config);
+    const url = `ws://localhost:${listenPort}`;
+    const ws = new WsProvider(url, 3_000, undefined, timeout);
+    const api = await ApiPromise.create({
+        provider: ws,
+        noInitWarn: true
+    });
+    return {
+        url,
+        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();
+        },
+        async pause () {
+            await ws.send('dev_setBlockBuildMode', [
+                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
+            ;
+        }
+    };
+};
+export const setupNetworks = async (networkOptions)=>{
+    const ret = {};
+    let wasmOverriden = false;
+    for (const [name, options] of Object.entries(networkOptions)){
+        const config = typeof options === 'string' ? await fetchConfig(options) : options ?? await 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]: relaychain, ...parachains } = ret;
+    if (relaychain) {
+        for (const parachain of Object.values(parachains)){
+            await connectVertical(relaychain.chain, parachain.chain);
+        }
+    }
+    const parachainList = Object.values(parachains).map((i)=>i.chain);
+    if (parachainList.length > 0) {
+        await 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;
+};
+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)=>{
+        console.log('tranaction status: ', status.status.toHuman());
+        if (status.isInBlock || status.isFinalized) {
+            deferred.resolve(status.events);
+        }
+        if (status.isError) {
+            deferred.reject(status.status);
+        }
+    });
+    return {
+        events: deferred.promise
+    };
+};
+export const testingPairs = (keyringType = 'ed25519', ss58Format)=>{
+    const keyringEth = createTestKeyring({
+        type: 'ethereum'
+    });
+    // default to ed25519 because sr25519 signature is non-deterministic
+    const keyring = new Keyring({
+        type: keyringType,
+        ss58Format
+    });
+    return {
+        alice: keyring.addFromUri('//Alice'),
+        bob: keyring.addFromUri('//Bob'),
+        charlie: keyring.addFromUri('//Charlie'),
+        dave: keyring.addFromUri('//Dave'),
+        eve: keyring.addFromUri('//Eve'),
+        alith: keyringEth.getPair('0xf24FF3a9CF04c71Dbc94D0b566f7A27B94566cac'),
+        baltathar: keyringEth.getPair('0x3Cd0A705a2DC65e5b1E1205896BaA2be8A07c6e0'),
+        charleth: keyringEth.getPair('0x798d4Ba9baf0064Ec19eB4F0a1a45785ae9D6DFc'),
+        dorothy: keyringEth.getPair('0x773539d4Ac0e786233D90A233654ccEE26a613D9'),
+        ethan: keyringEth.getPair('0xFf64d3F6efE2317EE2807d223a0Bdc4c0c49dfDB'),
+        keyring,
+        keyringEth
+    };
+};

package/dist/esm/signFake.js

@@ -0,0 +1,22 @@
+export const signFakeWithApi = async (api, tx, addr, options = {})=>{
+    const nonce = options.nonce ?? (await api.query.system.account(addr)).nonce;
+    signFake(tx, addr, {
+        nonce,
+        genesisHash: api.genesisHash,
+        runtimeVersion: api.runtimeVersion,
+        blockHash: api.genesisHash,
+        ...options
+    });
+};
+export const signFake = (tx, addr, options)=>{
+    const mockSignature = new Uint8Array(64);
+    mockSignature.fill(0xcd);
+    mockSignature.set([
+        0xde,
+        0xad,
+        0xbe,
+        0xef
+    ]);
+    tx.signFake(addr, options);
+    tx.signature.set(mockSignature);
+};

package/dist/types/index.d.ts

@@ -0,0 +1,101 @@
+import { ApiPromise, WsProvider } from '@polkadot/api';
+import { StorageValues } from '@acala-network/chopsticks';
+import { Codec } from '@polkadot/types/types';
+import { Config } from '@acala-network/chopsticks/schema/index.js';
+import { HexString } from '@polkadot/util/types';
+import { Keyring } from '@polkadot/keyring';
+import { SubmittableExtrinsic } from '@polkadot/api-base/types';
+export * from './signFake.js';
+export type SetupOption = {
+    endpoint: string;
+    blockNumber?: number;
+    blockHash?: HexString;
+    wasmOverride?: string;
+    db?: string;
+    timeout?: number;
+    port?: number;
+    maxMemoryBlockCount?: number;
+    resume?: boolean | HexString | number;
+    runtimeLogLevel?: number;
+};
+export type SetupConfig = Config & {
+    timeout?: number;
+};
+export declare const createConfig: ({ endpoint, blockNumber, blockHash, wasmOverride, db, timeout, port, maxMemoryBlockCount, resume, runtimeLogLevel, }: SetupOption) => SetupConfig;
+export declare const setupContext: (option: SetupOption) => Promise<{
+    url: string;
+    chain: import("@acala-network/chopsticks").Blockchain;
+    ws: WsProvider;
+    api: ApiPromise;
+    dev: {
+        newBlock: (param?: {
+            count?: number;
+            to?: number;
+            unsafeBlockHeight?: 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 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;
+            unsafeBlockHeight?: 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;
+            unsafeBlockHeight?: 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 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 testingPairs: (keyringType?: 'ed25519' | 'sr25519', 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;
+    alith: import("@polkadot/keyring/types").KeyringPair;
+    baltathar: import("@polkadot/keyring/types").KeyringPair;
+    charleth: import("@polkadot/keyring/types").KeyringPair;
+    dorothy: import("@polkadot/keyring/types").KeyringPair;
+    ethan: import("@polkadot/keyring/types").KeyringPair;
+    keyring: Keyring;
+    keyringEth: import("@polkadot/keyring/types").KeyringInstance;
+};

package/dist/types/signFake.d.ts

@@ -0,0 +1,6 @@
+import { ApiPromise } from '@polkadot/api';
+import { GenericExtrinsic } from '@polkadot/types';
+import { SignatureOptions } from '@polkadot/types/types';
+export type SignFakeOptions = Partial<SignatureOptions>;
+export declare const signFakeWithApi: (api: ApiPromise, tx: GenericExtrinsic, addr: string, options?: SignFakeOptions) => Promise<void>;
+export declare const signFake: (tx: GenericExtrinsic, addr: string, options: SignatureOptions) => void;

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@acala-network/chopsticks-utils",
+  "version": "0.9.2-2",
+  "author": "Acala Developers <hello@acala.network>",
+  "license": "Apache-2.0",
+  "type": "module",
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "yarn clean && yarn build:cjs && yarn build:esm && yarn build:types",
+    "build:cjs": "swc ./src --config-file ../../.cjsswcrc -d dist/cjs && echo '{\"type\": \"commonjs\"}' > dist/cjs/package.json",
+    "build:esm": "swc ./src --config-file ../../.esmswcrc -d dist/esm",
+    "build:types": "tsc -p tsconfig.json --emitDeclarationOnly --outDir dist/types"
+  },
+  "dependencies": {
+    "@acala-network/chopsticks": "0.9.2-5"
+  },
+  "devDependencies": {
+    "@swc/cli": "0.1.62",
+    "@swc/core": "^1.3.96",
+    "typescript": "^5.2.2"
+  },
+  "files": [
+    "dist/esm/**",
+    "dist/cjs/**",
+    "dist/types/**"
+  ],
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "require": "./dist/cjs/index.js",
+      "import": "./dist/esm/index.js",
+      "default": "./dist/esm/index.js"
+    },
+    "./*": {
+      "types": "./dist/types/*.d.ts",
+      "require": "./dist/cjs/*.js",
+      "import": "./dist/esm/*.js",
+      "default": "./dist/esm/*.js"
+    },
+    "./package.json": "./package.json",
+    "./package.cjs.json": "./dist/cjs/package.json"
+  }
+}