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

package/dist/esm/utils/time-travel.js

@@ -0,0 +1,58 @@
+import { hexToU8a, u8aToHex } from '@polkadot/util';
+import { compactHex } from '.';
+import { getAuraSlotDuration } from '../wasm-executor';
+import { setStorage } from './set-storage';
+export const getCurrentSlot = async (chain) => {
+    const meta = await chain.head.meta;
+    // use raw key here because some chain did not expose those storage to metadata
+    const slotRaw = meta.consts.babe
+        ? await chain.head.get('0x1cb6f36e027abb2091cfb5110ab5087f06155b3cd9a8c9e5e9a23fd5dc13a5ed') // babe.currentSlot
+        : await chain.head.get('0x57f8dc2f5ab09467896f47300f04243806155b3cd9a8c9e5e9a23fd5dc13a5ed'); // aura.currentSlot
+    if (!slotRaw)
+        throw new Error('Cannot find current slot');
+    return meta.registry.createType('Slot', hexToU8a(slotRaw)).toNumber();
+};
+export const getCurrentTimestamp = async (chain) => {
+    const meta = await chain.head.meta;
+    const timestamp = await chain.head.read('u64', meta.query.timestamp.now);
+    return timestamp?.toBigInt() ?? 0n;
+};
+export const getSlotDuration = async (chain) => {
+    const meta = await chain.head.meta;
+    return meta.consts.babe
+        ? meta.consts.babe.expectedBlockTime.toNumber()
+        : meta.query.aura
+            ? getAuraSlotDuration(await chain.head.wasm, meta.registry)
+            : 12000;
+};
+export const timeTravel = async (chain, timestamp) => {
+    const meta = await chain.head.meta;
+    const slotDuration = await getSlotDuration(chain);
+    const newSlot = Math.floor(timestamp / slotDuration);
+    // new timestamp
+    const storage = [
+        [compactHex(meta.query.timestamp.now()), u8aToHex(meta.registry.createType('u64', timestamp).toU8a())],
+    ];
+    if (meta.consts.babe) {
+        // new slot
+        storage.push([
+            compactHex(meta.query.babe.currentSlot()),
+            u8aToHex(meta.registry.createType('Slot', newSlot).toU8a()),
+        ]);
+        // new epoch
+        const epochDuration = meta.consts.babe.epochDuration.toNumber();
+        const newEpoch = Math.floor(timestamp / epochDuration);
+        storage.push([
+            compactHex(meta.query.babe.epochIndex()),
+            u8aToHex(meta.registry.createType('u64', newEpoch).toU8a()),
+        ]);
+    }
+    else if (meta.query.aura) {
+        // new slot
+        storage.push([
+            compactHex(meta.query.aura.currentSlot()),
+            u8aToHex(meta.registry.createType('Slot', newSlot).toU8a()),
+        ]);
+    }
+    await setStorage(chain, storage);
+};

package/dist/esm/wasm-executor/browser-wasm-executor.mjs

@@ -0,0 +1,32 @@
+import * as Comlink from 'comlink'
+import * as pkg from '@acala-network/chopsticks-executor'
+
+const getRuntimeVersion = async (code) => {
+	await pkg.wasmReady
+	return pkg.get_runtime_version(code)
+}
+
+// trie_version: 0 for old trie, 1 for new trie
+const calculateStateRoot = async (entries, trie_version) => {
+	await pkg.wasmReady
+	return pkg.calculate_state_root(entries, trie_version)
+}
+
+const decodeProof = async (trieRootHash, keys, nodes) => {
+	await pkg.wasmReady
+	return pkg.decode_proof(trieRootHash, keys, nodes)
+}
+
+const createProof = async (nodes, entries) => {
+	await pkg.wasmReady
+	return pkg.create_proof(nodes, entries)
+}
+
+const runTask = async (task, callback) => {
+	await pkg.wasmReady
+	return pkg.run_task(task, callback, 'info')
+}
+
+const wasmExecutor = { runTask, getRuntimeVersion, calculateStateRoot, createProof, decodeProof }
+
+Comlink.expose(wasmExecutor)

