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

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

@@ -0,0 +1,176 @@
+import { writeFileSync } from 'node:fs';
+import { z } from 'zod';
+import _ from 'lodash';
+import { Block, decodeKeyValue, printRuntimeLogs, runTask, taskHandler } from '@acala-network/chopsticks-core';
+import { defaultOptions, mockOptions } from '../../cli-options';
+import { generateHtmlDiffPreviewFile } from '../../utils/generate-html-diff';
+import { openHtml } from '../../utils/open-html';
+import { setupContext } from '../../context';
+export const cli = (y) => {
+    y.command('run-block', 'Replay a block', (yargs) => yargs.options({
+        ...defaultOptions,
+        ...mockOptions,
+        'output-path': {
+            desc: 'File path to print output',
+            string: true,
+        },
+        html: {
+            desc: 'Generate html with storage diff',
+        },
+        open: {
+            desc: 'Open generated html',
+        },
+    }), async (argv) => {
+        const context = await setupContext(argv, true);
+        const header = await context.chain.head.header;
+        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]]);
+        }
+        calls.push(['BlockBuilder_finalize_block', []]);
+        const result = await runTask({
+            wasm,
+            calls,
+            mockSignatureHost: false,
+            allowUnresolvedImports: false,
+            runtimeLogLevel: argv.runtimeLogLevel || 0,
+        }, taskHandler(parent));
+        if ('Error' in result) {
+            throw new Error(result.Error);
+        }
+        printRuntimeLogs(result.Call.runtimeLogs);
+        if (argv.html) {
+            const filePath = await generateHtmlDiffPreviewFile(parent, result.Call.storageDiff, block.hash);
+            console.log(`Generated preview ${filePath}`);
+            if (argv.open) {
+                openHtml(filePath);
+            }
+        }
+        else if (argv.outputPath) {
+            writeFileSync(argv.outputPath, JSON.stringify(result, null, 2));
+        }
+        else {
+            console.dir(result, { depth: null, colors: false });
+        }
+        process.exit(0);
+    });
+};
+const zHex = z.custom((val) => /^0x\w+$/.test(val));
+const zHash = z.string().length(66).and(zHex);
+const schema = z.object({
+    includeRaw: z.boolean().optional(),
+    includeParsed: z.boolean().optional(),
+    includeBlockDetails: z.boolean().optional(),
+    parent: zHash.optional(),
+    block: z.object({
+        header: z.any(),
+        extrinsics: z.array(zHex),
+    }),
+});
+export const name = 'runBlock';
+/**
+ * Run a set of extrinsics on top of a block and get the storage diff
+ * and optionally the parsed storage diff and block details.
+ * NOTE: The extrinsics should include inherents or tranasctions may have unexpected results.
+ *
+ * This function is a dev rpc handler. Use `dev_runBlock` as the method name when calling it.
+ */
+export const rpc = async ({ chain }, [params]) => {
+    const { includeRaw, includeParsed, includeBlockDetails, parent, block } = schema.parse(params);
+    const includeRawStorage = includeRaw ?? true;
+    const parentBlock = await chain.getBlock(parent);
+    if (!parentBlock) {
+        throw Error(`Invalid block hash ${parent}`);
+    }
+    const registry = await parentBlock.registry;
+    const header = registry.createType('Header', block.header);
+    const wasm = await parentBlock.wasm;
+    const blockNumber = parentBlock.number + 1;
+    const hash = `0x${Math.round(Math.random() * 100000000)
+        .toString(16)
+        .padEnd(64, '0')}`;
+    const newBlock = new Block(chain, blockNumber, hash, parentBlock, {
+        header,
+        extrinsics: [],
+        storage: parentBlock.storage,
+    });
+    const resp = {
+        phases: [],
+    };
+    const run = async (fn, args) => {
+        const result = await runTask({
+            wasm,
+            calls: [[fn, args]],
+            mockSignatureHost: false,
+            allowUnresolvedImports: false,
+            runtimeLogLevel: 5,
+        }, taskHandler(newBlock));
+        if ('Error' in result) {
+            throw new Error(result.Error);
+        }
+        const resp = {};
+        const raw = result.Call.storageDiff;
+        newBlock.pushStorageLayer().setAll(raw);
+        if (includeRawStorage) {
+            resp.raw = raw;
+        }
+        if (includeParsed) {
+            const meta = await newBlock.meta;
+            const parsed = {};
+            for (const [key, value] of raw) {
+                _.merge(parsed, decodeKeyValue(meta, newBlock, key, value, false));
+            }
+            // clear events because it can be stupidly large and redudant
+            if (parsed['system']?.['events']) {
+                delete parsed['system']['events'];
+            }
+            resp.parsed = parsed;
+        }
+        resp.logs = result.Call.runtimeLogs;
+        return resp;
+    };
+    const resInit = await run('Core_initialize_block', [header.toHex()]);
+    resp.phases.push({ phase: 'Initialization', ...resInit });
+    for (const extrinsic of block.extrinsics) {
+        const res = await run('BlockBuilder_apply_extrinsic', [extrinsic]);
+        resp.phases.push({ phase: resp.phases.length - 1, ...res });
+    }
+    const resFinalize = await run('BlockBuilder_finalize_block', []);
+    resp.phases.push({ phase: 'Finalization', ...resFinalize });
+    if (includeBlockDetails) {
+        const meta = await newBlock.meta;
+        const registry = await newBlock.registry;
+        const timestamp = await newBlock.read('u64', meta.query.timestamp.now);
+        const events = await newBlock.read('Vec<EventRecord>', meta.query.system.events);
+        const parsedEvents = events?.map((event) => ({
+            phase: event.phase.isApplyExtrinsic ? event.phase.asApplyExtrinsic.toNumber() : event.phase.toString(),
+            section: event.event.section,
+            method: event.event.method,
+            args: event.event.data.map((arg) => arg.toJSON()),
+        }));
+        const extrinsics = block.extrinsics.map((extrinsic, idx) => {
+            const parsed = registry.createType('GenericExtrinsic', extrinsic);
+            const resultEvent = events?.find(({ event, phase }) => event.section === 'system' &&
+                (event.method === 'ExtrinsicSuccess' || event.method === 'ExtrinsicFailed') &&
+                phase.isApplyExtrinsic &&
+                phase.asApplyExtrinsic.eq(idx));
+            return {
+                section: parsed.method.section,
+                method: parsed.method.method,
+                args: parsed.method.args.map((arg) => arg.toJSON()),
+                success: resultEvent?.event.method === 'ExtrinsicSuccess',
+            };
+        });
+        resp.blockDetails = {
+            timestamp: timestamp?.toString(),
+            events: parsedEvents,
+            extrinsics,
+        };
+    }
+    return resp;
+};

