@acala-network/chopsticks 0.8.5-4 → 0.8.5-6

package/chopsticks.js

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-require('./lib/cli.js')
+require('./dist/cjs/cli.js')

package/{lib → dist/cjs}/plugins/dry-run/dry-run-preimage.js

@@ -69,9 +69,7 @@ const dryRunPreimage = async (argv) => {
     if ('Error' in result) {
         throw new Error(result.Error);
     }
-    for (const logs of result.Call.runtimeLogs) {
-        logger_1.defaultLogger.info(`RuntimeLogs:\n${logs}`);
-    }
+    (0, chopsticks_core_1.printRuntimeLogs)(result.Call.runtimeLogs);
     const filePath = await (0, generate_html_diff_1.generateHtmlDiffPreviewFile)(block, result.Call.storageDiff, hash);
     console.log(`Generated preview ${filePath}`);
     if (argv['open']) {

package/{lib → dist/cjs}/plugins/run-block/index.js

@@ -8,7 +8,6 @@ const node_fs_1 = require("node:fs");
 const zod_1 = require("zod");
 const lodash_1 = __importDefault(require("lodash"));
 const chopsticks_core_1 = require("@acala-network/chopsticks-core");
-const logger_1 = require("../../logger");
 const cli_options_1 = require("../../cli-options");
 const generate_html_diff_1 = require("../../utils/generate-html-diff");
 const open_html_1 = require("../../utils/open-html");
@@ -50,9 +49,7 @@ const cli = (y) => {
         if ('Error' in result) {
             throw new Error(result.Error);
         }
-        for (const logs of result.Call.runtimeLogs) {
-            logger_1.defaultLogger.info(`RuntimeLogs:\n${logs}`);
-        }
+        (0, chopsticks_core_1.printRuntimeLogs)(result.Call.runtimeLogs);
         if (argv.html) {
             const filePath = await (0, generate_html_diff_1.generateHtmlDiffPreviewFile)(parent, result.Call.storageDiff, block.hash);
             console.log(`Generated preview ${filePath}`);

package/{lib → dist/cjs}/utils/generate-html-diff.js

@@ -10,7 +10,7 @@ const lodash_1 = require("lodash");
 const node_path_1 = __importDefault(require("node:path"));
 const generateHtmlDiff = async (block, diff) => {
     const { oldState, delta } = await (0, decoder_1.decodeStorageDiff)(block, diff);
-    const htmlTemplate = (0, node_fs_1.readFileSync)(node_path_1.default.join(__dirname, '../../template/diff.html'), 'utf-8');
+    const htmlTemplate = (0, node_fs_1.readFileSync)(node_path_1.default.join(__dirname, '../../../template/diff.html'), 'utf-8');
     return (0, lodash_1.template)(htmlTemplate)({ left: JSON.stringify(oldState), delta: JSON.stringify(delta) });
 };
 exports.generateHtmlDiff = generateHtmlDiff;

package/dist/esm/cli-options.js

@@ -0,0 +1,40 @@
+export const defaultOptions = {
+    endpoint: {
+        desc: 'Endpoint to connect to',
+        string: true,
+    },
+    block: {
+        desc: 'Block hash or block number. Default to latest block',
+        string: true,
+    },
+    'wasm-override': {
+        desc: 'Path to wasm override',
+        string: true,
+    },
+    db: {
+        desc: 'Path to database',
+        string: true,
+    },
+    config: {
+        desc: 'Path to config file with default options',
+        string: true,
+    },
+    'runtime-log-level': {
+        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,
+    },
+};
+export const mockOptions = {
+    'import-storage': {
+        desc: 'Pre-defined JSON/YAML storage file path',
+        string: true,
+    },
+    'mock-signature-host': {
+        desc: 'Mock signature host so any signature starts with 0xdeadbeef and filled by 0xcd is considered valid',
+        boolean: true,
+    },
+};

package/dist/esm/cli.js

@@ -0,0 +1,90 @@
+import { config as dotenvConfig } from 'dotenv';
+import { hideBin } from 'yargs/helpers';
+import _ from 'lodash';
+import yargs from 'yargs';
+import { BuildBlockMode, connectParachains, connectVertical } from '@acala-network/chopsticks-core';
+import { fetchConfig } from './schema';
+import { defaultOptions, mockOptions } from './cli-options';
+import { pluginExtendCli } from './plugins';
+import { setupWithServer } from '.';
+dotenvConfig();
+const processArgv = async (argv) => {
+    if (argv.config) {
+        Object.assign(argv, _.defaults(argv, await fetchConfig(argv.config)));
+    }
+    argv.port = argv.port ?? (process.env.PORT ? Number(process.env.PORT) : 8000);
+};
+const commands = yargs(hideBin(process.argv))
+    .scriptName('chopsticks')
+    .middleware(processArgv, false)
+    .command('*', 'Dev mode, fork off a chain', (yargs) => yargs.options({
+    ...defaultOptions,
+    ...mockOptions,
+    port: {
+        desc: 'Port to listen on',
+        number: true,
+    },
+    'build-block-mode': {
+        desc: 'Build block mode. Default to Batch',
+        enum: [BuildBlockMode.Batch, BuildBlockMode.Manual, BuildBlockMode.Instant],
+    },
+    'allow-unresolved-imports': {
+        desc: 'Allow wasm unresolved imports',
+        boolean: true,
+    },
+    'max-memory-block-count': {
+        desc: 'Max memory block count',
+        number: true,
+    },
+    resume: {
+        desc: `Resume from the specified block hash or block number in db.
+                 If true, it will resume from the latest block in db.
+                 Note this will override the block option`,
+        string: true,
+    },
+}), async (argv) => {
+    await setupWithServer(argv);
+})
+    .command('xcm', 'XCM setup with relaychain and parachains', (yargs) => yargs
+    .options({
+    relaychain: {
+        desc: 'Relaychain config file path',
+        string: true,
+    },
+    parachain: {
+        desc: 'Parachain config file path',
+        type: 'array',
+        string: true,
+        required: true,
+    },
+})
+    .alias('relaychain', 'r')
+    .alias('parachain', 'p'), async (argv) => {
+    const parachains = [];
+    for (const config of argv.parachain) {
+        const { chain } = await setupWithServer(await fetchConfig(config));
+        parachains.push(chain);
+    }
+    if (parachains.length > 1) {
+        await connectParachains(parachains);
+    }
+    if (argv.relaychain) {
+        const { chain: relaychain } = await setupWithServer(await fetchConfig(argv.relaychain));
+        for (const parachain of parachains) {
+            await connectVertical(relaychain, parachain);
+        }
+    }
+})
+    .strict()
+    .help()
+    .alias('help', 'h')
+    .alias('version', 'v')
+    .alias('config', 'c')
+    .alias('endpoint', 'e')
+    .alias('port', 'p')
+    .alias('block', 'b')
+    .alias('import-storage', 's')
+    .alias('wasm-override', 'w')
+    .usage('Usage: $0 <command> [options]')
+    .example('$0', '-c acala');
+pluginExtendCli(commands).then(() => commands.parse());

package/dist/esm/context.js

@@ -0,0 +1,86 @@
+import './utils/tunnel';
+import { GenesisProvider, defaultLogger, isUrl, setup, timeTravel } from '@acala-network/chopsticks-core';
+import { SqliteDatabase } from '@acala-network/chopsticks-db';
+import { overrideStorage, overrideWasm } from './utils/override';
+import axios from 'axios';
+const logger = defaultLogger.child({ name: 'setup-context' });
+export const genesisFromUrl = async (url) => {
+    const getFile = async (url) => {
+        if (isUrl(url)) {
+            return axios.get(url).then((x) => x.data);
+        }
+        else if (typeof process === 'object') {
+            const { lstatSync, readFileSync } = await import('node:fs');
+            if (lstatSync(url).isFile()) {
+                return JSON.parse(String(readFileSync(url)));
+            }
+        }
+        throw Error(`invalid genesis path or url ${url}`);
+    };
+    return new GenesisProvider(await getFile(url));
+};
+export const setupContext = async (argv, overrideParent = false) => {
+    let genesis;
+    if (argv.genesis) {
+        if (typeof argv.genesis === 'string') {
+            genesis = await genesisFromUrl(argv.genesis);
+        }
+        else {
+            genesis = new GenesisProvider(argv.genesis);
+        }
+    }
+    const chain = await setup({
+        endpoint: argv.endpoint,
+        block: argv.block,
+        genesis,
+        buildBlockMode: argv['build-block-mode'],
+        db: argv.db ? new SqliteDatabase(argv.db) : undefined,
+        mockSignatureHost: argv['mock-signature-host'],
+        allowUnresolvedImports: argv['allow-unresolved-imports'],
+        runtimeLogLevel: argv['runtime-log-level'],
+        registeredTypes: argv['registered-types'],
+        offchainWorker: argv['offchain-worker'],
+        maxMemoryBlockCount: argv['max-memory-block-count'],
+    });
+    // load block from db
+    if (chain.db) {
+        if (argv.resume) {
+            let blockData = null;
+            if (typeof argv.resume === 'string' && argv.resume.startsWith('0x')) {
+                blockData = await chain.db.queryBlock(argv.resume);
+            }
+            else if (typeof argv.resume === 'boolean' || argv.resume === 'true') {
+                blockData = await chain.db.queryHighestBlock();
+            }
+            else if (Number.isInteger(+argv.resume)) {
+                blockData = await chain.db.queryBlockByNumber(+argv.resume);
+            }
+            else {
+                throw new Error(`Resume failed. Invalid resume option ${argv.resume}`);
+            }
+            if (blockData) {
+                const block = await chain.loadBlockFromDB(blockData.number);
+                block && (await chain.setHead(block));
+                logger.info(`Resume from block ${blockData.number}, hash: ${blockData.hash}`);
+            }
+            else {
+                throw new Error(`Resume failed. Cannot find block ${argv.resume}`);
+            }
+        }
+    }
+    if (argv.timestamp)
+        await timeTravel(chain, argv.timestamp);
+    let at;
+    if (overrideParent) {
+        // in case of run block we need to apply wasm-override and import-storage to parent block
+        const block = await chain.head.parentBlock;
+        if (!block)
+            throw new Error('Cannot find parent block');
+        at = block.hash;
+    }
+    // override wasm before importing storage, in case new pallets have been
+    // added that have storage imports
+    await overrideStorage(chain, argv['import-storage'], at);
+    await overrideWasm(chain, argv['wasm-override'], at);
+    return { chain };
+};

package/dist/esm/plugins/decode-key/index.js

@@ -0,0 +1,23 @@
+import { decodeKey } from '@acala-network/chopsticks-core';
+import { defaultOptions } from '../../cli-options';
+import { setupContext } from '../../context';
+export const cli = (y) => {
+    y.command('decode-key <key>', 'Deocde a key', (yargs) => yargs
+        .positional('key', {
+        desc: 'Key to decode',
+        type: 'string',
+    })
+        .options({
+        ...defaultOptions,
+    }), async (argv) => {
+        const context = await setupContext(argv);
+        const { storage, decodedKey } = decodeKey(await context.chain.head.meta, context.chain.head, argv.key);
+        if (storage && decodedKey) {
+            console.log(`${storage.section}.${storage.method}`, decodedKey.args.map((x) => JSON.stringify(x.toHuman())).join(', '));
+        }
+        else {
+            console.log('Unknown');
+        }
+        process.exit(0);
+    });
+};

package/dist/esm/plugins/dry-run/cli.js

@@ -0,0 +1,42 @@
+import { defaultOptions, mockOptions } from '../../cli-options';
+import { dryRunExtrinsic } from './dry-run-extrinsic';
+import { dryRunPreimage } from './dry-run-preimage';
+export const cli = (y) => {
+    y.command('dry-run', 'Dry run an extrinsic', (yargs) => yargs.options({
+        ...defaultOptions,
+        ...mockOptions,
+        extrinsic: {
+            desc: 'Extrinsic or call to dry run. If you pass call here then address is required to fake signature',
+            string: true,
+        },
+        address: {
+            desc: 'Address to fake sign extrinsic',
+            string: true,
+        },
+        preimage: {
+            desc: 'Preimage to dry run',
+            string: true,
+        },
+        at: {
+            desc: 'Block hash to dry run',
+            string: true,
+        },
+        'output-path': {
+            desc: 'File path to print output',
+            string: true,
+        },
+        html: {
+            desc: 'Generate html with storage diff',
+        },
+        open: {
+            desc: 'Open generated html',
+        },
+    }), async (argv) => {
+        if (argv.preimage) {
+            await dryRunPreimage(argv);
+        }
+        else {
+            await dryRunExtrinsic(argv);
+        }
+    });
+};

package/dist/esm/plugins/dry-run/dry-run-extrinsic.js

@@ -0,0 +1,29 @@
+import { blake2AsHex } from '@polkadot/util-crypto';
+import { writeFileSync } from 'node:fs';
+import { defaultLogger } from '../../logger';
+import { generateHtmlDiffPreviewFile } from '../../utils/generate-html-diff';
+import { openHtml } from '../../utils/open-html';
+import { setupContext } from '../../context';
+export const dryRunExtrinsic = async (argv) => {
+    const context = await setupContext(argv);
+    const input = argv['address'] ? { call: argv['extrinsic'], address: argv['address'] } : argv['extrinsic'];
+    const { outcome, storageDiff } = await context.chain.dryRunExtrinsic(input, argv['at']);
+    if (outcome.isErr) {
+        throw new Error(outcome.asErr.toString());
+    }
+    defaultLogger.info(outcome.toHuman(), 'dry_run_outcome');
+    if (argv['html']) {
+        const filePath = await generateHtmlDiffPreviewFile(context.chain.head, storageDiff, blake2AsHex(argv['extrinsic'], 256));
+        console.log(`Generated preview ${filePath}`);
+        if (argv['open']) {
+            openHtml(filePath);
+        }
+    }
+    else if (argv['output-path']) {
+        writeFileSync(argv['output-path'], JSON.stringify({ outcome: outcome.toHuman(), storageDiff }, null, 2));
+    }
+    else {
+        console.dir({ outcome: outcome.toHuman(), storageDiff }, { depth: null, colors: false });
+    }
+    process.exit(0);
+};

package/dist/esm/plugins/dry-run/dry-run-preimage.js

@@ -0,0 +1,92 @@
+import { blake2AsHex } from '@polkadot/util-crypto';
+import { hexToU8a } from '@polkadot/util';
+import { defaultLogger } from '../../logger';
+import { generateHtmlDiffPreviewFile } from '../../utils/generate-html-diff';
+import { newHeader, printRuntimeLogs, runTask, setStorage, taskHandler } from '@acala-network/chopsticks-core';
+import { openHtml } from '../../utils/open-html';
+import { setupContext } from '../../context';
+export const dryRunPreimage = async (argv) => {
+    const context = await setupContext(argv);
+    const extrinsic = argv['preimage'];
+    const block = context.chain.head;
+    const registry = await block.registry;
+    const header = await newHeader(block);
+    const data = hexToU8a(extrinsic);
+    const hash = blake2AsHex(data, 256);
+    await setStorage(context.chain, {
+        Preimage: {
+            PreimageFor: [[[[hash, data.byteLength]], extrinsic]],
+            StatusFor: [
+                [
+                    [hash],
+                    {
+                        Requested: {
+                            count: 1,
+                            len: data.byteLength,
+                        },
+                    },
+                ],
+            ],
+        },
+        Scheduler: {
+            Agenda: [
+                [
+                    [block.number + 1],
+                    [
+                        {
+                            maybeId: '0x64656d6f637261633a0000000000000000000000000000000000000000000000',
+                            priority: 63,
+                            call: {
+                                Lookup: {
+                                    hash: hash,
+                                    len: data.byteLength,
+                                },
+                            },
+                            origin: { system: { Root: null } },
+                        },
+                    ],
+                ],
+            ],
+            Lookup: [[['0x64656d6f637261633a0000000000000000000000000000000000000000000000'], [block.number + 1, 0]]],
+        },
+    });
+    const calls = [['Core_initialize_block', [header.toHex()]]];
+    for (const inherent of await block.chain.getInherents()) {
+        calls.push(['BlockBuilder_apply_extrinsic', [inherent]]);
+    }
+    calls.push(['BlockBuilder_finalize_block', []]);
+    defaultLogger.info({ preimage: registry.createType('Call', data).toHuman() }, 'Dry run preimage');
+    const result = await runTask({
+        wasm: await block.wasm,
+        calls,
+        mockSignatureHost: false,
+        allowUnresolvedImports: false,
+        runtimeLogLevel: argv['runtime-log-level'] || 0,
+    }, taskHandler(block));
+    if ('Error' in result) {
+        throw new Error(result.Error);
+    }
+    printRuntimeLogs(result.Call.runtimeLogs);
+    const filePath = await generateHtmlDiffPreviewFile(block, result.Call.storageDiff, hash);
+    console.log(`Generated preview ${filePath}`);
+    if (argv['open']) {
+        openHtml(filePath);
+    }
+    // if dry-run preimage has extrinsic arguments then dry-run extrinsic
+    // this is usefull to test something after preimage is applied
+    if (argv['extrinsic']) {
+        await context.chain.newBlock();
+        const input = argv['address'] ? { call: argv['extrinsic'], address: argv['address'] } : argv['extrinsic'];
+        const { outcome, storageDiff } = await context.chain.dryRunExtrinsic(input);
+        if (outcome.isErr) {
+            throw new Error(outcome.asErr.toString());
+        }
+        defaultLogger.info(outcome.toHuman(), 'dry_run_outcome');
+        const filePath = await generateHtmlDiffPreviewFile(context.chain.head, storageDiff, blake2AsHex(argv['extrinsic'], 256));
+        console.log(`Generated preview ${filePath}`);
+        if (argv['open']) {
+            openHtml(filePath);
+        }
+    }
+    process.exit(0);
+};

package/dist/esm/plugins/dry-run/rpc.js

@@ -0,0 +1,101 @@
+import { z } from 'zod';
+import { ResponseError } from '@acala-network/chopsticks-core';
+import { decodeStorageDiff } from '../../utils/decoder';
+import { generateHtmlDiff } from '../../utils/generate-html-diff';
+const zHex = z.custom((val) => /^0x\w+$/.test(val));
+const zHash = z.string().length(66).and(zHex);
+const zParaId = z.string().regex(/^\d+$/).transform(Number);
+const schema = z.object({
+    raw: z.boolean().optional(),
+    html: z.boolean().optional(),
+    extrinsic: zHex
+        .or(z.object({
+        call: zHex,
+        address: zHex,
+    }))
+        .optional(),
+    hrmp: z
+        .record(zParaId, z
+        .array(z.object({
+        sentAt: z.number(),
+        data: zHex,
+    }))
+        .min(1))
+        .optional(),
+    dmp: z
+        .array(z.object({
+        sentAt: z.number(),
+        msg: zHex,
+    }))
+        .min(1)
+        .optional(),
+    ump: z.record(zParaId, z.array(zHex).min(1)).optional(),
+    at: zHash.optional(),
+});
+// custom rpc name (optional). e.g. dryRun will be called as dev_dryRun
+export const name = 'dryRun';
+/**
+ * Dry run an extrinsic or messages.
+ * If `html` is true, return the generated storage diff html string.
+ * If `raw` is true, return the raw storage diff.
+ * Otherwise, return `{ oldState, newState, delta }`.
+ *
+ * This function is a dev rpc handler. Use `dev_dryRun` as the method name when calling it.
+ *
+ * @param context - The context object of the rpc handler
+ * @param params - The parameters of the rpc handler
+ *
+ * @example Dry run an dmp
+ * ```ts
+ * import { WsProvider } from '@polkadot/rpc-provider'
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * const params = [
+    {
+      raw: false,
+      dmp: [
+        // https://acala.subscan.io/xcm_message/polkadot-2ab22918c567455af3563989d852f307f4cc1250
+        {
+          sentAt: 14471353,
+          msg: '0x02100104000100000b00280b9bba030a13000100000b00280b9bba03010300286bee0d0100040001010070c53d8e216f9c0f2e3b11c53f5f4bf3e078b995d5f0ed590f889f41e20e6531',
+        },
+      ],
+    },
+  ]
+ * await ws.send('dev_dryRun', params)
+ * ```
+ */
+export const rpc = async (context, [params]) => {
+    const { html, extrinsic, hrmp, dmp, ump, raw, at } = schema.parse(params);
+    const dryRun = async () => {
+        if (extrinsic) {
+            const { outcome, storageDiff } = await context.chain.dryRunExtrinsic(extrinsic, at);
+            if (outcome.isErr) {
+                throw new ResponseError(1, outcome.asErr.toString());
+            }
+            return storageDiff;
+        }
+        if (hrmp) {
+            return context.chain.dryRunHrmp(hrmp, at);
+        }
+        if (dmp) {
+            return context.chain.dryRunDmp(dmp, at);
+        }
+        if (ump) {
+            return context.chain.dryRunUmp(ump, at);
+        }
+        throw new ResponseError(1, 'No extrinsic to run');
+    };
+    const storageDiff = await dryRun();
+    if (html) {
+        return generateHtmlDiff(context.chain.head, storageDiff);
+    }
+    if (raw) {
+        return storageDiff;
+    }
+    const { oldState, newState, delta } = await decodeStorageDiff(context.chain.head, storageDiff);
+    return {
+        old: oldState,
+        new: newState,
+        delta,
+    };
+};

package/dist/esm/plugins/index.js

@@ -0,0 +1,25 @@
+import { camelCase } from 'lodash';
+import { lstatSync, readdirSync } from 'fs';
+import { defaultLogger } from '../logger';
+const logger = defaultLogger.child({ name: 'plugin' });
+export const pluginHandlers = {};
+const plugins = readdirSync(__dirname).filter((file) => lstatSync(`${__dirname}/${file}`).isDirectory());
+(async () => {
+    for (const plugin of plugins) {
+        const { rpc, name } = await import(`./${plugin}`);
+        if (rpc) {
+            const methodName = name || camelCase(plugin);
+            pluginHandlers[`dev_${methodName}`] = rpc;
+            logger.debug(`Registered plugin ${plugin} RPC`);
+        }
+    }
+})();
+export const pluginExtendCli = async (y) => {
+    for (const plugin of plugins) {
+        const { cli } = await import(`./${plugin}`);
+        if (cli) {
+            cli(y);
+            logger.debug(`Registered plugin ${plugin} CLI`);
+        }
+    }
+};

package/dist/esm/plugins/new-block/index.js

@@ -0,0 +1,67 @@
+import { ResponseError } from '@acala-network/chopsticks-core';
+import { defaultLogger } from '../../logger';
+/**
+ * Build new blocks.
+ *
+ * This function is a dev rpc handler. Use `dev_newBlock` as the method name when calling it.
+ *
+ * @param context - The context object of the rpc handler
+ * @param params - The parameters of the rpc handler
+ *
+ * @example Build 2 blocks
+ * ```ts
+ * import { WsProvider } from '@polkadot/rpc-provider'
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * await ws.send('dev_newBlock', [{ count: 2 }])
+ * ```
+ * @example Build a block with upward messages
+ * ```ts
+ * import { WsProvider } from '@polkadot/rpc-provider'
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * await ws.send('dev_newBlock', [
+ *  {
+ *    ump: {
+ *      // https://acala.subscan.io/xcm_message/polkadot-ff66f28818d0b74573e62db8317e354b253fbc80
+ *      2000: [
+ *        '0x021000040000000007903fc4db080a130000000007903fc4db08000d010004000101009c4b11a0974cba4a395c94832fba812868a6cb0ba09e8519b3521093ea359905',
+ *      ],
+ *    }
+ *  }
+ * ])
+ * ```
+ *
+ * @example Build two blocks with unsafeBlockHeight
+ * ```ts
+ * import { WsProvider } from '@polkadot/rpc-provider'
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * // this will create two blocks with block height 100000001 and 100000002
+ * await ws.send('dev_newBlock', [{ count: 2, unsafeBlockHeight: 100000001 }])
+ * ```
+ */
+export const rpc = async (context, params) => {
+    const [param] = params;
+    const { count, to, hrmp, ump, dmp, transactions, unsafeBlockHeight } = param || {};
+    const now = context.chain.head.number;
+    const diff = to ? to - now : count;
+    const finalCount = diff > 0 ? diff : 1;
+    let finalHash;
+    if (unsafeBlockHeight < now) {
+        throw new ResponseError(1, 'unsafeBlockHeight must be greater than current block height');
+    }
+    for (let i = 0; i < finalCount; i++) {
+        const block = await context.chain
+            .newBlock({
+            transactions,
+            horizontalMessages: hrmp,
+            upwardMessages: ump,
+            downwardMessages: dmp,
+            unsafeBlockHeight: i === 0 ? unsafeBlockHeight : undefined,
+        })
+            .catch((error) => {
+            throw new ResponseError(1, error.toString());
+        });
+        defaultLogger.debug({ hash: block.hash }, 'dev_newBlock');
+        finalHash = block.hash;
+    }
+    return finalHash;
+};