package/dist/esm/wasm-executor/browser-worker.js

@@ -0,0 +1,15 @@
+import { wrap } from 'comlink';
+export const startWorker = async () => {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    const worker = new Worker(new URL('browser-wasm-executor.mjs', import.meta.url), {
+        type: 'module',
+        name: 'chopsticks-wasm-executor',
+    });
+    return {
+        remote: wrap(worker),
+        terminate: async () => {
+            worker.terminate();
+        },
+    };
+};

package/dist/esm/wasm-executor/index.js

@@ -0,0 +1,146 @@
+import * as Comlink from 'comlink';
+import { hexToString, hexToU8a } from '@polkadot/util';
+import { randomAsHex } from '@polkadot/util-crypto';
+import _ from 'lodash';
+import { PREFIX_LENGTH } from '../utils/key-cache';
+import { defaultLogger, truncate } from '../logger';
+import { stripChildPrefix } from '../utils';
+const logger = defaultLogger.child({ name: 'executor' });
+let __executor_worker;
+const getWorker = async () => {
+    if (__executor_worker)
+        return __executor_worker;
+    const isNode = typeof process !== 'undefined' && process?.versions?.node; // true for node or bun
+    if (isNode) {
+        __executor_worker = import('./node-worker').then(({ startWorker }) => startWorker());
+    }
+    else {
+        __executor_worker = import('./browser-worker').then(({ startWorker }) => startWorker());
+    }
+    return __executor_worker;
+};
+export const getRuntimeVersion = _.memoize(async (code) => {
+    const worker = await getWorker();
+    return worker.remote.getRuntimeVersion(code).then((version) => {
+        version.specName = hexToString(version.specName);
+        version.implName = hexToString(version.implName);
+        return version;
+    });
+});
+// trie_version: 0 for old trie, 1 for new trie
+export const calculateStateRoot = async (entries, trie_version) => {
+    const worker = await getWorker();
+    return worker.remote.calculateStateRoot(entries, trie_version);
+};
+export const decodeProof = async (trieRootHash, keys, nodes) => {
+    const worker = await getWorker();
+    const result = await worker.remote.decodeProof(trieRootHash, keys, nodes);
+    return result.reduce((accum, [key, value]) => {
+        accum[key] = value;
+        return accum;
+    }, {});
+};
+export const createProof = async (nodes, entries) => {
+    const worker = await getWorker();
+    const [trieRootHash, newNodes] = await worker.remote.createProof(nodes, entries);
+    return { trieRootHash, nodes: newNodes };
+};
+export const runTask = async (task, callback = emptyTaskHandler) => {
+    const worker = await getWorker();
+    logger.trace(truncate(task), 'taskRun');
+    const response = await worker.remote.runTask(task, Comlink.proxy(callback));
+    if ('Call' in response) {
+        logger.trace(truncate(response.Call), 'taskResponse');
+    }
+    else {
+        logger.trace({ response }, 'taskResponse');
+    }
+    return response;
+};
+export const taskHandler = (block) => {
+    return {
+        getStorage: async function (key) {
+            return block.get(key);
+        },
+        getStateRoot: async function () {
+            const header = await block.header;
+            return header.stateRoot.toHex();
+        },
+        getNextKey: async function (prefix, key) {
+            const [nextKey] = await block.getKeysPaged({
+                prefix: prefix.length === 2 /** 0x */ ? key.slice(0, PREFIX_LENGTH) : prefix,
+                pageSize: 1,
+                startKey: key,
+            });
+            return nextKey && stripChildPrefix(nextKey);
+        },
+        offchainGetStorage: async function (key) {
+            if (!block.chain.offchainWorker)
+                throw new Error('offchain worker not found');
+            return block.chain.offchainWorker.get(key);
+        },
+        offchainTimestamp: async function () {
+            return Date.now();
+        },
+        offchainRandomSeed: async function () {
+            return randomAsHex(32);
+        },
+        offchainSubmitTransaction: async function (tx) {
+            if (!block.chain.offchainWorker)
+                throw new Error('offchain worker not found');
+            try {
+                const hash = await block.chain.offchainWorker.pushExtrinsic(block, tx);
+                logger.trace({ hash }, 'offchainSubmitTransaction');
+                return true;
+            }
+            catch (error) {
+                logger.trace({ error }, 'offchainSubmitTransaction');
+                return false;
+            }
+        },
+    };
+};
+export const emptyTaskHandler = {
+    getStorage: async function (_key) {
+        throw new Error('Method not implemented');
+    },
+    getStateRoot: async function () {
+        throw new Error('Method not implemented');
+    },
+    getNextKey: async function (_prefix, _key) {
+        throw new Error('Method not implemented');
+    },
+    offchainGetStorage: async function (_key) {
+        throw new Error('Method not implemented');
+    },
+    offchainTimestamp: async function () {
+        throw new Error('Method not implemented');
+    },
+    offchainRandomSeed: async function () {
+        throw new Error('Method not implemented');
+    },
+    offchainSubmitTransaction: async function (_tx) {
+        throw new Error('Method not implemented');
+    },
+};
+export const getAuraSlotDuration = _.memoize(async (wasm, registry) => {
+    const result = await runTask({
+        wasm,
+        calls: [['AuraApi_slot_duration', []]],
+        mockSignatureHost: false,
+        allowUnresolvedImports: false,
+        runtimeLogLevel: 0,
+    });
+    if ('Error' in result)
+        throw new Error(result.Error);
+    const slotDuration = registry.createType('u64', hexToU8a(result.Call.result)).toNumber();
+    return slotDuration;
+});
+export const releaseWorker = async () => {
+    if (!__executor_worker)
+        return;
+    const executor = await __executor_worker;
+    executor.remote[Comlink.releaseProxy]();
+    await executor.terminate();
+    __executor_worker = undefined;
+};