package/dist/esm/plugins/set-block-build-mode/index.js

@@ -0,0 +1,25 @@
+import { BuildBlockMode, ResponseError } from '@acala-network/chopsticks-core';
+import { defaultLogger } from '../../logger';
+/**
+ * Set a build block mode. See [BuildBlockMode](../core/enums/BuildBlockMode).
+ *
+ * This function is a dev rpc handler. Use `dev_setBlockBuildMode` 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 Set build block mode to instant
+ * ```ts
+ * import { WsProvider } from '@polkadot/rpc-provider'
+ * import { BuildBlockMode } from '@acala-network/chopsticks-core'
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * await ws.send('dev_setBlockBuildMode', [BuildBlockMode.Instant])
+ * ```
+ */
+export const rpc = async (context, [mode]) => {
+    defaultLogger.debug({ mode }, 'dev_setBlockBuildMode');
+    if (BuildBlockMode[mode] === undefined) {
+        throw new ResponseError(1, `Invalid mode ${mode}`);
+    }
+    context.chain.txPool.mode = mode;
+};

package/dist/esm/plugins/set-head/index.js

@@ -0,0 +1,31 @@
+import { ResponseError } from '@acala-network/chopsticks-core';
+/**
+ * Set head.
+ *
+ * This function is a dev rpc handler. Use `dev_setHead` as the method name when calling it.
+ *
+ * @param context - The context object of the rpc handler
+ * @param hashOrNumber - The block hash or number to set as head
+ *
+ * @example Set head to block 1000000
+ * ```ts
+ * import { WsProvider } from '@polkadot/rpc-provider'
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * await ws.send('dev_setHead', [1000000])
+ * ```
+ */
+export const rpc = async (context, [hashOrNumber]) => {
+    let block;
+    if (typeof hashOrNumber === 'number') {
+        const blockNumber = hashOrNumber > 0 ? hashOrNumber : context.chain.head.number + hashOrNumber;
+        block = await context.chain.getBlockAt(blockNumber);
+    }
+    else {
+        block = await context.chain.getBlock(hashOrNumber);
+    }
+    if (!block) {
+        throw new ResponseError(1, `Block not found ${hashOrNumber}`);
+    }
+    await context.chain.setHead(block);
+    return block.hash;
+};

