@acala-network/chopsticks-testing 0.8.5-5 → 0.9.0

package/dist/cjs/check.js

@@ -0,0 +1,192 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Checker_instances, _Checker_value, _Checker_pipeline, _Checker_format, _Checker_message, _Checker_redactOptions, _Checker_redact;
+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);
+class Checker {
+    constructor(value, message) {
+        _Checker_instances.add(this);
+        _Checker_value.set(this, void 0);
+        _Checker_pipeline.set(this, []);
+        _Checker_format.set(this, 'json');
+        _Checker_message.set(this, void 0);
+        _Checker_redactOptions.set(this, void 0);
+        __classPrivateFieldSet(this, _Checker_value, value, "f");
+        __classPrivateFieldSet(this, _Checker_message, message, "f");
+    }
+    toHuman() {
+        __classPrivateFieldSet(this, _Checker_format, 'human', "f");
+        return this;
+    }
+    toHex() {
+        __classPrivateFieldSet(this, _Checker_format, 'hex', "f");
+        return this;
+    }
+    toJson() {
+        __classPrivateFieldSet(this, _Checker_format, 'json', "f");
+        return this;
+    }
+    message(message) {
+        __classPrivateFieldSet(this, _Checker_message, message, "f");
+        return this;
+    }
+    filterEvents(...filters) {
+        this.toHuman();
+        __classPrivateFieldGet(this, _Checker_pipeline, "f").push((value) => {
+            let data = value.map(({ event: { index: _, ...event } }) => event);
+            if (filters.length > 0) {
+                data = data.filter((evt) => {
+                    return filters.some((filter) => {
+                        if (typeof filter === 'string') {
+                            return evt.section === filter;
+                        }
+                        else if ('method' in filter) {
+                            const { section, method } = filter;
+                            return evt.section === section && evt.method === method;
+                        }
+                    });
+                });
+            }
+            return data;
+        });
+        return this;
+    }
+    redact(options = { number: 2, hash: true }) {
+        __classPrivateFieldSet(this, _Checker_redactOptions, {
+            ...__classPrivateFieldGet(this, _Checker_redactOptions, "f"),
+            ...options,
+        }, "f");
+        return this;
+    }
+    map(fn) {
+        __classPrivateFieldGet(this, _Checker_pipeline, "f").push(fn);
+        return this;
+    }
+    pipe(fn) {
+        return fn ? fn(this) : this;
+    }
+    async value() {
+        let value = await __classPrivateFieldGet(this, _Checker_value, "f");
+        switch (__classPrivateFieldGet(this, _Checker_format, "f")) {
+            case 'human':
+                value = toHuman(value);
+                break;
+            case 'hex':
+                value = toHex(value);
+                break;
+            case 'json':
+                value = toJson(value);
+                break;
+        }
+        for (const fn of __classPrivateFieldGet(this, _Checker_pipeline, "f")) {
+            value = await fn(value);
+        }
+        value = __classPrivateFieldGet(this, _Checker_instances, "m", _Checker_redact).call(this, value);
+        return value;
+    }
+    async toMatchSnapshot(msg) {
+        return (0, vitest_1.expect)(await this.value()).toMatchSnapshot(msg ?? __classPrivateFieldGet(this, _Checker_message, "f"));
+    }
+}
+exports.Checker = Checker;
+_Checker_value = new WeakMap(), _Checker_pipeline = new WeakMap(), _Checker_format = new WeakMap(), _Checker_message = new WeakMap(), _Checker_redactOptions = new WeakMap(), _Checker_instances = new WeakSet(), _Checker_redact = function _Checker_redact(value) {
+    if (!__classPrivateFieldGet(this, _Checker_redactOptions, "f")) {
+        return value;
+    }
+    const redactNumber = __classPrivateFieldGet(this, _Checker_redactOptions, "f").number === true || typeof __classPrivateFieldGet(this, _Checker_redactOptions, "f").number === 'number';
+    const precision = redactNumber
+        ? typeof __classPrivateFieldGet(this, _Checker_redactOptions, "f").number === 'number'
+            ? __classPrivateFieldGet(this, _Checker_redactOptions, "f").number
+            : 0
+        : 0;
+    const redactHash = __classPrivateFieldGet(this, _Checker_redactOptions, "f").hash === true;
+    const redactHex = __classPrivateFieldGet(this, _Checker_redactOptions, "f").hex === true;
+    const redactAddress = __classPrivateFieldGet(this, _Checker_redactOptions, "f").address === true;
+    const processNumber = (value) => {
+        if (precision > 0) {
+            const rounded = parseFloat(value.toPrecision(precision));
+            if (rounded === value) {
+                return rounded;
+            }
+            return `(rounded ${rounded})`;
+        }
+        return '(number)';
+    };
+    const process = (obj) => {
+        if (obj == null) {
+            return obj;
+        }
+        if (Array.isArray(obj)) {
+            return obj.map(process);
+        }
+        if (redactNumber && typeof obj === 'number') {
+            return processNumber(obj);
+        }
+        if (typeof obj === 'string') {
+            if (redactNumber && obj.match(/0x000000[0-9a-f]{26}/)) {
+                // this is very likely u128 encoded in hex
+                const num = parseInt(obj);
+                return processNumber(num);
+            }
+            if (redactHash && obj.match(/0x[0-9a-f]{64}/)) {
+                return '(hash)';
+            }
+            if (redactHex && obj.match(/0x[0-9a-f]+/)) {
+                return '(hex)';
+            }
+            if (redactAddress && obj.match(/^[1-9A-HJ-NP-Za-km-z]{46,48}$/)) {
+                return '(address)';
+            }
+            if (redactNumber && obj.match(/^-?[\d,]+$/)) {
+                const num = parseInt(obj.replace(/,/g, ''));
+                return processNumber(num);
+            }
+            return obj;
+        }
+        if (typeof obj === 'object') {
+            return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, process(v)]));
+        }
+        return obj;
+    };
+    return process(value);
+};
+const check = (value, msg) => {
+    if (value instanceof Checker) {
+        if (msg) {
+            return value.message(msg);
+        }
+        return value;
+    }
+    return new Checker(value, msg);
+};
+exports.check = check;
+const checkEvents = ({ events }, ...filters) => (0, exports.check)(events, 'events')
+    .filterEvents(...filters)
+    .redact();
+exports.checkEvents = checkEvents;
+const checkSystemEvents = ({ api }, ...filters) => (0, exports.check)(api.query.system.events(), 'system events')
+    .filterEvents(...filters)
+    .redact();
+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/dist/cjs/index.js