package/dist/esm/wasm-executor/node-wasm-executor.mjs

@@ -0,0 +1,29 @@
+import * as Comlink from 'comlink'
+import * as pkg from '@acala-network/chopsticks-executor'
+import { parentPort } from 'node:worker_threads'
+import nodeEndpoint from 'comlink/dist/umd/node-adapter.js'
+
+const getRuntimeVersion = async (code) => {
+	return pkg.get_runtime_version(code)
+}
+
+// trie_version: 0 for old trie, 1 for new trie
+const calculateStateRoot = async (entries, trie_version) => {
+	return pkg.calculate_state_root(entries, trie_version)
+}
+
+const decodeProof = async (trieRootHash, keys, nodes) => {
+	return pkg.decode_proof(trieRootHash, keys, nodes)
+}
+
+const createProof = async (nodes, entries) => {
+	return pkg.create_proof(nodes, entries)
+}
+
+const runTask = async (task, callback) => {
+	return pkg.run_task(task, callback, process.env.RUST_LOG)
+}
+
+const wasmExecutor = { runTask, getRuntimeVersion, calculateStateRoot, createProof, decodeProof }
+
+Comlink.expose(wasmExecutor, nodeEndpoint(parentPort))

package/dist/esm/wasm-executor/node-worker.js

@@ -0,0 +1,15 @@
+import { wrap } from 'comlink';
+import nodeEndpoint from 'comlink/dist/umd/node-adapter.js';
+import threads from 'node:worker_threads';
+import url from 'node:url';
+export const startWorker = async () => {
+    const worker = new threads.Worker(url.resolve(__filename, 'node-wasm-executor.mjs'), {
+        name: 'chopsticks-wasm-executor',
+    });
+    return {
+        remote: wrap(nodeEndpoint(worker)),
+        terminate: async () => {
+            await worker.terminate();
+        },
+    };
+};

package/dist/esm/xcm/downward.js