package/dist/esm/plugins/set-runtime-log-level/index.js

@@ -0,0 +1,24 @@
+import { ResponseError } from '@acala-network/chopsticks-core';
+import { defaultLogger } from '../../logger';
+/**
+ * Set runtime log level.
+ *
+ * This function is a dev rpc handler. Use `dev_setRuntimeLogLevel` as the method name when calling it.
+ *
+ * @param context - The context object of the rpc handler
+ * @param runtimeLogLevel - The runtime log level to set
+ *
+ * @example Set runtime log level to 1
+ * ```ts
+ * import { WsProvider } from '@polkadot/rpc-provider'
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * await ws.send('dev_setRuntimeLogLevel', [1])
+ * ```
+ */
+export const rpc = async (context, [runtimeLogLevel]) => {
+    defaultLogger.debug({ runtimeLogLevel }, 'dev_setRuntimeLogLevel');
+    if (typeof runtimeLogLevel !== 'number') {
+        throw new ResponseError(1, `Invalid runtimeLogLevel ${runtimeLogLevel}`);
+    }
+    context.chain.runtimeLogLevel = runtimeLogLevel;
+};

package/dist/esm/plugins/set-storage/index.js

@@ -0,0 +1,38 @@
+import { ResponseError, setStorage } from '@acala-network/chopsticks-core';
+import { defaultLogger } from '../../logger';
+/**
+ * Set storage values.
+ *
+ * This function is a dev rpc handler. Use `dev_setStorage` 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
+ * ```ts
+ * import { WsProvider } from '@polkadot/rpc-provider'
+ * import { Keyring } from '@polkadot/keyring'
+ *
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * const keyring = new Keyring({ type: 'ed25519' })
+ * const bob = keyring.addFromUri('//Bob')
+ *
+ * const storage = {
+ *   System: {
+ *     Account: [[[bob.address], { data: { free: 100000 }, nonce: 1 }]],
+ *   },
+ * }
+ * await ws.send('dev_setStorage', [storage])
+ * ```
+ */
+export const rpc = async (context, params) => {
+    const [values, blockHash] = params;
+    const hash = await setStorage(context.chain, values, blockHash).catch((error) => {
+        throw new ResponseError(1, error.toString());
+    });
+    defaultLogger.debug({
+        hash,
+        values,
+    }, 'dev_setStorage');
+    return hash;
+};

package/dist/esm/plugins/time-travel/index.js

@@ -0,0 +1,23 @@
+import { ResponseError, timeTravel } from '@acala-network/chopsticks-core';
+/**
+ * Travel to a specific time.
+ *
+ * This function is a dev rpc handler. Use `dev_timeTravel` as the method name when calling it.
+ *
+ * @param context - The context object of the rpc handler
+ * @param date - Timestamp or date string to set
+ *
+ * @example
+ * ```ts
+ * import { WsProvider } from '@polkadot/rpc-provider'
+ * const ws = new WsProvider(`ws://localhost:8000`)
+ * await ws.send('dev_timeTravel', ['Jan 1, 2023'])
+ * ```
+ */
+export const rpc = async (context, [date]) => {
+    const timestamp = typeof date === 'string' ? Date.parse(date) : date;
+    if (Number.isNaN(timestamp))
+        throw new ResponseError(1, 'Invalid date');
+    await timeTravel(context.chain, timestamp);
+    return timestamp;
+};

package/dist/esm/plugins/try-runtime/index.js

