@acala-network/chopsticks 0.6.5 → 0.7.0

package/lib/blockchain/block-builder.js

@@ -129,34 +129,84 @@ const initNewBlock = async (head, header, inherents, storageLayer) => {
 const buildBlock = async (head, inherents, extrinsics, ump, onApplyExtrinsicError) => {
     const registry = await head.registry;
     const header = await (0, exports.newHeader)(head);
+    logger.info({
+        number: head.number + 1,
+        extrinsicsCount: extrinsics.length,
+        umpCount: Object.keys(ump).length,
+    }, `Try building block #${(head.number + 1).toLocaleString()}`);
     let layer;
     // apply ump via storage override hack
     if (Object.keys(ump).length > 0) {
         const meta = await head.meta;
         layer = new storage_layer_1.StorageLayer(head.storage);
         for (const [paraId, upwardMessages] of Object.entries(ump)) {
-            const queueSize = meta.registry.createType('(u32, u32)', [
-                upwardMessages.length,
-                upwardMessages.map((x) => x.length).reduce((s, i) => s + i, 0),
-            ]);
-            const messages = meta.registry.createType('Vec<Bytes>', upwardMessages);
-            // TODO: make sure we append instead of replace
-            layer.setAll([
-                [(0, utils_1.compactHex)(meta.query.ump.relayDispatchQueues(paraId)), messages.toHex()],
-                [(0, utils_1.compactHex)(meta.query.ump.relayDispatchQueueSize(paraId)), queueSize.toHex()],
-            ]);
+            const upwardMessagesU8a = upwardMessages.map((x) => (0, util_1.hexToU8a)(x));
+            const messagesCount = upwardMessages.length;
+            const messagesSize = upwardMessagesU8a.map((x) => x.length).reduce((s, i) => s + i, 0);
+            if (meta.query.ump) {
+                const queueSize = meta.registry.createType('(u32, u32)', [messagesCount, messagesSize]);
+                const messages = meta.registry.createType('Vec<Bytes>', upwardMessages);
+                // TODO: make sure we append instead of replace
+                layer.setAll([
+                    [(0, utils_1.compactHex)(meta.query.ump.relayDispatchQueues(paraId)), messages.toHex()],
+                    [(0, utils_1.compactHex)(meta.query.ump.relayDispatchQueueSize(paraId)), queueSize.toHex()],
+                ]);
+            }
+            else if (meta.query.messageQueue) {
+                // TODO: make sure we append instead of replace
+                const origin = { ump: { para: paraId } };
+                let last = 0;
+                let heap = new Uint8Array(0);
+                for (const message of upwardMessagesU8a) {
+                    const payloadLen = message.length;
+                    const header = meta.registry.createType('(u32, bool)', [payloadLen, false]);
+                    last = heap.length;
+                    heap = (0, util_1.u8aConcat)(heap, header.toU8a(), message);
+                }
+                layer.setAll([
+                    [
+                        (0, utils_1.compactHex)(meta.query.messageQueue.bookStateFor(origin)),
+                        meta.registry
+                            .createType('PalletMessageQueueBookState', {
+                            begin: 0,
+                            end: 1,
+                            count: 1,
+                            readyNeighbours: { prev: origin, next: origin },
+                            messageCount: messagesCount,
+                            size_: messagesSize,
+                        })
+                            .toHex(),
+                    ],
+                    [
+                        (0, utils_1.compactHex)(meta.query.messageQueue.serviceHead(origin)),
+                        meta.registry.createType('PolkadotRuntimeParachainsInclusionAggregateMessageOrigin', origin).toHex(),
+                    ],
+                    [
+                        (0, utils_1.compactHex)(meta.query.messageQueue.pages(origin, 0)),
+                        meta.registry
+                            .createType('PalletMessageQueuePage', {
+                            remaining: messagesCount,
+                            remaining_size: messagesSize,
+                            first_index: 0,
+                            first: 0,
+                            last,
+                            heap: (0, util_1.compactAddLength)(heap),
+                        })
+                            .toHex(),
+                    ],
+                ]);
+            }
+            else {
+                throw new Error('Unknown ump storage');
+            }
             logger.trace({ paraId, upwardMessages: (0, logger_1.truncate)(upwardMessages) }, 'Pushed UMP');
         }
-        const needsDispatch = meta.registry.createType('Vec<u32>', Object.keys(ump));
-        layer.set((0, utils_1.compactHex)(meta.query.ump.needsDispatch()), needsDispatch.toHex());
+        if (meta.query.ump) {
+            const needsDispatch = meta.registry.createType('Vec<u32>', Object.keys(ump));
+            layer.set((0, utils_1.compactHex)(meta.query.ump.needsDispatch()), needsDispatch.toHex());
+        }
     }
     const { block: newBlock } = await initNewBlock(head, header, inherents, layer);
-    logger.info({
-        number: newBlock.number,
-        extrinsicsCount: extrinsics.length,
-        umpCount: Object.keys(ump).length,
-        tempHash: newBlock.hash,
-    }, `Try building block #${newBlock.number.toLocaleString()}`);
     const pendingExtrinsics = [];
     const includedExtrinsic = [];
     // apply extrinsics

package/lib/blockchain/block.d.ts

@@ -8,6 +8,7 @@ import type { RuntimeVersion } from '../executor';
 export type TaskCallResponse = {
     result: HexString;
     storageDiff: [HexString, HexString | null][];
+    offchainStorageDiff: [HexString, HexString | null][];
     runtimeLogs: string[];
 };
 export declare class Block {
@@ -40,5 +41,5 @@ export declare class Block {
     get runtimeVersion(): Promise<RuntimeVersion>;
     get metadata(): Promise<HexString>;
     get meta(): Promise<DecoratedMeta>;
-    call(method: string, args: HexString[], storage?: [HexString, HexString | null][]): Promise<TaskCallResponse>;
+    call(method: string, args: HexString[]): Promise<TaskCallResponse>;
 }

package/lib/blockchain/block.js

@@ -165,12 +165,11 @@ class Block {
         }
         return this.#meta;
     }
-    async call(method, args, storage = []) {
+    async call(method, args) {
         const wasm = await this.wasm;
         const response = await (0, executor_1.runTask)({
             wasm,
             calls: [[method, args]],
-            storage,
             mockSignatureHost: this.#chain.mockSignatureHost,
             allowUnresolvedImports: this.#chain.allowUnresolvedImports,
             runtimeLogLevel: this.#chain.runtimeLogLevel,
@@ -179,6 +178,12 @@ class Block {
             for (const log of response.Call.runtimeLogs) {
                 logger_1.defaultLogger.info(`RuntimeLogs:\n${log}`);
             }
+            if (this.chain.offchainWorker) {
+                // apply offchain storage
+                for (const [key, value] of response.Call.offchainStorageDiff) {
+                    this.chain.offchainWorker.set(key, value);
+                }
+            }
             return response.Call;
         }
         if (response.Error)

package/lib/blockchain/index.d.ts

@@ -2,11 +2,13 @@ import { ApplyExtrinsicResult } from '@polkadot/types/interfaces';
 import { DataSource } from 'typeorm';
 import { HexString } from '@polkadot/util/types';
 import { RegisteredTypes } from '@polkadot/types/types';
+import type { TransactionValidity } from '@polkadot/types/interfaces/txqueue';
 import { Api } from '../api';
 import { Block } from './block';
 import { BuildBlockMode, BuildBlockParams, DownwardMessage, HorizontalMessage, TxPool } from './txpool';
 import { HeadState } from './head-state';
 import { InherentProvider } from './inherent';
+import { OffchainWorker } from '../offchain';
 export interface Options {
     api: Api;
     buildBlockMode?: BuildBlockMode;
@@ -20,6 +22,7 @@ export interface Options {
     allowUnresolvedImports?: boolean;
     runtimeLogLevel?: number;
     registeredTypes: RegisteredTypes;
+    offchainWorker?: boolean;
 }
 export declare class Blockchain {
     #private;
@@ -31,7 +34,8 @@ export declare class Blockchain {
     readonly runtimeLogLevel: number;
     readonly registeredTypes: RegisteredTypes;
     readonly headState: HeadState;
-    constructor({ api, buildBlockMode, inherentProvider, db, header, mockSignatureHost, allowUnresolvedImports, runtimeLogLevel, registeredTypes, }: Options);
+    readonly offchainWorker: OffchainWorker | undefined;
+    constructor({ api, buildBlockMode, inherentProvider, db, header, mockSignatureHost, allowUnresolvedImports, runtimeLogLevel, registeredTypes, offchainWorker, }: Options);
     get head(): Block;
     get txPool(): TxPool;
     getBlockAt(number?: number): Promise<Block | undefined>;
@@ -39,6 +43,7 @@ export declare class Blockchain {
     unregisterBlock(block: Block): void;
     setHead(block: Block): Promise<void>;
     submitExtrinsic(extrinsic: HexString): Promise<HexString>;
+    validateExtrinsic(extrinsic: HexString, source?: '0x00' | '0x01' | '0x02' /** External */): Promise<TransactionValidity>;
     submitUpwardMessages(id: number, ump: HexString[]): void;
     submitDownwardMessages(dmp: DownwardMessage[]): void;
     submitHorizontalMessages(id: number, hrmp: HorizontalMessage[]): void;

package/lib/blockchain/index.js

@@ -6,6 +6,7 @@ const util_1 = require("@polkadot/util");
 const block_1 = require("./block");
 const txpool_1 = require("./txpool");
 const head_state_1 = require("./head-state");
+const offchain_1 = require("../offchain");
 const utils_1 = require("../utils");
 const logger_1 = require("../logger");
 const block_builder_1 = require("./block-builder");
@@ -25,7 +26,8 @@ class Blockchain {
     #blocksByHash = {};
     #loadingBlocks = {};
     headState;
-    constructor({ api, buildBlockMode, inherentProvider, db, header, mockSignatureHost = false, allowUnresolvedImports = false, runtimeLogLevel = 0, registeredTypes = {}, }) {
+    offchainWorker;
+    constructor({ api, buildBlockMode, inherentProvider, db, header, mockSignatureHost = false, allowUnresolvedImports = false, runtimeLogLevel = 0, registeredTypes = {}, offchainWorker = false, }) {
         this.api = api;
         this.db = db;
         this.mockSignatureHost = mockSignatureHost;
@@ -37,6 +39,9 @@ class Blockchain {
         this.#txpool = new txpool_1.TxPool(this, inherentProvider, buildBlockMode);
         this.#inherentProvider = inherentProvider;
         this.headState = new head_state_1.HeadState(this.#head);
+        if (offchainWorker) {
+            this.offchainWorker = new offchain_1.OffchainWorker();
+        }
     }
     #registerBlock(block) {
         this.#blocksByNumber[block.number] = block;
@@ -107,19 +112,24 @@ class Blockchain {
         this.#head = block;
         this.#registerBlock(block);
         await this.headState.setHead(block);
+        if (this.offchainWorker) {
+            await this.offchainWorker.run(block);
+        }
     }
     async submitExtrinsic(extrinsic) {
-        const source = '0x02'; // External
-        const args = (0, util_1.u8aToHex)((0, util_1.u8aConcat)(source, extrinsic, this.head.hash));
-        const res = await this.head.call('TaggedTransactionQueue_validate_transaction', [args]);
-        const registry = await this.head.registry;
-        const validity = registry.createType('TransactionValidity', res.result);
+        const validity = await this.validateExtrinsic(extrinsic);
         if (validity.isOk) {
             await this.#txpool.submitExtrinsic(extrinsic);
             return (0, util_crypto_1.blake2AsHex)(extrinsic, 256);
         }
         throw validity.asErr;
     }
+    async validateExtrinsic(extrinsic, source = '0x02' /** External */) {
+        const args = (0, util_1.u8aToHex)((0, util_1.u8aConcat)(source, extrinsic, this.head.hash));
+        const res = await this.head.call('TaggedTransactionQueue_validate_transaction', [args]);
+        const registry = await this.head.registry;
+        return registry.createType('TransactionValidity', res.result);
+    }
     submitUpwardMessages(id, ump) {
         this.#txpool.submitUpwardMessages(id, ump);
         logger.debug({ id, ump }, 'submitUpwardMessages');

package/lib/blockchain/inherent/parachain/validation-data.js

@@ -150,7 +150,7 @@ class SetValidationData {
                 // make sure previous goAhead is removed
                 newEntries.push([upgradeKey, null]);
             }
-            const { trieRootHash, nodes } = await (0, executor_1.createProof)(extrinsic.validationData.relayParentStorageRoot, extrinsic.relayChainState.trieNodes, newEntries);
+            const { trieRootHash, nodes } = await (0, executor_1.createProof)(extrinsic.relayChainState.trieNodes, newEntries);
             newData = {
                 ...extrinsic,
                 downwardMessages,

package/lib/blockchain/txpool.js

@@ -16,7 +16,7 @@ var BuildBlockMode;
     BuildBlockMode[BuildBlockMode["Batch"] = 0] = "Batch";
     BuildBlockMode[BuildBlockMode["Instant"] = 1] = "Instant";
     BuildBlockMode[BuildBlockMode["Manual"] = 2] = "Manual";
-})(BuildBlockMode = exports.BuildBlockMode || (exports.BuildBlockMode = {}));
+})(BuildBlockMode || (exports.BuildBlockMode = BuildBlockMode = {}));
 class TxPool {
     #chain;
     #pool = [];
@@ -157,8 +157,8 @@ class TxPool {
         }
         finally {
             this.#isBuilding = false;
-            this.#buildBlockIfNeeded();
         }
+        this.#buildBlockIfNeeded();
     }
     async #buildBlock() {
         await this.#chain.api.isReady;

package/lib/cli.js

@@ -4,11 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_path_1 = require("node:path");
+const dotenv_1 = require("dotenv");
 const helpers_1 = require("yargs/helpers");
 const node_fs_1 = require("node:fs");
 const lodash_1 = __importDefault(require("lodash"));
 const axios_1 = __importDefault(require("axios"));
-const dotenv_1 = __importDefault(require("dotenv"));
 const js_yaml_1 = __importDefault(require("js-yaml"));
 const yargs_1 = __importDefault(require("yargs"));
 const _1 = require(".");
@@ -20,7 +20,7 @@ const utils_1 = require("./utils");
 const shared_1 = require("./rpc/shared");
 const run_block_1 = require("./run-block");
 const try_runtime_1 = require("./try-runtime");
-dotenv_1.default.config();
+(0, dotenv_1.config)();
 const CONFIGS_BASE_URL = 'https://raw.githubusercontent.com/AcalaNetwork/chopsticks/master/configs/';
 const processConfig = async (path) => {
     let file;
@@ -80,6 +80,10 @@ const defaultOptions = {
         desc: 'Runtime maximum log level [off = 0; error = 1; warn = 2; info = 3; debug = 4; trace = 5]',
         number: true,
     },
+    'offchain-worker': {
+        desc: 'Enable offchain worker',
+        boolean: true,
+    },
 };
 const mockOptions = {
     'import-storage': {

package/lib/db/entities.js

@@ -11,7 +11,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KeyValuePair = void 0;
 const typeorm_1 = require("typeorm");
-let KeyValuePair = class KeyValuePair {
+let KeyValuePair = exports.KeyValuePair = class KeyValuePair {
     blockHash;
     key;
     value;
@@ -28,7 +28,6 @@ __decorate([
     (0, typeorm_1.Column)({ nullable: true }),
     __metadata("design:type", String)
 ], KeyValuePair.prototype, "value", void 0);
-KeyValuePair = __decorate([
+exports.KeyValuePair = KeyValuePair = __decorate([
     (0, typeorm_1.Entity)()
 ], KeyValuePair);
-exports.KeyValuePair = KeyValuePair;

package/lib/dry-run-preimage.js

@@ -64,7 +64,6 @@ const dryRunPreimage = async (argv) => {
     const result = await (0, executor_1.runTask)({
         wasm: await block.wasm,
         calls,
-        storage: [],
         mockSignatureHost: false,
         allowUnresolvedImports: false,
         runtimeLogLevel: argv['runtime-log-level'] || 0,

package/lib/executor.d.ts

@@ -1,12 +1,8 @@
 import { HexString } from '@polkadot/util/types';
 import { Block } from './blockchain/block';
+import { JsCallback } from '@acala-network/chopsticks-executor';
 import { Registry } from '@polkadot/types-codec/types';
 import _ from 'lodash';
-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;
@@ -20,14 +16,13 @@ export type RuntimeVersion = {
 export declare const getRuntimeVersion: (code: HexString) => Promise<RuntimeVersion>;
 export declare const calculateStateRoot: (entries: [HexString, HexString][], trie_version: number) => 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 | null][]) => Promise<{
+export declare const createProof: (nodes: HexString[], entries: [HexString, HexString | null][]) => Promise<{
     trieRootHash: `0x${string}`;
     nodes: `0x${string}`[];
 }>;
 export declare const runTask: (task: {
     wasm: HexString;
     calls: [string, HexString[]][];
-    storage: [HexString, HexString | null][];
     mockSignatureHost: boolean;
     allowUnresolvedImports: boolean;
     runtimeLogLevel: number;
@@ -35,8 +30,11 @@ export declare const runTask: (task: {
 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>;
+    getStateRoot: () => Promise<never>;
+    getNextKey: (_prefix: HexString, _key: HexString) => Promise<never>;
+    offchainGetStorage: (_key: HexString) => Promise<never>;
+    offchainTimestamp: () => Promise<never>;
+    offchainRandomSeed: () => Promise<never>;
+    offchainSubmitTransaction: (_tx: HexString) => Promise<never>;
 };
 export declare const getAuraSlotDuration: ((wasm: HexString, registry: Registry) => Promise<number>) & _.MemoizedFunction;
-export {};

package/lib/executor.js

@@ -5,8 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAuraSlotDuration = exports.emptyTaskHandler = exports.taskHandler = exports.runTask = exports.createProof = exports.decodeProof = exports.calculateStateRoot = exports.getRuntimeVersion = void 0;
 const util_1 = require("@polkadot/util");
-const key_cache_1 = require("./utils/key-cache");
+const util_crypto_1 = require("@polkadot/util-crypto");
 const chopsticks_executor_1 = require("@acala-network/chopsticks-executor");
+const key_cache_1 = require("./utils/key-cache");
 const logger_1 = require("./logger");
 const lodash_1 = __importDefault(require("lodash"));
 const logger = logger_1.defaultLogger.child({ name: 'executor' });
@@ -31,14 +32,14 @@ const decodeProof = async (trieRootHash, keys, nodes) => {
     }, {});
 };
 exports.decodeProof = decodeProof;
-const createProof = async (trieRootHash, nodes, entries) => {
-    const result = await (0, chopsticks_executor_1.create_proof)(trieRootHash, nodes, entries);
+const createProof = async (nodes, entries) => {
+    const result = await (0, chopsticks_executor_1.create_proof)(nodes, entries);
     return { trieRootHash: result[0], nodes: result[1] };
 };
 exports.createProof = createProof;
 const runTask = async (task, callback = exports.emptyTaskHandler) => {
     logger.trace((0, logger_1.truncate)(task), 'taskRun');
-    const response = await (0, chopsticks_executor_1.run_task)(task, callback);
+    const response = await (0, chopsticks_executor_1.run_task)(task, callback, process.env.RUST_LOG);
     if (response.Call) {
         logger.trace((0, logger_1.truncate)(response.Call), 'taskResponse');
     }
@@ -49,25 +50,46 @@ const runTask = async (task, callback = exports.emptyTaskHandler) => {
 };
 exports.runTask = runTask;
 const taskHandler = (block) => {
-    const batchSize = 1000;
     return {
         getStorage: async function (key) {
             return block.get(key);
         },
-        getPrefixKeys: async function (key) {
-            let keys = [];
-            let startKey = key;
-            while (startKey) {
-                const batch = await block.getKeysPaged({ prefix: key.slice(0, key_cache_1.PREFIX_LENGTH), pageSize: batchSize, startKey });
-                keys = keys.concat(batch);
-                startKey = batch[batchSize - 1];
-            }
-            return keys;
+        getStateRoot: async function () {
+            const header = await block.header;
+            return header.stateRoot.toHex();
         },
-        getNextKey: async function (key) {
-            const [nextKey] = await block.getKeysPaged({ prefix: key.slice(0, key_cache_1.PREFIX_LENGTH), pageSize: 1, startKey: key });
+        getNextKey: async function (prefix, key) {
+            const [nextKey] = await block.getKeysPaged({
+                prefix: prefix.length === 2 /** 0x */ ? key.slice(0, key_cache_1.PREFIX_LENGTH) : prefix,
+                pageSize: 1,
+                startKey: key,
+            });
             return 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 (0, util_crypto_1.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;
+            }
+        },
     };
 };
 exports.taskHandler = taskHandler;
@@ -75,10 +97,22 @@ exports.emptyTaskHandler = {
     getStorage: async function (_key) {
         throw new Error('Method not implemented');
     },
-    getPrefixKeys: async function (_key) {
+    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');
     },
-    getNextKey: async function (_key) {
+    offchainSubmitTransaction: async function (_tx) {
         throw new Error('Method not implemented');
     },
 };
@@ -86,7 +120,6 @@ exports.getAuraSlotDuration = lodash_1.default.memoize(async (wasm, registry) =>
     const result = await (0, exports.runTask)({
         wasm,
         calls: [['AuraApi_slot_duration', []]],
-        storage: [],
         mockSignatureHost: false,
         allowUnresolvedImports: false,
         runtimeLogLevel: 0,

package/lib/genesis-provider.d.ts

@@ -1,4 +1,5 @@
 import { HexString } from '@polkadot/util/types';
+import { JsCallback } from '@acala-network/chopsticks-executor';
 import { ProviderInterface, ProviderInterfaceCallback, ProviderInterfaceEmitCb, ProviderInterfaceEmitted, ProviderStats } from '@polkadot/rpc-provider/types';
 import { Genesis } from './schema';
 export declare class GenesisProvider implements ProviderInterface {
@@ -36,11 +37,7 @@ 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[]>;
-    };
+    get _jsCallback(): JsCallback;
     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/lib/genesis-provider.js

@@ -99,14 +99,15 @@ class GenesisProvider {
     get _jsCallback() {
         const storage = this.#genesis.genesis.raw.top;
         return {
+            ...executor_1.emptyTaskHandler,
             getStorage: async function (key) {
                 return storage[key];
             },
-            getNextKey: async function (_key) {
-                return '0x';
+            getStateRoot: async function () {
+                return '0x49416764844ff0d8bad851e8abe686dff9dd2de78621180ef8e9f99bb7a480f1';
             },
-            getPrefixKeys: async function (_key) {
-                return [];
+            getNextKey: async function (_prefix, _key) {
+                return undefined;
             },
         };
     }
@@ -124,7 +125,6 @@ class GenesisProvider {
                 return (0, executor_1.runTask)({
                     wasm: code,
                     calls: [['Metadata_metadata', []]],
-                    storage: [],
                     mockSignatureHost: false,
                     allowUnresolvedImports: true,
                     runtimeLogLevel: 0,

package/lib/offchain.d.ts

@@ -0,0 +1,10 @@
+import { Block } from './blockchain/block';
+import { HexString } from '@polkadot/util/types';
+export declare class OffchainWorker {
+    readonly pendingExtrinsics: HexString[];
+    readonly offchainStorage: Map<string, string | null | undefined>;
+    get(key: string): string | null | undefined;
+    set(key: string, value: string | null | undefined): void;
+    run(block: Block): Promise<void>;
+    pushExtrinsic(block: Block, extrinsic: HexString): Promise<`0x${string}`>;
+}

package/lib/offchain.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OffchainWorker = void 0;
+const util_crypto_1 = require("@polkadot/util-crypto");
+const shared_1 = require("./rpc/shared");
+const rxjs_1 = require("rxjs");
+class OffchainWorker {
+    pendingExtrinsics = [];
+    offchainStorage = new Map();
+    get(key) {
+        return this.offchainStorage.get(key);
+    }
+    set(key, value) {
+        this.offchainStorage.set(key, value);
+    }
+    async run(block) {
+        shared_1.logger.info({ number: block.number, hash: block.hash }, `Run Offchain Worker for block #${block.number.toLocaleString()}`);
+        const header = await block.header;
+        await block.call('OffchainWorkerApi_offchain_worker', [header.toHex()]);
+        shared_1.logger.info(`Offchain Worker complete for block #${block.number.toLocaleString()}`);
+        const txs = this.pendingExtrinsics.splice(0);
+        if (txs.length > 0) {
+            rxjs_1.queueScheduler.schedule(async (transactions) => {
+                await block.chain.txPool.buildBlock({ transactions });
+            }, 100, txs);
+        }
+    }
+    async pushExtrinsic(block, extrinsic) {
+        const validity = await block.chain.validateExtrinsic(extrinsic, '0x01');
+        if (validity.isOk) {
+            this.pendingExtrinsics.push(extrinsic);
+            return (0, util_crypto_1.blake2AsHex)(extrinsic, 256);
+        }
+        throw validity.asErr;
+    }
+}
+exports.OffchainWorker = OffchainWorker;

package/lib/run-block.js

@@ -10,11 +10,11 @@ const setup_1 = require("./setup");
 const runBlock = async (argv) => {
     const context = await (0, setup_1.setup)(argv, true);
     const header = await context.chain.head.header;
-    const wasm = await context.chain.head.wasm;
     const block = context.chain.head;
     const parent = await block.parentBlock;
     if (!parent)
         throw Error('cant find parent block');
+    const wasm = await parent.wasm;
     const calls = [['Core_initialize_block', [header.toHex()]]];
     for (const extrinsic of await block.extrinsics) {
         calls.push(['BlockBuilder_apply_extrinsic', [extrinsic]]);
@@ -23,7 +23,6 @@ const runBlock = async (argv) => {
     const result = await (0, executor_1.runTask)({
         wasm,
         calls,
-        storage: [],
         mockSignatureHost: false,
         allowUnresolvedImports: false,
         runtimeLogLevel: argv['runtime-log-level'] || 0,

package/lib/schema/index.d.ts

@@ -133,6 +133,7 @@ export declare const configSchema: z.ZodObject<{
     timestamp: z.ZodOptional<z.ZodNumber>;
     'registered-types': z.ZodOptional<z.ZodAny>;
     'runtime-log-level': z.ZodOptional<z.ZodNumber>;
+    'offchain-worker': z.ZodOptional<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
     port?: number | undefined;
     endpoint?: string | undefined;
@@ -159,6 +160,7 @@ export declare const configSchema: z.ZodObject<{
     timestamp?: number | undefined;
     'registered-types'?: any;
     'runtime-log-level'?: number | undefined;
+    'offchain-worker'?: boolean | undefined;
 }, {
     port?: number | undefined;
     endpoint?: string | undefined;
@@ -185,5 +187,6 @@ export declare const configSchema: z.ZodObject<{
     timestamp?: number | undefined;
     'registered-types'?: any;
     'runtime-log-level'?: number | undefined;
+    'offchain-worker'?: boolean | undefined;
 }>;
 export type Config = z.infer<typeof configSchema>;

package/lib/schema/index.js

@@ -27,5 +27,6 @@ exports.configSchema = zod_1.z
     timestamp: zod_1.z.number().optional(),
     'registered-types': zod_1.z.any().optional(),
     'runtime-log-level': zod_1.z.number().min(0).max(5).optional(),
+    'offchain-worker': zod_1.z.boolean().optional(),
 })
     .strict();

package/lib/setup.d.ts

@@ -1,3 +1,4 @@
+import './utils/tunnel';
 import '@polkadot/types-codec';
 import { ProviderInterface } from '@polkadot/rpc-provider/types';
 import { Api } from './api';

package/lib/setup.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setup = void 0;
+require("./utils/tunnel");
 require("@polkadot/types-codec");
 const api_1 = require("@polkadot/api");
 const api_2 = require("./api");
@@ -64,6 +65,7 @@ const setup = async (argv, runBlock = false) => {
         allowUnresolvedImports: argv['allow-unresolved-imports'],
         runtimeLogLevel: argv['runtime-log-level'],
         registeredTypes: argv['registered-types'],
+        offchainWorker: argv['offchain-worker'],
     });
     if (argv.timestamp)
         await (0, time_travel_1.timeTravel)(chain, argv.timestamp);

package/lib/try-runtime.js

@@ -17,7 +17,7 @@ const tryRuntime = async (argv) => {
         },
     });
     const select_none = registry.createType('UpgradeCheckSelect', 'None');
-    const result = await block.call('TryRuntime_on_runtime_upgrade', [select_none.toHex()], []);
+    const result = await block.call('TryRuntime_on_runtime_upgrade', [select_none.toHex()]);
     if (argv['html']) {
         const filePath = await (0, generate_html_diff_1.generateHtmlDiffPreviewFile)(block, result.storageDiff, block.hash);
         console.log(`Generated preview ${filePath}`);

package/lib/utils/tunnel.d.ts

@@ -0,0 +1 @@
+import 'global-agent/bootstrap';

package/lib/utils/tunnel.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("global-agent/bootstrap");
+const npm_conf_1 = __importDefault(require("@pnpm/npm-conf"));
+const npmConfig = (0, npm_conf_1.default)().config;
+global.GLOBAL_AGENT.HTTP_PROXY =
+    process.env.HTTP_PROXY ||
+        process.env.http_proxy ||
+        process.env.HTTPS_PROXY ||
+        process.env.https_proxy ||
+        npmConfig.get('proxy') ||
+        npmConfig.get('https-proxy') ||
+        global.GLOBAL_AGENT.HTTP_PROXY;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acala-network/chopsticks",
-  "version": "0.6.5",
+  "version": "0.7.0",
   "author": "Bryan Chen <xlchen1291@gmail.com>",
   "license": "Apache-2.0",
   "bin": "./chopsticks.js",
@@ -16,30 +16,33 @@
     "dev:moonbeam": "cd ../..; ts-node-dev --transpile-only --inspect --notify=false packages/chopsticks/src/cli.ts -- --config=configs/moonbeam.yml"
   },
   "dependencies": {
-    "@acala-network/chopsticks-executor": "0.6.5",
-    "@polkadot/api": "^10.7.2",
+    "@acala-network/chopsticks-executor": "0.7.0",
+    "@pnpm/npm-conf": "^2.2.2",
+    "@polkadot/api": "^10.9.1",
     "axios": "^1.4.0",
+    "global-agent": "^3.0.0",
     "js-yaml": "^4.1.0",
     "jsondiffpatch": "^0.4.1",
     "lodash": "^4.17.21",
     "pino": "^8.14.1",
-    "pino-pretty": "^10.0.0",
+    "pino-pretty": "^10.0.1",
     "reflect-metadata": "^0.1.13",
     "sqlite3": "^5.1.6",
-    "typeorm": "^0.3.16",
+    "typeorm": "^0.3.17",
     "ws": "^8.13.0",
     "yargs": "^17.7.2",
     "zod": "^3.21.4"
   },
   "devDependencies": {
+    "@types/global-agent": "^2.1.1",
     "@types/js-yaml": "^4.0.5",
-    "@types/lodash": "^4.14.194",
-    "@types/node": "^20.2.3",
-    "@types/ws": "^8.5.4",
+    "@types/lodash": "^4.14.195",
+    "@types/node": "^20.4.2",
+    "@types/ws": "^8.5.5",
     "@types/yargs": "^17.0.24",
     "ts-node": "^10.9.1",
     "ts-node-dev": "^2.0.0",
-    "typescript": "^5.0.4"
+    "typescript": "^5.1.6"
   },
   "files": [
     "lib",

package/template/diff.html

@@ -1,4 +1,4 @@
-<!DOCTYPE html>
+<!doctype html>
 <html>
 	<head>
 		<style>