@@ -0,0 +1,25 @@
+import { hexToU8a } from '@polkadot/util';
+import { compactHex, getParaId } from '../utils';
+import { logger } from '.';
+import { setStorage } from '../utils/set-storage';
+export const connectDownward = async (relaychain, parachain) => {
+    const meta = await relaychain.head.meta;
+    const paraId = await getParaId(parachain);
+    const downwardMessageQueuesKey = compactHex(meta.query.dmp.downwardMessageQueues(paraId));
+    await relaychain.headState.subscribeStorage([downwardMessageQueuesKey], async (head, pairs) => {
+        const value = pairs[0][1];
+        if (!value)
+            return;
+        const meta = await head.meta;
+        const downwardMessageQueuesKey = compactHex(meta.query.dmp.downwardMessageQueues(paraId));
+        // clear relaychain message queue
+        await setStorage(relaychain, [[downwardMessageQueuesKey, null]], head.hash);
+        const downwardMessages = meta.registry
+            .createType('Vec<PolkadotCorePrimitivesInboundDownwardMessage>', hexToU8a(value))
+            .toJSON();
+        if (downwardMessages.length === 0)
+            return;
+        logger.debug({ downwardMessages }, 'downward_message');
+        parachain.submitDownwardMessages(downwardMessages);
+    });
+};

package/dist/esm/xcm/horizontal.js

@@ -0,0 +1,25 @@
+import { hexToU8a } from '@polkadot/util';
+import { compactHex } from '../utils';
+import { logger } from '.';
+export const connectHorizontal = async (parachains) => {
+    for (const [id, chain] of Object.entries(parachains)) {
+        const meta = await chain.head.meta;
+        const hrmpOutboundMessagesKey = compactHex(meta.query.parachainSystem.hrmpOutboundMessages());
+        await chain.headState.subscribeStorage([hrmpOutboundMessagesKey], async (head, pairs) => {
+            const value = pairs[0][1];
+            if (!value)
+                return;
+            const meta = await head.meta;
+            const outboundHrmpMessage = meta.registry
+                .createType('Vec<PolkadotCorePrimitivesOutboundHrmpMessage>', hexToU8a(value))
+                .toJSON();
+            logger.info({ outboundHrmpMessage }, 'outboundHrmpMessage');
+            for (const { recipient, data } of outboundHrmpMessage) {
+                const receiver = parachains[recipient];
+                if (receiver) {
+                    receiver.submitHorizontalMessages(Number(id), [{ sentAt: head.number, data }]);
+                }
+            }
+        });
+    }
+};

package/dist/esm/xcm/index.js

@@ -0,0 +1,20 @@
+import { connectDownward } from './downward';
+import { connectHorizontal } from './horizontal';
+import { connectUpward } from './upward';
+import { defaultLogger } from '../logger';
+import { getParaId } from '../utils';
+export const logger = defaultLogger.child({ name: 'xcm' });
+export const connectVertical = async (relaychain, parachain) => {
+    await connectDownward(relaychain, parachain);
+    await connectUpward(parachain, relaychain);
+    logger.info(`Connected relaychain '${await relaychain.api.getSystemChain()}' with parachain '${await parachain.api.getSystemChain()}'`);
+};
+export const connectParachains = async (parachains) => {
+    const list = {};
+    for (const chain of parachains) {
+        const paraId = await getParaId(chain);
+        list[paraId.toNumber()] = chain;
+    }
+    await connectHorizontal(list);
+    logger.info(`Connected parachains [${Object.keys(list)}]`);
+};

package/dist/esm/xcm/upward.js

@@ -0,0 +1,17 @@
+import { hexToU8a } from '@polkadot/util';
+import { compactHex, getParaId } from '../utils';
+export const connectUpward = async (parachain, relaychain) => {
+    const meta = await parachain.head.meta;
+    const paraId = (await getParaId(parachain)).toNumber();
+    const upwardMessagesKey = compactHex(meta.query.parachainSystem.upwardMessages());
+    await parachain.headState.subscribeStorage([upwardMessagesKey], async (_head, pairs) => {
+        const value = pairs[0][1];
+        if (!value)
+            return;
+        const meta = await relaychain.head.meta;
+        const upwardMessages = meta.registry.createType('Vec<Bytes>', hexToU8a(value));
+        if (upwardMessages.length === 0)
+            return;
+        relaychain.submitUpwardMessages(paraId, upwardMessages.map((x) => x.toHex()));
+    });
+};