@@ -0,0 +1,54 @@
+import { writeFileSync } from 'node:fs';
+import { defaultOptions } from '../../cli-options';
+import { generateHtmlDiffPreviewFile } from '../../utils/generate-html-diff';
+import { openHtml } from '../../utils/open-html';
+import { setupContext } from '../../context';
+export const cli = (y) => {
+    y.command('try-runtime', 'Runs runtime upgrade', (yargs) => yargs.options({
+        ...defaultOptions,
+        'wasm-override': {
+            desc: 'Path to WASM built with feature `try-runtime` enabled',
+            string: true,
+            required: true,
+        },
+        'output-path': {
+            desc: 'File path to print output',
+            string: true,
+        },
+        html: {
+            desc: 'Generate html with storage diff',
+            boolean: true,
+        },
+        open: {
+            desc: 'Open generated html',
+            boolean: true,
+        },
+    }), async (argv) => {
+        const context = await setupContext(argv);
+        const block = context.chain.head;
+        const registry = await block.registry;
+        registry.register({
+            UpgradeCheckSelect: {
+                _enum: {
+                    None: null,
+                },
+            },
+        });
+        const select_none = registry.createType('UpgradeCheckSelect', 'None');
+        const result = await block.call('TryRuntime_on_runtime_upgrade', [select_none.toHex()]);
+        if (argv.html) {
+            const filePath = await generateHtmlDiffPreviewFile(block, result.storageDiff, block.hash);
+            console.log(`Generated preview ${filePath}`);
+            if (argv.open) {
+                openHtml(filePath);
+            }
+        }
+        else if (argv.outputPath) {
+            writeFileSync(argv.outputPath, JSON.stringify(result, null, 2));
+        }
+        else {
+            console.dir(result, { depth: null, colors: false });
+        }
+        process.exit(0);
+    });
+};

package/{lib/plugins/types.d.ts → dist/esm/plugins/types.js}

@@ -1,8 +1,8 @@
-export { rpc as newBlock, NewBlockParams } from './new-block';
-export { rpc as dryRun, DryRunParams } from './dry-run';
+export { rpc as newBlock } from './new-block';
+export { rpc as dryRun } from './dry-run';
 export { rpc as setBlockBuildMode } from './set-block-build-mode';
 export { rpc as setHead } from './set-head';
 export { rpc as setRuntimeLogLevel } from './set-runtime-log-level';
 export { rpc as setStorage } from './set-storage';
 export { rpc as timeTravel } from './time-travel';
-export { rpc as runBlock, RunBlockParams } from './run-block';
+export { rpc as runBlock } from './run-block';

package/dist/esm/rpc/index.js

@@ -0,0 +1,26 @@
+import { ResponseError, logger, substrate, } from '@acala-network/chopsticks-core';
+import { pluginHandlers } from '../plugins';
+const allHandlers = {
+    ...substrate,
+    rpc_methods: async () => Promise.resolve({
+        version: 1,
+        methods: [...Object.keys(allHandlers), ...Object.keys(pluginHandlers)],
+    }),
+};
+const getHandler = (method) => {
+    const handler = allHandlers[method];
+    if (!handler) {
+        // no handler for this method, check if it's a plugin
+        return pluginHandlers[method];
+    }
+    return handler;
+};
+export const handler = (context) => ({ method, params }, subscriptionManager) => {
+    logger.trace('Handling %s', method);
+    const handler = getHandler(method);
+    if (!handler) {
+        logger.warn('Method not found %s', method);
+        throw new ResponseError(-32601, `Method not found: ${method}`);
+    }
+    return handler(context, params, subscriptionManager);
+};

package/dist/esm/schema/index.js

