@acala-network/chopsticks 0.7.2 → 0.8.0-0

package/lib/schema/index.js

@@ -1,32 +1,59 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.configSchema = exports.genesisSchema = void 0;
-const txpool_1 = require("../blockchain/txpool");
+exports.fetchConfig = exports.configSchema = void 0;
+const chopsticks_core_1 = require("@acala-network/chopsticks-core");
+const node_path_1 = require("node:path");
+const node_fs_1 = require("node:fs");
 const zod_1 = require("zod");
-exports.genesisSchema = zod_1.z.object({
-    id: zod_1.z.string(),
-    name: zod_1.z.string(),
-    properties: zod_1.z.object({
-        ss58Format: zod_1.z.number().optional(),
-        tokenDecimals: zod_1.z.union([zod_1.z.number(), zod_1.z.array(zod_1.z.number())]).optional(),
-        tokenSymbol: zod_1.z.union([zod_1.z.string(), zod_1.z.array(zod_1.z.string())]).optional(),
-    }),
-    genesis: zod_1.z.object({ raw: zod_1.z.object({ top: zod_1.z.record(zod_1.z.string()) }) }),
-});
+const lodash_1 = __importDefault(require("lodash"));
+const axios_1 = __importDefault(require("axios"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
 exports.configSchema = zod_1.z
     .object({
     port: zod_1.z.number().optional(),
     endpoint: zod_1.z.string().optional(),
     block: zod_1.z.union([zod_1.z.string().length(66).startsWith('0x'), zod_1.z.number(), zod_1.z.null()]).optional(),
-    'build-block-mode': zod_1.z.nativeEnum(txpool_1.BuildBlockMode).optional(),
+    'build-block-mode': zod_1.z.nativeEnum(chopsticks_core_1.BuildBlockMode).optional(),
     'import-storage': zod_1.z.any().optional(),
     'mock-signature-host': zod_1.z.boolean().optional(),
+    'max-memory-block-count': zod_1.z.number().optional(),
     db: zod_1.z.string().optional(),
     'wasm-override': zod_1.z.string().optional(),
-    genesis: zod_1.z.union([zod_1.z.string(), exports.genesisSchema]).optional(),
+    genesis: zod_1.z.union([zod_1.z.string(), chopsticks_core_1.genesisSchema]).optional(),
     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();
+const CONFIGS_BASE_URL = 'https://raw.githubusercontent.com/AcalaNetwork/chopsticks/master/configs/';
+const fetchConfig = async (path) => {
+    let file;
+    if ((0, chopsticks_core_1.isUrl)(path)) {
+        file = await axios_1.default.get(path).then((x) => x.data);
+    }
+    else {
+        try {
+            file = (0, node_fs_1.readFileSync)(path, 'utf8');
+        }
+        catch (err) {
+            if ((0, node_path_1.basename)(path) === path && ['', '.yml', '.yaml', '.json'].includes((0, node_path_1.extname)(path))) {
+                if ((0, node_path_1.extname)(path) === '') {
+                    path += '.yml';
+                }
+                const url = CONFIGS_BASE_URL + path;
+                chopsticks_core_1.defaultLogger.info(`Loading config file ${url}`);
+                file = await axios_1.default.get(url).then((x) => x.data);
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    const config = js_yaml_1.default.load(lodash_1.default.template(file, { variable: 'env' })(process.env));
+    return exports.configSchema.parse(config);
+};
+exports.fetchConfig = fetchConfig;

package/lib/server.js

@@ -25,6 +25,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createServer = void 0;
 const ws_1 = __importStar(require("ws"));
+const shared_1 = require("./rpc/shared");
 const logger_1 = require("./logger");
 const logger = logger_1.defaultLogger.child({ name: 'ws' });
 const parseRequest = (request) => {
@@ -145,7 +146,7 @@ const createServer = async (handler, port) => {
                 send({
                     id: req.id,
                     jsonrpc: '2.0',
-                    error: e,
+                    error: e instanceof shared_1.ResponseError ? e : { code: -32603, message: `Internal ${e}` },
                 });
             }
         });

package/lib/setup-with-server.d.ts

@@ -2,7 +2,5 @@ import { Config } from './schema';
 export declare const setupWithServer: (argv: Config) => Promise<{
     close: () => Promise<void>;
     listenPort: number;
-    chain: import("./blockchain").Blockchain;
-    api: import("./api").Api;
-    ws: import("@polkadot/rpc-provider/types").ProviderInterface;
+    chain: import("@acala-network/chopsticks-core").Blockchain;
 }>;

package/lib/setup-with-server.js

@@ -4,9 +4,9 @@ exports.setupWithServer = void 0;
 const server_1 = require("./server");
 const rpc_1 = require("./rpc");
 const shared_1 = require("./rpc/shared");
-const setup_1 = require("./setup");
+const context_1 = require("./context");
 const setupWithServer = async (argv) => {
-    const context = await (0, setup_1.setup)(argv);
+    const context = await (0, context_1.setupContext)(argv);
     const port = argv.port ?? 8000;
     if (argv.genesis) {
         // mine 1st block when starting from genesis to set some mock validation data

package/lib/utils/decoder.d.ts

@@ -1,5 +1,5 @@
 import '@polkadot/types-codec';
-import { Block } from '../blockchain/block';
+import { Block } from '@acala-network/chopsticks-core';
 import { DecoratedMeta } from '@polkadot/types/metadata/decorate/types';
 import { HexString } from '@polkadot/util/types';
 import { StorageEntry } from '@polkadot/types/primitive/types';

package/lib/utils/generate-html-diff.d.ts

@@ -1,4 +1,4 @@
-import { Block } from '../blockchain/block';
+import { Block } from '@acala-network/chopsticks-core';
 import { HexString } from '@polkadot/util/types';
 export declare const generateHtmlDiff: (block: Block, diff: [HexString, HexString | null][]) => Promise<string>;
 export declare const generateHtmlDiffPreviewFile: (block: Block, diff: [HexString, HexString | null][], filename: string) => Promise<string>;

package/lib/utils/override.d.ts

@@ -0,0 +1,4 @@
+import { Blockchain, StorageValues } from '@acala-network/chopsticks-core';
+import { HexString } from '@polkadot/util/types';
+export declare const overrideStorage: (chain: Blockchain, storage?: string | StorageValues, at?: HexString) => Promise<void>;
+export declare const overrideWasm: (chain: Blockchain, wasmPath?: string, at?: HexString) => Promise<void>;

package/lib/utils/{import-storage.js → override.js}

@@ -3,12 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.overrideWasm = exports.importStorage = void 0;
+exports.overrideWasm = exports.overrideStorage = void 0;
+const chopsticks_core_1 = require("@acala-network/chopsticks-core");
 const node_fs_1 = require("node:fs");
 const js_yaml_1 = __importDefault(require("js-yaml"));
-const set_storage_1 = require("./set-storage");
 const logger_1 = require("../logger");
-const importStorage = async (chain, storage, at) => {
+const overrideStorage = async (chain, storage, at) => {
     if (storage == null) {
         return;
     }
@@ -21,10 +21,10 @@ const importStorage = async (chain, storage, at) => {
     else {
         storageValue = storage;
     }
-    const blockHash = await (0, set_storage_1.setStorage)(chain, storageValue, at);
-    logger_1.defaultLogger.trace({ blockHash, storage }, 'ImportStorage');
+    const blockHash = await (0, chopsticks_core_1.setStorage)(chain, storageValue, at);
+    logger_1.defaultLogger.trace({ blockHash, storage }, 'OverrideStorage');
 };
-exports.importStorage = importStorage;
+exports.overrideStorage = overrideStorage;
 const overrideWasm = async (chain, wasmPath, at) => {
     if (wasmPath == null) {
         return;

package/package.json

@@ -1,34 +1,30 @@
 {
   "name": "@acala-network/chopsticks",
-  "version": "0.7.2",
+  "version": "0.8.0-0",
   "author": "Bryan Chen <xlchen1291@gmail.com>",
   "license": "Apache-2.0",
   "bin": "./chopsticks.js",
   "scripts": {
     "clean": "rm -rf lib tsconfig.tsbuildinfo",
     "build": "tsc -p ./tsconfig.json",
-    "script:start": "cd ../..; ts-node --transpile-only packages/chopsticks/src/cli.ts",
-    "script:run": "cd ../..; LOG_LEVEL=trace ts-node-dev --transpile-only --inspect --notify=false packages/chopsticks/src/cli.ts -- --config=configs/dev.yml",
-    "dev:karura": "cd ../..; ts-node-dev --transpile-only --inspect --notify=false packages/chopsticks/src/cli.ts -- --config=configs/karura.yml",
-    "dev:acala": "cd ../..; ts-node-dev --transpile-only --inspect --notify=false packages/chopsticks/src/cli.ts -- --config=configs/acala.yml",
-    "dev:polkadot": "cd ../..; ts-node-dev --transpile-only --inspect --notify=false packages/chopsticks/src/cli.ts -- --config=configs/polkadot.yml",
-    "dev:moonriver": "cd ../..; ts-node-dev --transpile-only --inspect --notify=false packages/chopsticks/src/cli.ts -- --config=configs/moonriver.yml",
-    "dev:moonbeam": "cd ../..; ts-node-dev --transpile-only --inspect --notify=false packages/chopsticks/src/cli.ts -- --config=configs/moonbeam.yml"
+    "script:start": "cd ../..; ts-node --transpile-only -r tsconfig-paths/register packages/chopsticks/src/cli.ts",
+    "script:run": "cd ../..; LOG_LEVEL=trace ts-node-dev --transpile-only -r tsconfig-paths/register --inspect --notify=false packages/chopsticks/src/cli.ts -- --config=configs/dev.yml",
+    "dev:karura": "cd ../..; ts-node-dev --transpile-only --inspect -r tsconfig-paths/register --notify=false packages/chopsticks/src/cli.ts -- --config=configs/karura.yml",
+    "dev:acala": "cd ../..; ts-node-dev --transpile-only --inspect -r tsconfig-paths/register --notify=false packages/chopsticks/src/cli.ts -- --config=configs/acala.yml",
+    "dev:polkadot": "cd ../..; ts-node-dev --transpile-only --inspect -r tsconfig-paths/register --notify=false packages/chopsticks/src/cli.ts -- --config=configs/polkadot.yml",
+    "dev:moonriver": "cd ../..; ts-node-dev --transpile-only --inspect -r tsconfig-paths/register --notify=false packages/chopsticks/src/cli.ts -- --config=configs/moonriver.yml",
+    "dev:moonbeam": "cd ../..; ts-node-dev --transpile-only --inspect -r tsconfig-paths/register --notify=false packages/chopsticks/src/cli.ts -- --config=configs/moonbeam.yml"
   },
   "dependencies": {
-    "@acala-network/chopsticks-executor": "0.7.2",
+    "@acala-network/chopsticks-core": "0.8.0-0",
     "@pnpm/npm-conf": "^2.2.2",
     "@polkadot/api": "^10.9.1",
     "axios": "^1.4.0",
+    "dotenv": "^16.3.1",
     "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.1",
-    "reflect-metadata": "^0.1.13",
-    "sqlite3": "^5.1.6",
-    "typeorm": "^0.3.17",
     "ws": "^8.13.0",
     "yargs": "^17.7.2",
     "zod": "^3.21.4"
@@ -37,7 +33,7 @@
     "@types/global-agent": "^2.1.1",
     "@types/js-yaml": "^4.0.5",
     "@types/lodash": "^4.14.195",
-    "@types/node": "^20.4.2",
+    "@types/node": "^20.4.5",
     "@types/ws": "^8.5.5",
     "@types/yargs": "^17.0.24",
     "ts-node": "^10.9.1",
@@ -61,5 +57,6 @@
       "default": "./lib/*.js"
     },
     "./package.json": "./package.json"
-  }
+  },
+  "stableVersion": "0.7.3"
 }

package/lib/api.d.ts

@@ -1,43 +0,0 @@
-import { ExtDef } from '@polkadot/types/extrinsic/signedExtensions/types';
-import { HexString } from '@polkadot/util/types';
-import { ProviderInterface } from '@polkadot/rpc-provider/types';
-type ChainProperties = {
-    ss58Format?: number;
-    tokenDecimals?: number[];
-    tokenSymbol?: string[];
-};
-type Header = {
-    parentHash: HexString;
-    number: HexString;
-    stateRoot: HexString;
-    extrinsicsRoot: HexString;
-    digest: {
-        logs: HexString[];
-    };
-};
-type SignedBlock = {
-    block: {
-        header: Header;
-        extrinsics: HexString[];
-    };
-    justifications?: HexString[];
-};
-export declare class Api {
-    #private;
-    readonly signedExtensions: ExtDef;
-    constructor(provider: ProviderInterface, signedExtensions?: ExtDef);
-    disconnect(): Promise<void>;
-    get isReady(): Promise<void> | undefined;
-    get chain(): Promise<string>;
-    get chainProperties(): Promise<ChainProperties>;
-    getSystemName(): Promise<string>;
-    getSystemProperties(): Promise<ChainProperties>;
-    getSystemChain(): Promise<string>;
-    getMetadata(hash?: string): Promise<string>;
-    getBlockHash(blockNumber?: number): Promise<`0x${string}`>;
-    getHeader(hash?: string): Promise<Header>;
-    getBlock(hash?: string): Promise<SignedBlock>;
-    getStorage(key: string, hash?: string): Promise<string>;
-    getKeysPaged(prefix: string, pageSize: number, startKey: string, hash?: string): Promise<string[]>;
-}
-export {};

package/lib/api.js

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Api = void 0;
-class Api {
-    #provider;
-    #ready;
-    #chain;
-    #chainProperties;
-    signedExtensions;
-    constructor(provider, signedExtensions) {
-        this.#provider = provider;
-        this.signedExtensions = signedExtensions || {};
-    }
-    async disconnect() {
-        return this.#provider.disconnect();
-    }
-    get isReady() {
-        if (!this.#ready) {
-            if (this.#provider['isReady']) {
-                this.#ready = this.#provider['isReady'];
-            }
-            else {
-                this.#ready = new Promise((resolve) => {
-                    this.#provider.on('connected', () => {
-                        resolve();
-                    });
-                    this.#provider.connect();
-                });
-            }
-        }
-        return this.#ready;
-    }
-    get chain() {
-        if (!this.#chain) {
-            this.#chain = this.getSystemChain();
-        }
-        return this.#chain;
-    }
-    get chainProperties() {
-        if (!this.#chainProperties) {
-            this.#chainProperties = this.getSystemProperties();
-        }
-        return this.#chainProperties;
-    }
-    async getSystemName() {
-        return this.#provider.send('system_name', []);
-    }
-    async getSystemProperties() {
-        return this.#provider.send('system_properties', []);
-    }
-    async getSystemChain() {
-        return this.#provider.send('system_chain', []);
-    }
-    async getMetadata(hash) {
-        return this.#provider.send('state_getMetadata', hash ? [hash] : []);
-    }
-    async getBlockHash(blockNumber) {
-        return this.#provider.send('chain_getBlockHash', Number.isInteger(blockNumber) ? [blockNumber] : []);
-    }
-    async getHeader(hash) {
-        return this.#provider.send('chain_getHeader', hash ? [hash] : []);
-    }
-    async getBlock(hash) {
-        return this.#provider.send('chain_getBlock', hash ? [hash] : []);
-    }
-    async getStorage(key, hash) {
-        if (hash) {
-            return this.#provider.send('state_getStorageAt', [key, hash]);
-        }
-        return this.#provider.send('state_getStorage', [key]);
-    }
-    async getKeysPaged(prefix, pageSize, startKey, hash) {
-        if (hash) {
-            return this.#provider.send('state_getKeysPagedAt', [prefix, pageSize, startKey, hash]);
-        }
-        return this.#provider.send('state_getKeysPaged', [prefix, pageSize, startKey]);
-    }
-}
-exports.Api = Api;

package/lib/blockchain/block-builder.d.ts

@@ -1,10 +0,0 @@
-import { Header, TransactionValidityError } from '@polkadot/types/interfaces';
-import { Block, TaskCallResponse } from './block';
-import { HexString } from '@polkadot/util/types';
-export declare const newHeader: (head: Block) => Promise<Header>;
-export declare const buildBlock: (head: Block, inherents: HexString[], extrinsics: HexString[], ump: Record<number, HexString[]>, onApplyExtrinsicError: (extrinsic: HexString, error: TransactionValidityError) => void) => Promise<[Block, HexString[]]>;
-export declare const dryRunExtrinsic: (head: Block, inherents: HexString[], extrinsic: HexString | {
-    call: HexString;
-    address: string;
-}) => Promise<TaskCallResponse>;
-export declare const dryRunInherents: (head: Block, inherents: HexString[]) => Promise<[HexString, HexString | null][]>;

package/lib/blockchain/block-builder.js

@@ -1,297 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dryRunInherents = exports.dryRunExtrinsic = exports.buildBlock = exports.newHeader = void 0;
-const block_1 = require("./block");
-const storage_layer_1 = require("./storage-layer");
-const util_1 = require("@polkadot/util");
-const utils_1 = require("../utils");
-const logger_1 = require("../logger");
-const time_travel_1 = require("../utils/time-travel");
-const logger = logger_1.defaultLogger.child({ name: 'block-builder' });
-const getConsensus = (header) => {
-    if (header.digest.logs.length === 0)
-        return;
-    const preRuntime = header.digest.logs[0].asPreRuntime;
-    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();
-};
-const newHeader = async (head) => {
-    const meta = await head.meta;
-    const parentHeader = await head.header;
-    let newLogs = parentHeader.digest.logs;
-    const consensus = getConsensus(parentHeader);
-    if (consensus?.consensusEngine.isAura) {
-        const slot = await (0, time_travel_1.getCurrentSlot)(head.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) {
-        const slot = await (0, time_travel_1.getCurrentSlot)(head.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];
-    }
-    else if (consensus?.consensusEngine?.toString() == 'nmbs') {
-        const nmbsKey = (0, util_1.stringToHex)('nmbs');
-        newLogs = [
-            {
-                // Using previous block author
-                PreRuntime: [
-                    consensus.consensusEngine,
-                    parentHeader.digest.logs
-                        .find((log) => log.isPreRuntime && log.asPreRuntime[0].toHex() == nmbsKey)
-                        ?.asPreRuntime[1].toHex(),
-                ],
-            },
-            ...consensus.rest,
-        ];
-        if (meta.query.randomness) {
-            // TODO: shouldn't modify existing head
-            // reset notFirstBlock so randomness will skip validation
-            head.pushStorageLayer().set((0, utils_1.compactHex)(meta.query.randomness.notFirstBlock()), "Deleted" /* StorageValueKind.Deleted */);
-        }
-    }
-    const header = meta.registry.createType('Header', {
-        parentHash: head.hash,
-        number: head.number + 1,
-        stateRoot: '0x0000000000000000000000000000000000000000000000000000000000000000',
-        extrinsicsRoot: '0x0000000000000000000000000000000000000000000000000000000000000000',
-        digest: {
-            logs: newLogs,
-        },
-    });
-    return header;
-};
-exports.newHeader = newHeader;
-const initNewBlock = async (head, header, inherents, storageLayer) => {
-    const blockNumber = header.number.toNumber();
-    const hash = `0x${Math.round(Math.random() * 100000000)
-        .toString(16)
-        .padEnd(64, '0')}`;
-    const newBlock = new block_1.Block(head.chain, blockNumber, hash, head, {
-        header,
-        extrinsics: [],
-        storage: storageLayer ?? head.storage,
-    });
-    {
-        // initialize block
-        const { storageDiff } = await newBlock.call('Core_initialize_block', [header.toHex()]);
-        newBlock.pushStorageLayer().setAll(storageDiff);
-        logger.trace((0, logger_1.truncate)(storageDiff), 'Initialize block');
-    }
-    const layers = [];
-    // apply inherents
-    for (const extrinsic of inherents) {
-        try {
-            const { storageDiff } = await newBlock.call('BlockBuilder_apply_extrinsic', [extrinsic]);
-            const layer = newBlock.pushStorageLayer();
-            layer.setAll(storageDiff);
-            layers.push(layer);
-            logger.trace((0, logger_1.truncate)(storageDiff), 'Applied inherent');
-        }
-        catch (e) {
-            logger.warn('Failed to apply inherents %o %s', e, e);
-            throw new Error('Failed to apply inherents');
-        }
-    }
-    return {
-        block: newBlock,
-        layers: layers,
-    };
-};
-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 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');
-        }
-        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);
-    const pendingExtrinsics = [];
-    const includedExtrinsic = [];
-    // apply extrinsics
-    for (const extrinsic of extrinsics) {
-        try {
-            const { result, storageDiff } = await newBlock.call('BlockBuilder_apply_extrinsic', [extrinsic]);
-            const outcome = registry.createType('ApplyExtrinsicResult', result);
-            if (outcome.isErr) {
-                onApplyExtrinsicError(extrinsic, outcome.asErr);
-                continue;
-            }
-            newBlock.pushStorageLayer().setAll(storageDiff);
-            logger.trace((0, logger_1.truncate)(storageDiff), 'Applied extrinsic');
-            includedExtrinsic.push(extrinsic);
-        }
-        catch (e) {
-            logger.info('Failed to apply extrinsic %o %s', e, e);
-            pendingExtrinsics.push(extrinsic);
-        }
-    }
-    {
-        // finalize block
-        const { storageDiff } = await newBlock.call('BlockBuilder_finalize_block', []);
-        newBlock.pushStorageLayer().setAll(storageDiff);
-        logger.trace((0, logger_1.truncate)(storageDiff), 'Finalize block');
-    }
-    const blockData = registry.createType('Block', {
-        header,
-        extrinsics: includedExtrinsic,
-    });
-    const storageDiff = await newBlock.storageDiff();
-    logger.trace(Object.entries(storageDiff).map(([key, value]) => [key, (0, logger_1.truncate)(value)]), 'Final block');
-    const finalBlock = new block_1.Block(head.chain, newBlock.number, blockData.hash.toHex(), head, {
-        header,
-        extrinsics: [...inherents, ...includedExtrinsic],
-        storage: head.storage,
-        storageDiff,
-    });
-    logger.info({
-        number: newBlock.number,
-        hash: finalBlock.hash,
-        extrinsics: (0, logger_1.truncate)(includedExtrinsic),
-        pendingExtrinsicsCount: pendingExtrinsics.length,
-        ump: (0, logger_1.truncate)(ump),
-    }, 'Block built');
-    return [finalBlock, pendingExtrinsics];
-};
-exports.buildBlock = buildBlock;
-const dryRunExtrinsic = async (head, inherents, extrinsic) => {
-    const registry = await head.registry;
-    const header = await (0, exports.newHeader)(head);
-    const { block: newBlock } = await initNewBlock(head, header, inherents);
-    if (typeof extrinsic !== 'string') {
-        if (!head.chain.mockSignatureHost) {
-            throw new Error('Cannot fake signature because mock signature host is not enabled. Start chain with `mockSignatureHost: true`');
-        }
-        const meta = await head.meta;
-        const call = registry.createType('Call', (0, util_1.hexToU8a)(extrinsic.call));
-        const generic = registry.createType('GenericExtrinsic', call);
-        const accountRaw = await head.get((0, utils_1.compactHex)(meta.query.system.account(extrinsic.address)));
-        const account = registry.createType('AccountInfo', (0, util_1.hexToU8a)(accountRaw));
-        generic.signFake(extrinsic.address, {
-            blockHash: head.hash,
-            genesisHash: head.hash,
-            runtimeVersion: await head.runtimeVersion,
-            nonce: account.nonce,
-        });
-        const mockSignature = new Uint8Array(64);
-        mockSignature.fill(0xcd);
-        mockSignature.set([0xde, 0xad, 0xbe, 0xef]);
-        generic.signature.set(mockSignature);
-        logger_1.defaultLogger.info({ call: call.toHuman() }, 'dry_run_call');
-        return newBlock.call('BlockBuilder_apply_extrinsic', [generic.toHex()]);
-    }
-    logger_1.defaultLogger.info({ call: registry.createType('GenericExtrinsic', (0, util_1.hexToU8a)(extrinsic)).toHuman() }, 'dry_run_extrinsic');
-    return newBlock.call('BlockBuilder_apply_extrinsic', [extrinsic]);
-};
-exports.dryRunExtrinsic = dryRunExtrinsic;
-const dryRunInherents = async (head, inherents) => {
-    const header = await (0, exports.newHeader)(head);
-    const { layers } = await initNewBlock(head, header, inherents);
-    const stoarge = {};
-    for (const layer of layers) {
-        await layer.mergeInto(stoarge);
-    }
-    return Object.entries(stoarge);
-};
-exports.dryRunInherents = dryRunInherents;