@@ -0,0 +1,243 @@
+"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);
+__exportStar(require("./signFake"), exports);
+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 = {
+        endpoint,
+        port,
+        block: blockNumber || blockHash,
+        'mock-signature-host': true,
+        'build-block-mode': chopsticks_1.BuildBlockMode.Manual,
+        'max-memory-block-count': maxMemoryBlockCount ?? 100,
+        db,
+        'wasm-override': wasmOverride,
+        timeout,
+        resume: resume ?? false,
+    };
+    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 api_1.WsProvider(url, undefined, undefined, timeout);
+    const api = await api_1.ApiPromise.create({
+        provider: ws,
+        signedExtensions: {
+            SetEvmOrigin: {
+                extrinsic: {},
+                payload: {},
+            },
+        },
+    });
+    await api.isReady;
+    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_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);
+const expectJson = (codec) => {
+    return (0, vitest_1.expect)(toJson(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) {
+        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 (0, vitest_1.expect)(data).toMatchSnapshot(msg);
+};
+const matchEvents = async (events, ...filters) => {
+    return _matchEvents('events', (0, exports.redact)(events), ...filters);
+};
+exports.matchEvents = matchEvents;
+const matchSystemEvents = async ({ api }, ...filters) => {
+    await _matchEvents('system events', (0, exports.redact)(api.query.system.events()), ...filters);
+};
+exports.matchSystemEvents = matchSystemEvents;
+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);
+};
+exports.redact = redact;
+function defer() {
+    const deferred = {};
+    deferred.promise = new Promise((resolve, reject) => {
+        deferred.resolve = resolve;
+        deferred.reject = reject;
+    });
+    return deferred;
+}
+exports.defer = defer;
+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,
+    };
+};
+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_1.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,
+    };
+};
+exports.testingPairs = testingPairs;

package/dist/cjs/signFake.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signFake = exports.signFakeWithApi = void 0;
+const signFakeWithApi = async (api, tx, addr, options = {}) => {
+    const nonce = options.nonce ?? (await api.query.system.account(addr)).nonce;
+    (0, exports.signFake)(tx, addr, {
+        nonce,
+        genesisHash: api.genesisHash,
+        runtimeVersion: api.runtimeVersion,
+        blockHash: api.genesisHash,
+        ...options,
+    });
+};
+exports.signFakeWithApi = signFakeWithApi;
+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);
+};
+exports.signFake = signFake;

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@acala-network/chopsticks-testing",
-  "version": "0.8.5-5",
+  "version": "0.9.0",
   "author": "Acala Developers <hello@acala.network>",
   "license": "Apache-2.0",
   "scripts": {
-    "clean": "rm -rf lib tsconfig.tsbuildinfo",
-    "build": "tsc -p ./tsconfig.json"
+    "clean": "rm -rf dist",
+    "build": "yarn clean && tsc -p ./tsconfig.json && tsc -p ./tsconfig.esm.json"
   },
   "dependencies": {
-    "@acala-network/chopsticks": "0.8.5-5"
+    "@acala-network/chopsticks": "0.9.0"
   },
   "peerDependencies": {
     "vitest": "^0.34.0"
@@ -18,18 +18,25 @@
     "typescript": "^5.1.6"
   },
   "files": [
-    "lib"
+    "dist/esm/**",
+    "dist/cjs/**",
+    "dist/types/**"
   ],
-  "main": "./lib/index.js",
-  "types": "./lib/index.d.ts",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/types/index.d.ts",
   "exports": {
     ".": {
-      "types": "./lib/index.d.ts",
-      "default": "./lib/index.js"
+      "types": "./dist/types/index.d.ts",
+      "require": "./dist/cjs/index.js",
+      "import": "./dist/esm/index.js",
+      "default": "./dist/esm/index.js"
     },
     "./*": {
-      "types": "./lib/*.d.ts",
-      "default": "./lib/*.js"
+      "types": "./dist/types/index.d.ts",
+      "require": "./dist/cjs/index.js",
+      "import": "./dist/esm/index.js",
+      "default": "./dist/esm/index.js"
     },
     "./package.json": "./package.json"
   }