package/{lib → dist/types}/genesis-provider.d.ts

@@ -26,7 +26,7 @@ export declare class GenesisProvider implements ProviderInterface {
     get blockHash(): HexString;
     getHeader: () => Promise<{
         blockHash: `0x${string}`;
-        number: number;
+        number: `0x${string}`;
         stateRoot: `0x${string}`;
         digest: {
             logs: never[];
@@ -36,7 +36,7 @@ export declare class GenesisProvider implements ProviderInterface {
         block: {
             header: {
                 blockHash: `0x${string}`;
-                number: number;
+                number: `0x${string}`;
                 stateRoot: `0x${string}`;
                 digest: {
                     logs: never[];

package/dist/types/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Chopsticks core package. A common package for usage in both server and browser.
+ * It contains a local blockchain implementation, a transaction pool, a runtime executor and more!
+ *
+ * @privateRemarks
+ * Above is the package description for `chopsticks-core` package.
+ *
+ * @packageDocumentation
+ */
+export * from './api';
+export * from './blockchain';
+export * from './blockchain/block';
+export * from './blockchain/block-builder';
+export * from './blockchain/txpool';
+export * from './blockchain/storage-layer';
+export * from './blockchain/head-state';
+export * from './utils';
+export * from './wasm-executor';
+export * from './schema';
+export * from './xcm';
+export * from './setup';
+export * from './database';
+export * from './blockchain/inherent';
+export * from './logger';
+export * from './offchain';
+export * from './chopsticks-provider';
+export * from './genesis-provider';
+export * from './rpc';

package/{lib → dist/types}/utils/index.d.ts

@@ -21,3 +21,4 @@ export declare const prefixedChildKey: (prefix: HexString, key: HexString) => st
 export declare const isPrefixedChildKey: (key: HexString) => boolean;
 export declare const splitChildKey: (key: HexString) => never[] | [`0x${string}`, `0x${string}`];
 export declare const stripChildPrefix: (key: HexString) => `0x${string}`;
+export declare const printRuntimeLogs: (logs: string[]) => void;

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@acala-network/chopsticks-core",
-  "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; yarn copyfiles",
-    "copyfiles": "cp -r src/wasm-executor/*.mjs lib/wasm-executor/",
+    "clean": "rm -rf dist",
+    "build": "yarn clean && tsc -p ./tsconfig.json && tsc -p ./tsconfig.esm.json && yarn copyfiles",
+    "copyfiles": "cp -r src/wasm-executor/*.mjs dist/cjs/wasm-executor/ && cp -r src/wasm-executor/*.mjs dist/esm/wasm-executor/",
     "docs:prep": "typedoc"
   },
   "dependencies": {
-    "@acala-network/chopsticks-executor": "0.8.5-5",
+    "@acala-network/chopsticks-executor": "0.9.0",
     "@polkadot/api": "^10.10.1",
     "@polkadot/util-crypto": "^12.5.1",
     "comlink": "^4.4.1",
@@ -25,23 +25,32 @@
     "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/esm/index.d.ts",
+      "require": "./dist/cjs/index.js",
+      "import": "./dist/esm/index.js",
+      "default": "./dist/esm/index.js"
     },
     "./package.json": "./package.json"
   },
   "browser": {
-    "./lib/wasm-executor/node-wasm-executor.mjs": "./lib/wasm-executor/browser-wasm-executor.mjs",
-    "./lib/wasm-executor/node-worker.js": "./lib/wasm-executor/browser-worker.js"
+    "./dist/cjs/wasm-executor/node-wasm-executor.mjs": "./dist/cjs/wasm-executor/browser-wasm-executor.mjs",
+    "./dist/cjs/wasm-executor/node-worker.js": "./dist/cjs/wasm-executor/browser-worker.js",
+    "./dist/esm/wasm-executor/node-wasm-executor.mjs": "./dist/esm/wasm-executor/browser-wasm-executor.mjs",
+    "./dist/esm/wasm-executor/node-worker.js": "./dist/esm/wasm-executor/browser-worker.js"
   }
 }