@acala-network/chopsticks 0.2.2 → 0.3.0

package/dist/blockchain/txpool.js

@@ -6,11 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TxPool = exports.BuildBlockMode = void 0;
 const util_1 = require("@polkadot/util");
 const lodash_1 = __importDefault(require("lodash"));
-const block_1 = require("./block");
-const shared_1 = require("../rpc/shared");
-const utils_1 = require("../utils");
-const logger_1 = require("../logger");
-const logger = logger_1.defaultLogger.child({ name: 'txpool' });
+const block_builder_1 = require("./block-builder");
+const time_travel_1 = require("../utils/time-travel");
 var BuildBlockMode;
 (function (BuildBlockMode) {
     BuildBlockMode[BuildBlockMode["Batch"] = 0] = "Batch";
@@ -21,8 +18,35 @@ const getConsensus = (header) => {
     if (header.digest.logs.length === 0)
         return;
     const preRuntime = header.digest.logs[0].asPreRuntime;
-    const [consensusEngine] = preRuntime;
-    return { consensusEngine, rest: header.digest.logs.slice(1) };
+    const [consensusEngine, slot] = preRuntime;
+    return { consensusEngine, slot, rest: header.digest.logs.slice(1) };
+};
+const getNewSlot = (digest, slotNumber) => {
+    if (digest.isPrimary) {
+        return {
+            primary: {
+                ...digest.asPrimary.toJSON(),
+                slotNumber,
+            },
+        };
+    }
+    if (digest.isSecondaryPlain) {
+        return {
+            secondaryPlain: {
+                ...digest.asSecondaryPlain.toJSON(),
+                slotNumber,
+            },
+        };
+    }
+    if (digest.isSecondaryVRF) {
+        return {
+            secondaryVRF: {
+                ...digest.asSecondaryVRF.toJSON(),
+                slotNumber,
+            },
+        };
+    }
+    return digest.toJSON();
 };
 class TxPool {
     #chain;
@@ -35,6 +59,9 @@ class TxPool {
         this.#mode = mode;
         this.#inherentProvider = inherentProvider;
     }
+    get pendingExtrinsics() {
+        return this.#pool;
+    }
     submitExtrinsic(extrinsic) {
         this.#pool.push(extrinsic);
         switch (this.#mode) {
@@ -50,29 +77,29 @@ class TxPool {
         }
     }
     #batchBuildBlock = lodash_1.default.debounce(this.buildBlock, 100, { maxWait: 1000 });
-    async buildBlock() {
+    async buildBlock(params) {
         const last = this.#lastBuildBlockPromise;
-        this.#lastBuildBlockPromise = this.#buildBlock(last);
+        this.#lastBuildBlockPromise = this.#buildBlock(last, params);
         await this.#lastBuildBlockPromise;
     }
-    async #buildBlock(wait) {
+    async #buildBlock(wait, params) {
         await this.#chain.api.isReady;
         await wait.catch(() => { }); // ignore error
         const head = this.#chain.head;
         const extrinsics = this.#pool.splice(0);
         const meta = await head.meta;
         const parentHeader = await head.header;
-        const time = this.#inherentProvider.getTimestamp(head.number + 1);
         let newLogs = parentHeader.digest.logs;
-        const expectedSlot = Math.floor(time / (meta.consts.timestamp.minimumPeriod.toNumber() * 2));
         const consensus = getConsensus(parentHeader);
         if (consensus?.consensusEngine.isAura) {
-            const newSlot = (0, util_1.compactAddLength)((0, util_1.bnToU8a)(expectedSlot, { isLe: true, bitLength: 64 }));
+            const slot = await (0, time_travel_1.getCurrentSlot)(this.#chain);
+            const newSlot = (0, util_1.compactAddLength)(meta.registry.createType('Slot', slot + 1).toU8a());
             newLogs = [{ PreRuntime: [consensus.consensusEngine, newSlot] }, ...consensus.rest];
         }
         else if (consensus?.consensusEngine.isBabe) {
-            // trying to make a SecondaryPlainPreDigest
-            const newSlot = (0, util_1.compactAddLength)((0, util_1.u8aConcat)('0x0200000000', (0, util_1.bnToU8a)(expectedSlot, { isLe: true, bitLength: 64 })));
+            const slot = await (0, time_travel_1.getCurrentSlot)(this.#chain);
+            const digest = meta.registry.createType('RawBabePreDigest', consensus.slot);
+            const newSlot = (0, util_1.compactAddLength)(meta.registry.createType('RawBabePreDigest', getNewSlot(digest, slot + 1)).toU8a());
             newLogs = [{ PreRuntime: [consensus.consensusEngine, newSlot] }, ...consensus.rest];
         }
         const registry = await head.registry;
@@ -85,72 +112,10 @@ class TxPool {
                 logs: newLogs,
             },
         });
-        const newBlock = this.#chain.newTempBlock(head, header);
-        logger.info({
-            hash: head.hash,
-            number: head.number,
-            extrinsicsCount: extrinsics.length,
-            tempHash: newBlock.hash,
-            timeValue: time,
-            expectedSlot,
-        }, 'Building block');
-        const resp = await newBlock.call('Core_initialize_block', header.toHex());
-        logger.trace(resp.storageDiff, 'Initialize block');
-        newBlock.pushStorageLayer().setAll(resp.storageDiff);
-        if (meta.query.babe?.currentSlot) {
-            // TODO: figure out how to generate a valid babe slot digest instead of just modify the data
-            // but hey, we can get it working without a valid digest
-            const key = (0, utils_1.compactHex)(meta.query.babe.currentSlot());
-            newBlock.pushStorageLayer().set(key, (0, util_1.bnToHex)(expectedSlot, { isLe: true, bitLength: 64 }));
-        }
-        const inherents = await this.#inherentProvider.createInherents(meta, time, newBlock);
-        for (const extrinsic of inherents) {
-            try {
-                const resp = await newBlock.call('BlockBuilder_apply_extrinsic', extrinsic);
-                newBlock.pushStorageLayer().setAll(resp.storageDiff);
-                logger.trace(resp.storageDiff, 'Applied inherent');
-            }
-            catch (e) {
-                logger.warn('Failed to apply inherents %o %s', e, e);
-                throw new shared_1.ResponseError(1, 'Failed to apply inherents');
-            }
-        }
-        for (const extrinsic of extrinsics) {
-            try {
-                const resp = await newBlock.call('BlockBuilder_apply_extrinsic', extrinsic);
-                newBlock.pushStorageLayer().setAll(resp.storageDiff);
-                logger.trace(resp.storageDiff, 'Applied extrinsic');
-            }
-            catch (e) {
-                logger.info('Failed to apply extrinsic %o %s', e, e);
-                this.#pool.push(extrinsic);
-            }
-        }
-        if (meta.query.paraInherent?.included) {
-            // TODO: remvoe this once paraInherent.enter is implemented
-            // we are relaychain, however as we have not yet implemented the paraInherent.enter
-            // so need to do some trick to make the on_finalize check happy
-            const paraInherentIncludedKey = (0, utils_1.compactHex)(meta.query.paraInherent.included());
-            newBlock.pushStorageLayer().set(paraInherentIncludedKey, '0x01');
-        }
-        const resp2 = await newBlock.call('BlockBuilder_finalize_block', '0x');
-        newBlock.pushStorageLayer().setAll(resp2.storageDiff);
-        logger.trace(resp2.storageDiff, 'Finalize block');
-        const blockData = registry.createType('Block', {
-            header,
-            extrinsics,
-        });
-        const finalBlock = new block_1.Block(this.#chain, newBlock.number, blockData.hash.toHex(), head, {
-            header,
-            extrinsics: [...inherents, ...extrinsics],
-            storage: head.storage,
-        });
-        const diff = await newBlock.storageDiff();
-        logger.trace(diff, 'Final block');
-        finalBlock.pushStorageLayer().setAll(diff);
-        this.#chain.unregisterBlock(newBlock);
-        this.#chain.setHead(finalBlock);
-        logger.info({ hash: finalBlock.hash, number: finalBlock.number, prevHash: newBlock.hash }, 'Block built');
+        const inherents = await this.#inherentProvider.createInherents(head, params?.inherent);
+        const [newBlock, pendingExtrinsics] = await (0, block_builder_1.buildBlock)(head, header, inherents, extrinsics);
+        this.#pool.push(...pendingExtrinsics);
+        await this.#chain.setHead(newBlock);
     }
 }
 exports.TxPool = TxPool;

package/dist/decode-key.d.ts

@@ -0,0 +1,2 @@
+import '@polkadot/types-codec';
+export declare const decodeKey: (argv: any) => Promise<void>;

package/dist/decode-key.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeKey = void 0;
+require("@polkadot/types-codec");
+const util_1 = require("@polkadot/util");
+const setup_1 = require("./setup");
+const decodeKey = async (argv) => {
+    const context = await (0, setup_1.setup)(argv);
+    const key = argv.key;
+    const meta = await context.chain.head.meta;
+    outer: for (const module of Object.values(meta.query)) {
+        for (const storage of Object.values(module)) {
+            const keyPrefix = (0, util_1.u8aToHex)(storage.keyPrefix());
+            if (key.startsWith(keyPrefix)) {
+                const decodedKey = meta.registry.createType('StorageKey', key);
+                decodedKey.setMeta(storage.meta);
+                console.log(`${storage.section}.${storage.method}`, decodedKey.args.map((x) => JSON.stringify(x.toHuman())).join(', '));
+                break outer;
+            }
+        }
+    }
+    setTimeout(() => process.exit(0), 50);
+};
+exports.decodeKey = decodeKey;

package/dist/executor.d.ts

@@ -1,5 +1,11 @@
 import { HexString } from '@polkadot/util/types';
-import { run_task } from '../executor/pkg';
+import { Block } from './blockchain/block';
+import { Registry } from '@polkadot/types-codec/types';
+interface JsCallback {
+    getStorage: (key: HexString) => Promise<string | undefined>;
+    getPrefixKeys: (key: HexString) => Promise<string[]>;
+    getNextKey: (key: HexString) => Promise<string | undefined>;
+}
 export type RuntimeVersion = {
     specName: string;
     implName: string;
@@ -11,11 +17,24 @@ export type RuntimeVersion = {
     stateVersion: number;
 };
 export declare const getRuntimeVersion: (code: HexString) => Promise<RuntimeVersion>;
-export declare const getMetadata: (code: HexString) => Promise<HexString>;
 export declare const calculateStateRoot: (entries: [HexString, HexString][]) => Promise<HexString>;
 export declare const decodeProof: (trieRootHash: HexString, keys: HexString[], nodes: HexString[]) => Promise<Record<`0x${string}`, `0x${string}` | null>>;
-export declare const createProof: (trieRootHash: HexString, nodes: HexString[], entries: [HexString, HexString][]) => Promise<{
+export declare const createProof: (trieRootHash: HexString, nodes: HexString[], entries: [HexString, HexString | null][]) => Promise<{
     trieRootHash: `0x${string}`;
     nodes: `0x${string}`[];
 }>;
-export { run_task as runTask };
+export declare const runTask: (task: {
+    wasm: HexString;
+    calls: [string, HexString][];
+    storage: [HexString, HexString | null][];
+    mockSignatureHost: boolean;
+    allowUnresolvedImports: boolean;
+}, callback?: JsCallback) => Promise<any>;
+export declare const taskHandler: (block: Block) => JsCallback;
+export declare const emptyTaskHandler: {
+    getStorage: (_key: HexString) => Promise<never>;
+    getPrefixKeys: (_key: HexString) => Promise<never>;
+    getNextKey: (_key: HexString) => Promise<never>;
+};
+export declare const getAuraSlotDuration: ((wasm: HexString, registry: Registry) => Promise<number>) & import("lodash").MemoizedFunction;
+export {};

package/dist/executor.js

@@ -1,26 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runTask = exports.createProof = exports.decodeProof = exports.calculateStateRoot = exports.getMetadata = exports.getRuntimeVersion = void 0;
+exports.getAuraSlotDuration = exports.emptyTaskHandler = exports.taskHandler = exports.runTask = exports.createProof = exports.decodeProof = exports.calculateStateRoot = exports.getRuntimeVersion = void 0;
 const ws_1 = require("ws");
 const util_1 = require("@polkadot/util");
 global.WebSocket = ws_1.WebSocket;
-const pkg_1 = require("../executor/pkg");
-Object.defineProperty(exports, "runTask", { enumerable: true, get: function () { return pkg_1.run_task; } });
-const utils_1 = require("./utils");
+const chopsticks_executor_1 = require("@acala-network/chopsticks-executor");
+const logger_1 = require("./logger");
+const lodash_1 = require("lodash");
+const logger = logger_1.defaultLogger.child({ name: 'executor' });
 const getRuntimeVersion = async (code) => {
-    return (0, pkg_1.get_runtime_version)(code).then((version) => {
+    return (0, chopsticks_executor_1.get_runtime_version)(code).then((version) => {
         version.specName = (0, util_1.hexToString)(version.specName);
         version.implName = (0, util_1.hexToString)(version.implName);
         return version;
     });
 };
 exports.getRuntimeVersion = getRuntimeVersion;
-const getMetadata = async (code) => {
-    return (0, utils_1.compactHex)((0, util_1.hexToU8a)(await (0, pkg_1.get_metadata)(code)));
-};
-exports.getMetadata = getMetadata;
 const calculateStateRoot = async (entries) => {
-    return (0, pkg_1.calculate_state_root)(entries);
+    return (0, chopsticks_executor_1.calculate_state_root)(entries);
 };
 exports.calculateStateRoot = calculateStateRoot;
 const nodesAddLength = (nodes) => {
@@ -28,7 +25,7 @@ const nodesAddLength = (nodes) => {
     return (0, util_1.u8aToHex)((0, util_1.u8aConcatStrict)([(0, util_1.compactToU8a)(nodesWithLength.length), (0, util_1.u8aConcat)(...nodesWithLength)]));
 };
 const decodeProof = async (trieRootHash, keys, nodes) => {
-    const decoded = await (0, pkg_1.decode_proof)(trieRootHash, keys, nodesAddLength(nodes));
+    const decoded = await (0, chopsticks_executor_1.decode_proof)(trieRootHash, keys, nodesAddLength(nodes));
     return decoded.reduce((accum, [key, value]) => {
         accum[key] = value;
         return accum;
@@ -36,7 +33,58 @@ const decodeProof = async (trieRootHash, keys, nodes) => {
 };
 exports.decodeProof = decodeProof;
 const createProof = async (trieRootHash, nodes, entries) => {
-    const result = await (0, pkg_1.create_proof)(trieRootHash, nodesAddLength(nodes), entries);
+    const result = await (0, chopsticks_executor_1.create_proof)(trieRootHash, nodesAddLength(nodes), entries);
     return { trieRootHash: result[0], nodes: result[1] };
 };
 exports.createProof = createProof;
+const runTask = async (task, callback = exports.emptyTaskHandler) => {
+    logger.trace({ task: { ...task, wasm: (0, logger_1.truncate)(task.wasm) } }, 'taskRun');
+    const response = await (0, chopsticks_executor_1.run_task)(task, callback);
+    if (response.Call) {
+        logger.trace({ result: (0, logger_1.truncate)(response.Call.result), storageDiff: (0, logger_1.truncateStorageDiff)(response.Call.storageDiff) }, 'taskResponse');
+    }
+    else {
+        logger.trace({ response }, 'taskResponse');
+    }
+    return response;
+};
+exports.runTask = runTask;
+const taskHandler = (block) => {
+    return {
+        getStorage: async function (key) {
+            return block.get(key);
+        },
+        getPrefixKeys: async function (key) {
+            return block.getKeysPaged({ prefix: key, pageSize: 1000, startKey: key });
+        },
+        getNextKey: async function (key) {
+            const keys = await block.getKeysPaged({ prefix: key, pageSize: 1, startKey: key });
+            return keys[0];
+        },
+    };
+};
+exports.taskHandler = taskHandler;
+exports.emptyTaskHandler = {
+    getStorage: async function (_key) {
+        throw new Error('Method not implemented');
+    },
+    getPrefixKeys: async function (_key) {
+        throw new Error('Method not implemented');
+    },
+    getNextKey: async function (_key) {
+        throw new Error('Method not implemented');
+    },
+};
+exports.getAuraSlotDuration = (0, lodash_1.memoize)(async (wasm, registry) => {
+    const result = await (0, exports.runTask)({
+        wasm,
+        calls: [['AuraApi_slot_duration', '0x']],
+        storage: [],
+        mockSignatureHost: false,
+        allowUnresolvedImports: false,
+    });
+    if (!result.Call)
+        throw new Error(result.Error);
+    const slotDuration = registry.createType('u64', (0, util_1.hexToU8a)(result.Call.result)).toNumber();
+    return slotDuration;
+});

package/dist/executor.test.js

@@ -3,38 +3,29 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const metadata_1 = require("@polkadot/types/metadata");
 const types_1 = require("@polkadot/types");
-const decorate_1 = require("@polkadot/types/metadata/decorate");
 const vitest_1 = require("vitest");
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
 const proof_1 = require("./utils/proof");
 const executor_1 = require("./executor");
+const getCode = () => {
+    const code = String((0, node_fs_1.readFileSync)(node_path_1.default.join(__dirname, '../e2e/blobs/acala-runtime-2101.txt'))).trim();
+    (0, vitest_1.expect)(code.length).toBeGreaterThan(2);
+    return code;
+};
 (0, vitest_1.describe)('wasm', () => {
-    (0, vitest_1.it)('get metadata from wasm runtime', async () => {
-        const code = String((0, node_fs_1.readFileSync)(node_path_1.default.join(__dirname, 'runtime.example'))).trim();
-        (0, vitest_1.expect)(code.length).toBeGreaterThan(2);
-        const registry = new types_1.TypeRegistry();
-        const metadata = new metadata_1.Metadata(registry, await (0, executor_1.getMetadata)(code));
-        registry.setMetadata(metadata);
-        (0, vitest_1.expect)(registry.metadata.pallets.length).toBeGreaterThan(0);
-        const storage = (0, decorate_1.decorateStorage)(registry, metadata.asLatest, metadata.version);
-        (0, vitest_1.expect)(storage.system).toBeTruthy;
-    });
     (0, vitest_1.it)('get runtime version from wasm runtime', async () => {
-        const code = String((0, node_fs_1.readFileSync)(node_path_1.default.join(__dirname, 'runtime.example'))).trim();
-        (0, vitest_1.expect)(code.length).toBeGreaterThan(2);
         const expectedRuntimeVersion = {
             specName: 'acala',
             implName: 'acala',
             authoringVersion: 1,
-            specVersion: 2000,
+            specVersion: 2101,
             implVersion: 0,
             apis: [
-                ['0xdf6acb689907609b', 3],
+                ['0xdf6acb689907609b', 4],
                 ['0x37e397fc7c91f5e4', 1],
-                ['0x40fe3ad401f8959a', 5],
+                ['0x40fe3ad401f8959a', 6],
                 ['0xd2bc9897eed08f15', 3],
                 ['0xf78b278be53f454c', 2],
                 ['0xdd718d5cc53262d4', 1],
@@ -42,14 +33,14 @@ const executor_1 = require("./executor");
                 ['0xbc9d89904f5b923f', 1],
                 ['0x37c8bb1350a9a2a8', 1],
                 ['0x6ef953004ba30e59', 1],
-                ['0xf485c9145d3f0aad', 1],
-                ['0xe3df3f2aa8a5cc57', 1],
-                ['0xea93e3f16f3d6962', 1],
+                ['0x955e168e0cfb3409', 1],
+                ['0xe3df3f2aa8a5cc57', 2],
+                ['0xea93e3f16f3d6962', 2],
             ],
             transactionVersion: 1,
             stateVersion: 0,
         };
-        (0, vitest_1.expect)(await (0, executor_1.getRuntimeVersion)(code)).toMatchObject(expectedRuntimeVersion);
+        (0, vitest_1.expect)(await (0, executor_1.getRuntimeVersion)(getCode())).toMatchObject(expectedRuntimeVersion);
     });
     (0, vitest_1.it)('calculate state root', async () => {
         const a = await (0, executor_1.calculateStateRoot)([['0x5301bf5ff0298f5c7b93a446709f8e885f772afdd0d8ba3d4d559a06f0742f12', '0x01']]);
@@ -140,4 +131,8 @@ const executor_1 = require("./executor");
         (0, vitest_1.expect)(decoded).toMatchSnapshot();
         (0, vitest_1.expect)(decoded[upgradeKey]).toBe('0x01');
     });
+    (0, vitest_1.it)('get aura slot duration', async () => {
+        const slotDuration = await (0, executor_1.getAuraSlotDuration)(getCode(), new types_1.TypeRegistry());
+        (0, vitest_1.expect)(slotDuration).eq(12000);
+    });
 });

package/dist/genesis-provider.d.ts

@@ -36,6 +36,11 @@ export declare class GenesisProvider implements ProviderInterface {
             extrinsics: never[];
         };
     }>;
+    get _jsCallback(): {
+        getStorage: (key: HexString) => Promise<string>;
+        getNextKey: (_key: HexString) => Promise<string>;
+        getPrefixKeys: (_key: HexString) => Promise<never[]>;
+    };
     send: (method: string, params: unknown[], _isCacheable?: boolean) => Promise<any>;
     subscribe: (_type: string, _method: string, _params: unknown[], _cb: ProviderInterfaceCallback) => Promise<number | string>;
     unsubscribe: (_type: string, _method: string, _id: number | string) => Promise<boolean>;

package/dist/genesis-provider.js

@@ -30,7 +30,6 @@ class GenesisProvider {
             });
             this.#eventemitter.once('error', reject);
         });
-        this.connect();
     }
     static fromUrl = async (url) => {
         let isUrl = false;
@@ -103,6 +102,20 @@ class GenesisProvider {
             },
         };
     };
+    get _jsCallback() {
+        const storage = this.#genesis.genesis.raw.top;
+        return {
+            getStorage: async function (key) {
+                return storage[key];
+            },
+            getNextKey: async function (_key) {
+                return '0x';
+            },
+            getPrefixKeys: async function (_key) {
+                return [];
+            },
+        };
+    }
     send = async (method, params, _isCacheable) => {
         await this.isReady;
         switch (method) {
@@ -114,7 +127,13 @@ class GenesisProvider {
                 return this.#genesis.name;
             case 'state_getMetadata': {
                 const code = this.#genesis.genesis.raw.top[(0, util_1.stringToHex)(':code')];
-                return (0, executor_1.getMetadata)(code);
+                return (0, executor_1.runTask)({
+                    wasm: code,
+                    calls: [['Metadata_metadata', '0x']],
+                    storage: [],
+                    mockSignatureHost: false,
+                    allowUnresolvedImports: true,
+                }, this._jsCallback);
             }
             case 'chain_getHeader':
                 return this.getHeader();

package/dist/index.d.ts

@@ -1,21 +1 @@
-import '@polkadot/types-codec';
-import { ProviderInterface } from '@polkadot/rpc-provider/types';
-import { Api } from './api';
-import { Blockchain } from './blockchain';
-import { Config } from './schema';
-import { TaskManager } from './task';
-export declare const setup: (argv: Config) => Promise<{
-    chain: Blockchain;
-    api: Api;
-    ws: ProviderInterface;
-    tasks: TaskManager;
-}>;
-export declare const setupWithServer: (argv: Config) => Promise<{
-    close: () => Promise<void>;
-    chain: Blockchain;
-    api: Api;
-    ws: ProviderInterface;
-    tasks: TaskManager;
-}>;
-export declare const runBlock: (argv: Config) => Promise<void>;
-export declare const decodeKey: (argv: any) => Promise<void>;
+export {};