@@ -0,0 +1,53 @@
+import { BuildBlockMode, defaultLogger, genesisSchema, isUrl } from '@acala-network/chopsticks-core';
+import { basename, extname } from 'node:path';
+import { readFileSync } from 'node:fs';
+import { z } from 'zod';
+import _ from 'lodash';
+import axios from 'axios';
+import yaml from 'js-yaml';
+export const configSchema = z
+    .object({
+    port: z.number().optional(),
+    endpoint: z.string().optional(),
+    block: z.union([z.string().length(66).startsWith('0x'), z.number(), z.null()]).optional(),
+    'build-block-mode': z.nativeEnum(BuildBlockMode).optional(),
+    'import-storage': z.any().optional(),
+    'mock-signature-host': z.boolean().optional(),
+    'max-memory-block-count': z.number().optional(),
+    db: z.string().optional(),
+    'wasm-override': z.string().optional(),
+    genesis: z.union([z.string(), genesisSchema]).optional(),
+    timestamp: z.number().optional(),
+    'registered-types': z.any().optional(),
+    'runtime-log-level': z.number().min(0).max(5).optional(),
+    'offchain-worker': z.boolean().optional(),
+    resume: z.union([z.string().length(66).startsWith('0x'), z.number(), z.boolean()]).optional(),
+})
+    .strict();
+const CONFIGS_BASE_URL = 'https://raw.githubusercontent.com/AcalaNetwork/chopsticks/master/configs/';
+export const fetchConfig = async (path) => {
+    let file;
+    if (isUrl(path)) {
+        file = await axios.get(path).then((x) => x.data);
+    }
+    else {
+        try {
+            file = readFileSync(path, 'utf8');
+        }
+        catch (err) {
+            if (basename(path) === path && ['', '.yml', '.yaml', '.json'].includes(extname(path))) {
+                if (extname(path) === '') {
+                    path += '.yml';
+                }
+                const url = CONFIGS_BASE_URL + path;
+                defaultLogger.info(`Loading config file ${url}`);
+                file = await axios.get(url).then((x) => x.data);
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    const config = yaml.load(_.template(file, { variable: 'env' })(process.env));
+    return configSchema.parse(config);
+};

package/dist/esm/server.js

@@ -0,0 +1,164 @@
+import { WebSocket, WebSocketServer } from 'ws';
+import { ResponseError } from '@acala-network/chopsticks-core';
+import { z } from 'zod';
+import { defaultLogger, truncate } from './logger';
+const logger = defaultLogger.child({ name: 'ws' });
+const singleRequest = z.object({
+    id: z.number(),
+    jsonrpc: z.literal('2.0'),
+    method: z.string(),
+    params: z.array(z.any()).default([]),
+});
+const batchRequest = z.array(singleRequest);
+const requestSchema = z.union([singleRequest, batchRequest]);
+const parseRequest = (request) => {
+    try {
+        return JSON.parse(request);
+    }
+    catch (e) {
+        return undefined;
+    }
+};
+const createWS = async (port) => {
+    const wss = new WebSocketServer({ port, maxPayload: 1024 * 1024 * 100 });
+    const promise = new Promise((resolve) => {
+        wss.on('listening', () => {
+            resolve([wss, wss.address().port]);
+        });
+        wss.on('error', (_) => {
+            resolve([]);
+        });
+    });
+    return promise;
+};
+export const createServer = async (handler, port) => {
+    let wss;
+    let listenPort;
+    for (let i = 0; i < 10; i++) {
+        const preferPort = (port ?? 0) > 0 ? (port ?? 0) + i : 0;
+        logger.debug('Try starting on port %d', preferPort);
+        const [maybeWss, maybeListenPort] = await createWS(preferPort);
+        if (maybeWss && maybeListenPort) {
+            wss = maybeWss;
+            listenPort = maybeListenPort;
+            break;
+        }
+    }
+    if (!wss || !listenPort) {
+        throw new Error(`Failed to create WebsocketServer at port ${port}`);
+    }
+    wss.on('connection', (ws) => {
+        logger.debug('New connection');
+        const send = (data) => {
+            if (ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify(data));
+            }
+        };
+        const subscriptions = {};
+        const subscriptionManager = {
+            subscribe: (method, subid, onCancel = () => { }) => {
+                subscriptions[subid] = onCancel;
+                return (data) => {
+                    if (subscriptions[subid]) {
+                        logger.trace({ method, subid, data: truncate(data) }, 'Subscription notification');
+                        send({
+                            jsonrpc: '2.0',
+                            method,
+                            params: {
+                                result: data,
+                                subscription: subid,
+                            },
+                        });
+                    }
+                };
+            },
+            unsubscribe: (subid) => {
+                if (subscriptions[subid]) {
+                    subscriptions[subid](subid);
+                    delete subscriptions[subid];
+                }
+            },
+        };
+        const processRequest = async (req) => {
+            logger.trace({
+                id: req.id,
+                method: req.method,
+            }, 'Received message');
+            try {
+                const resp = await handler(req, subscriptionManager);
+                logger.trace({
+                    id: req.id,
+                    method: req.method,
+                    result: truncate(resp),
+                }, 'Response for request');
+                return {
+                    id: req.id,
+                    jsonrpc: '2.0',
+                    result: resp ?? null,
+                };
+            }
+            catch (e) {
+                logger.info('Error handling request: %s %o', e, e.stack);
+                return {
+                    id: req.id,
+                    jsonrpc: '2.0',
+                    error: e instanceof ResponseError ? e : { code: -32603, message: `Internal ${e}` },
+                };
+            }
+        };
+        ws.on('close', () => {
+            logger.debug('Connection closed');
+            for (const [subid, onCancel] of Object.entries(subscriptions)) {
+                onCancel(subid);
+            }
+            ws.removeAllListeners();
+        });
+        ws.on('error', () => {
+            logger.debug('Connection error');
+            for (const [subid, onCancel] of Object.entries(subscriptions)) {
+                onCancel(subid);
+            }
+            ws.removeAllListeners();
+        });
+        ws.on('message', async (message) => {
+            const parsed = await requestSchema.safeParseAsync(parseRequest(message.toString()));
+            if (!parsed.success) {
+                logger.info('Invalid request: %s', message);
+                send({
+                    id: null,
+                    jsonrpc: '2.0',
+                    error: {
+                        code: -32600,
+                        message: 'Invalid JSON Request',
+                    },
+                });
+                return;
+            }
+            const { data: req } = parsed;
+            if (Array.isArray(req)) {
+                logger.trace({ req }, 'Received batch request');
+                const resp = await Promise.all(req.map(processRequest));
+                send(resp);
+            }
+            else {
+                logger.trace({ req }, 'Received single request');
+                const resp = await processRequest(req);
+                send(resp);
+            }
+        });
+    });
+    return {
+        port: listenPort,
+        close: () => new Promise((resolve, reject) => {
+            wss?.clients.forEach((socket) => socket.close());
+            wss?.close((err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        }),
+    };
+};

package/dist/esm/setup-with-server.js

@@ -0,0 +1,22 @@
+import { createServer } from './server';
+import { handler } from './rpc';
+import { logger } from '@acala-network/chopsticks-core';
+import { setupContext } from './context';
+export const setupWithServer = async (argv) => {
+    const context = await setupContext(argv);
+    const port = argv.port ?? 8000;
+    if (argv.genesis) {
+        // mine 1st block when starting from genesis to set some mock validation data
+        await context.chain.newBlock();
+    }
+    const { close, port: listenPort } = await createServer(handler(context), port);
+    logger.info(`${await context.chain.api.getSystemChain()} RPC listening on port ${listenPort}`);
+    return {
+        ...context,
+        listenPort,
+        async close() {
+            await context.chain.close();
+            await close();
+        },
+    };
+};

package/dist/esm/types.js

@@ -0,0 +1,2 @@
+export * from '@acala-network/chopsticks-core/src/rpc/substrate';
+export * from './plugins/types';

package/dist/esm/utils/decoder.js

@@ -0,0 +1,15 @@
+import { decodeBlockStorageDiff } from '@acala-network/chopsticks-core';
+import { create } from 'jsondiffpatch';
+import _ from 'lodash';
+const diffPatcher = create({
+    array: { detectMove: false },
+    textDiff: { minLength: Number.MAX_VALUE }, // skip text diff
+});
+export const decodeStorageDiff = async (block, diff) => {
+    const [oldState, newState] = await decodeBlockStorageDiff(block, diff);
+    const oldStateWithoutEvents = _.cloneDeep(oldState);
+    if (oldStateWithoutEvents['system']?.['events']) {
+        oldStateWithoutEvents['system']['events'] = [];
+    }
+    return { oldState, newState, delta: diffPatcher.diff(oldStateWithoutEvents, newState) };
+};