@acala-network/chopsticks 0.2.3 → 0.3.1

package/dist/server.js

@@ -35,19 +35,34 @@ const parseRequest = (request) => {
         return undefined;
     }
 };
-const createServer = (port, handler) => {
-    logger.debug('Starting on port %d', port);
+const createWS = async (port) => {
     const wss = new ws_1.WebSocketServer({ port, maxPayload: 1024 * 1024 * 100 });
-    const promise = new Promise((resolve, reject) => {
+    const promise = new Promise((resolve) => {
         wss.on('listening', () => {
-            logger.debug(wss.address(), 'Listening');
-            resolve(wss.address().port);
+            resolve([wss, wss.address().port]);
         });
-        wss.on('error', (err) => {
-            logger.error(err, 'Error');
-            reject(err);
+        wss.on('error', (_) => {
+            resolve([]);
         });
     });
+    return promise;
+};
+const createServer = async (handler, port) => {
+    let wss;
+    let listenPort;
+    for (let i = 0; i < 5; i++) {
+        const preferPort = (port || 0) + i;
+        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) => {
@@ -131,10 +146,10 @@ const createServer = (port, handler) => {
         });
     });
     return {
-        port: promise,
+        port: listenPort,
         close: () => new Promise((resolve, reject) => {
-            wss.clients.forEach((socket) => socket.close());
-            wss.close((err) => {
+            wss?.clients.forEach((socket) => socket.close());
+            wss?.close((err) => {
                 if (err) {
                     reject(err);
                 }

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

@@ -0,0 +1,8 @@
+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;
+}>;

package/dist/setup-with-server.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 setupWithServer = async (argv) => {
+    const context = await (0, setup_1.setup)(argv);
+    const port = argv.port || Number(process.env.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 (0, server_1.createServer)((0, rpc_1.handler)(context), port);
+    shared_1.logger.info(`${await context.chain.api.getSystemChain()} RPC listening on port ${listenPort}`);
+    return {
+        ...context,
+        close,
+        listenPort,
+    };
+};
+exports.setupWithServer = setupWithServer;

package/dist/setup.d.ts

@@ -0,0 +1,10 @@
+import '@polkadot/types-codec';
+import { ProviderInterface } from '@polkadot/rpc-provider/types';
+import { Api } from './api';
+import { Blockchain } from './blockchain';
+import { Config } from './schema';
+export declare const setup: (argv: Config) => Promise<{
+    chain: Blockchain;
+    api: Api;
+    ws: ProviderInterface;
+}>;

package/dist/setup.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setup = void 0;
+require("@polkadot/types-codec");
+const api_1 = require("@polkadot/api");
+const api_2 = require("./api");
+const blockchain_1 = require("./blockchain");
+const genesis_provider_1 = require("./genesis-provider");
+const inherent_1 = require("./blockchain/inherent");
+const logger_1 = require("./logger");
+const import_storage_1 = require("./utils/import-storage");
+const db_1 = require("./db");
+const time_travel_1 = require("./utils/time-travel");
+const setup = async (argv) => {
+    let provider;
+    if (argv.genesis) {
+        if (typeof argv.genesis === 'string') {
+            provider = await genesis_provider_1.GenesisProvider.fromUrl(argv.genesis);
+        }
+        else {
+            provider = new genesis_provider_1.GenesisProvider(argv.genesis);
+        }
+    }
+    else {
+        provider = new api_1.WsProvider(argv.endpoint);
+    }
+    const api = new api_2.Api(provider);
+    await api.isReady;
+    let blockHash;
+    if (argv.block == null) {
+        blockHash = await api.getBlockHash();
+    }
+    else if (Number.isInteger(+argv.block)) {
+        blockHash = await api.getBlockHash(Number(argv.block));
+    }
+    else {
+        blockHash = argv.block;
+    }
+    logger_1.defaultLogger.debug({ ...argv, blockHash }, 'Args');
+    let db;
+    if (argv.db) {
+        db = await (0, db_1.openDb)(argv.db);
+    }
+    const header = await api.getHeader(blockHash);
+    const inherents = new inherent_1.InherentProviders(new inherent_1.SetTimestamp(), [
+        new inherent_1.SetValidationData(),
+        new inherent_1.ParaInherentEnter(),
+        new inherent_1.SetNimbusAuthorInherent(),
+        new inherent_1.SetBabeRandomness(),
+    ]);
+    const chain = new blockchain_1.Blockchain({
+        api,
+        buildBlockMode: argv['build-block-mode'],
+        inherentProvider: inherents,
+        db,
+        header: {
+            hash: blockHash,
+            number: Number(header.number),
+        },
+    });
+    if (argv.timestamp)
+        await (0, time_travel_1.timeTravel)(chain, argv.timestamp);
+    await (0, import_storage_1.importStorage)(chain, argv['import-storage']);
+    await (0, import_storage_1.overrideWasm)(chain, argv['wasm-override']);
+    return { chain, api, ws: provider };
+};
+exports.setup = setup;

package/dist/utils/decoder.d.ts

@@ -0,0 +1,17 @@
+import '@polkadot/types-codec';
+import { Block } from '../blockchain/block';
+import { HexString } from '@polkadot/util/types';
+import { StorageEntry } from '@polkadot/types/primitive/types';
+import { StorageKey } from '@polkadot/types';
+export declare const decodeKey: (block: Block, key: HexString) => Promise<{
+    storage?: StorageEntry | undefined;
+    decodedKey?: StorageKey<import("@polkadot/types-codec/types").AnyTuple> | undefined;
+}>;
+export declare const decodeKeyValue: (block: Block, key: HexString, value?: HexString | null) => Promise<{
+    [x: string]: `0x${string}` | null | undefined;
+} | {
+    [x: string]: {
+        [x: string]: import("@polkadot/types-codec/types").AnyJson;
+    };
+}>;
+export declare const decodeStorageDiff: (block: Block, diff: [HexString, HexString | null][]) => Promise<({} | undefined)[]>;

package/dist/utils/decoder.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeStorageDiff = exports.decodeKeyValue = exports.decodeKey = void 0;
+require("@polkadot/types-codec");
+const util_crypto_1 = require("@polkadot/util-crypto");
+const jsondiffpatch_1 = require("jsondiffpatch");
+const util_1 = require("@polkadot/util");
+const lodash_1 = __importDefault(require("lodash"));
+const diffPatcher = (0, jsondiffpatch_1.create)({
+    array: { detectMove: false },
+    textDiff: { minLength: Number.MAX_VALUE }, // skip text diff
+});
+const cache = {};
+const getStorageEntry = async (block, key) => {
+    for (const [prefix, storageEntry] of Object.entries(cache)) {
+        if (key.startsWith(prefix))
+            return storageEntry;
+    }
+    const meta = await block.meta;
+    for (const module of Object.values(meta.query)) {
+        for (const storage of Object.values(module)) {
+            const keyPrefix = (0, util_1.u8aToHex)(storage.keyPrefix());
+            if (key.startsWith(keyPrefix)) {
+                cache[keyPrefix] = storage;
+                return storage;
+            }
+        }
+    }
+    throw new Error(`Cannot find key ${key}`);
+};
+const decodeKey = async (block, key) => {
+    const meta = await block.meta;
+    const storage = await getStorageEntry(block, key).catch(() => undefined);
+    const decodedKey = meta.registry.createType('StorageKey', key);
+    if (storage) {
+        decodedKey.setMeta(storage.meta);
+        return { storage, decodedKey };
+    }
+    return {};
+};
+exports.decodeKey = decodeKey;
+const decodeKeyValue = async (block, key, value) => {
+    const meta = await block.meta;
+    const { storage, decodedKey } = await (0, exports.decodeKey)(block, key);
+    if (!storage || !decodedKey) {
+        return { [key]: value };
+    }
+    const decodeValue = () => {
+        if (!value)
+            return null;
+        if (storage.section === 'substrate' && storage.method === 'code') {
+            return `:code blake2_256 ${(0, util_crypto_1.blake2AsHex)(value, 256)} (${(0, util_1.hexToU8a)(value).length} bytes)`;
+        }
+        return meta.registry.createType(decodedKey.outputType, (0, util_1.hexToU8a)(value)).toHuman();
+    };
+    switch (decodedKey.args.length) {
+        case 2: {
+            return {
+                [storage.section]: {
+                    [storage.method]: {
+                        [decodedKey.args[0].toString()]: {
+                            [decodedKey.args[1].toString()]: decodeValue(),
+                        },
+                    },
+                },
+            };
+        }
+        case 1: {
+            return {
+                [storage.section]: {
+                    [storage.method]: {
+                        [decodedKey.args[0].toString()]: decodeValue(),
+                    },
+                },
+            };
+        }
+        default:
+            return {
+                [storage.section]: {
+                    [storage.method]: decodeValue(),
+                },
+            };
+    }
+};
+exports.decodeKeyValue = decodeKeyValue;
+const decodeStorageDiff = async (block, diff) => {
+    const parent = await block.parentBlock;
+    if (!parent)
+        throw new Error('Cannot find parent block');
+    const oldState = {};
+    const newState = {};
+    for (const [key, value] of diff) {
+        lodash_1.default.merge(oldState, await (0, exports.decodeKeyValue)(parent, key, (await parent.get(key))));
+        lodash_1.default.merge(newState, await (0, exports.decodeKeyValue)(block, key, value));
+    }
+    return [oldState, newState, diffPatcher.diff(oldState, newState)];
+};
+exports.decodeStorageDiff = decodeStorageDiff;

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

@@ -0,0 +1,4 @@
+import { Block } from '../blockchain/block';
+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/dist/utils/generate-html-diff.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateHtmlDiffPreviewFile = exports.generateHtmlDiff = void 0;
+const decoder_1 = require("./decoder");
+const node_fs_1 = require("node:fs");
+const lodash_1 = require("lodash");
+const generateHtmlDiff = async (block, diff) => {
+    const [left, _right, delta] = await (0, decoder_1.decodeStorageDiff)(block, diff);
+    const htmlTemplate = (0, node_fs_1.readFileSync)('./template/diff.html', 'utf-8');
+    return (0, lodash_1.template)(htmlTemplate)({ left: JSON.stringify(left), delta: JSON.stringify(delta) });
+};
+exports.generateHtmlDiff = generateHtmlDiff;
+const generateHtmlDiffPreviewFile = async (block, diff, filename) => {
+    const html = await (0, exports.generateHtmlDiff)(block, diff);
+    (0, node_fs_1.mkdirSync)('./preview', { recursive: true });
+    const filePath = `./preview/${filename}.html`;
+    (0, node_fs_1.writeFileSync)(filePath, html);
+    return filePath;
+};
+exports.generateHtmlDiffPreviewFile = generateHtmlDiffPreviewFile;

package/dist/utils/index.d.ts

@@ -1,7 +1,9 @@
 import { HexString } from '@polkadot/util/types';
 import { StorageKey } from '@polkadot/types';
+import { Blockchain } from '../blockchain';
 export type GetKeys = (startKey?: string) => Promise<StorageKey<any>[]>;
 export type ProcessKey = (key: StorageKey<any>) => any;
 export declare function fetchKeys(getKeys: GetKeys, processKey: ProcessKey): Promise<void>;
 export declare function fetchKeysToArray(getKeys: GetKeys): Promise<StorageKey<any>[]>;
 export declare const compactHex: (value: Uint8Array) => HexString;
+export declare const getParaId: (chain: Blockchain) => Promise<import("@polkadot/types").u32>;

package/dist/utils/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compactHex = exports.fetchKeysToArray = exports.fetchKeys = void 0;
+exports.getParaId = exports.compactHex = exports.fetchKeysToArray = exports.fetchKeys = void 0;
 const util_1 = require("@polkadot/util");
 async function fetchKeys(getKeys, processKey) {
     const processKeys = async (keys) => {
@@ -30,3 +30,11 @@ const compactHex = (value) => {
     return (0, util_1.u8aToHex)((0, util_1.compactStripLength)(value)[1]);
 };
 exports.compactHex = compactHex;
+const getParaId = async (chain) => {
+    const meta = await chain.head.meta;
+    const raw = await chain.head.get((0, exports.compactHex)(meta.query.parachainInfo.parachainId()));
+    if (!raw)
+        throw new Error('Cannot find parachain id');
+    return meta.registry.createType('u32', (0, util_1.hexToU8a)(raw));
+};
+exports.getParaId = getParaId;

package/dist/utils/open-html.d.ts

@@ -0,0 +1 @@
+export declare const openHtml: (filePath: string) => void;

package/dist/utils/open-html.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openHtml = void 0;
+const node_child_process_1 = require("node:child_process");
+const openHtml = (filePath) => {
+    const start = process.platform == 'darwin' ? 'open' : process.platform == 'win32' ? 'start' : 'xdg-open';
+    (0, node_child_process_1.execSync)(start + ' ' + filePath);
+};
+exports.openHtml = openHtml;

package/dist/utils/proof.d.ts

@@ -1,7 +1,15 @@
-import { HexString } from '@polkadot/util/types';
+import { HrmpChannelId } from '@polkadot/types/interfaces';
 import { u32 } from '@polkadot/types';
-export declare const WELL_KNOWN_KEYS: Record<string, HexString>;
+export declare const WELL_KNOWN_KEYS: {
+    EPOCH_INDEX: `0x${string}`;
+    CURRENT_BLOCK_RANDOMNESS: `0x${string}`;
+    ONE_EPOCH_AGO_RANDOMNESS: `0x${string}`;
+    TWO_EPOCHS_AGO_RANDOMNESS: `0x${string}`;
+    CURRENT_SLOT: `0x${string}`;
+    ACTIVE_CONFIG: `0x${string}`;
+};
 export declare const dmqMqcHead: (paraId: u32) => `0x${string}`;
 export declare const upgradeGoAheadSignal: (paraId: u32) => `0x${string}`;
 export declare const hrmpIngressChannelIndex: (paraId: u32) => `0x${string}`;
 export declare const hrmpEgressChannelIndex: (paraId: u32) => `0x${string}`;
+export declare const hrmpChannels: (channelId: HrmpChannelId) => `0x${string}`;

package/dist/utils/proof.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hrmpEgressChannelIndex = exports.hrmpIngressChannelIndex = exports.upgradeGoAheadSignal = exports.dmqMqcHead = exports.WELL_KNOWN_KEYS = void 0;
+exports.hrmpChannels = exports.hrmpEgressChannelIndex = exports.hrmpIngressChannelIndex = exports.upgradeGoAheadSignal = exports.dmqMqcHead = exports.WELL_KNOWN_KEYS = void 0;
 const util_1 = require("@polkadot/util");
 const util_crypto_1 = require("@polkadot/util-crypto");
 exports.WELL_KNOWN_KEYS = {
@@ -11,27 +11,31 @@ exports.WELL_KNOWN_KEYS = {
     CURRENT_SLOT: '0x1cb6f36e027abb2091cfb5110ab5087f06155b3cd9a8c9e5e9a23fd5dc13a5ed',
     ACTIVE_CONFIG: '0x06de3d8a54d27e44a9d5ce189618f22db4b49d95320d9021994c850f25b8e385',
 };
-const prefixWithParaId = (prefix, paraId) => {
-    const id = paraId.toU8a();
-    return (0, util_1.u8aToHex)((0, util_1.u8aConcat)((0, util_1.hexToU8a)(prefix), (0, util_crypto_1.xxhashAsU8a)(id, 64), id));
+const hash = (prefix, suffix) => {
+    return (0, util_1.u8aToHex)((0, util_1.u8aConcat)((0, util_1.hexToU8a)(prefix), (0, util_crypto_1.xxhashAsU8a)(suffix, 64), suffix));
 };
 const dmqMqcHead = (paraId) => {
     const prefix = '0x63f78c98723ddc9073523ef3beefda0c4d7fefc408aac59dbfe80a72ac8e3ce5';
-    return prefixWithParaId(prefix, paraId);
+    return hash(prefix, paraId.toU8a());
 };
 exports.dmqMqcHead = dmqMqcHead;
 const upgradeGoAheadSignal = (paraId) => {
     const prefix = '0xcd710b30bd2eab0352ddcc26417aa1949e94c040f5e73d9b7addd6cb603d15d3';
-    return prefixWithParaId(prefix, paraId);
+    return hash(prefix, paraId.toU8a());
 };
 exports.upgradeGoAheadSignal = upgradeGoAheadSignal;
 const hrmpIngressChannelIndex = (paraId) => {
     const prefix = '0x6a0da05ca59913bc38a8630590f2627c1d3719f5b0b12c7105c073c507445948';
-    return prefixWithParaId(prefix, paraId);
+    return hash(prefix, paraId.toU8a());
 };
 exports.hrmpIngressChannelIndex = hrmpIngressChannelIndex;
 const hrmpEgressChannelIndex = (paraId) => {
     const prefix = '0x6a0da05ca59913bc38a8630590f2627cf12b746dcf32e843354583c9702cc020';
-    return prefixWithParaId(prefix, paraId);
+    return hash(prefix, paraId.toU8a());
 };
 exports.hrmpEgressChannelIndex = hrmpEgressChannelIndex;
+const hrmpChannels = (channelId) => {
+    const prefix = '0x6a0da05ca59913bc38a8630590f2627cb6604cff828a6e3f579ca6c59ace013d';
+    return hash(prefix, channelId.toU8a());
+};
+exports.hrmpChannels = hrmpChannels;

package/dist/utils/set-storage.d.ts

@@ -1,6 +1,7 @@
+import { HexString } from '@polkadot/util/types';
 import { Blockchain } from '../blockchain';
 type RawStorageValues = [string, string | null][];
 type StorageConfig = Record<string, Record<string, any>>;
 export type StorageValues = RawStorageValues | StorageConfig;
-export declare const setStorage: (chain: Blockchain, storage: StorageValues, blockHash?: string) => Promise<string>;
+export declare const setStorage: (chain: Blockchain, storage: StorageValues, blockHash?: HexString) => Promise<HexString>;
 export {};

package/dist/utils/time-travel.d.ts

@@ -0,0 +1,5 @@
+import { Blockchain } from '../blockchain';
+export declare const getCurrentSlot: (chain: Blockchain) => Promise<number>;
+export declare const getCurrentTimestamp: (chain: Blockchain) => Promise<number>;
+export declare const getSlotDuration: (chain: Blockchain) => Promise<number>;
+export declare const timeTravel: (chain: Blockchain, timestamp: number) => Promise<void>;

package/dist/utils/time-travel.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timeTravel = exports.getSlotDuration = exports.getCurrentTimestamp = exports.getCurrentSlot = void 0;
+const util_1 = require("@polkadot/util");
+const _1 = require(".");
+const executor_1 = require("../executor");
+const set_storage_1 = require("./set-storage");
+const getCurrentSlot = async (chain) => {
+    const meta = await chain.head.meta;
+    const slotRaw = meta.consts.babe
+        ? await chain.head.get((0, _1.compactHex)(meta.query.babe.currentSlot()))
+        : await chain.head.get((0, _1.compactHex)(meta.query.aura.currentSlot()));
+    if (!slotRaw)
+        throw new Error('Cannot find current slot');
+    return meta.registry.createType('Slot', (0, util_1.hexToU8a)(slotRaw)).toNumber();
+};
+exports.getCurrentSlot = getCurrentSlot;
+const getCurrentTimestamp = async (chain) => {
+    const meta = await chain.head.meta;
+    const currentTimestampRaw = (await chain.head.get((0, _1.compactHex)(meta.query.timestamp.now()))) || '0x';
+    return meta.registry.createType('u64', (0, util_1.hexToU8a)(currentTimestampRaw)).toNumber();
+};
+exports.getCurrentTimestamp = getCurrentTimestamp;
+const getSlotDuration = async (chain) => {
+    const meta = await chain.head.meta;
+    return meta.consts.babe
+        ? meta.consts.babe.expectedBlockTime.toNumber()
+        : meta.query.aura
+            ? (0, executor_1.getAuraSlotDuration)(await chain.head.wasm, meta.registry)
+            : 12_000;
+};
+exports.getSlotDuration = getSlotDuration;
+const timeTravel = async (chain, timestamp) => {
+    const meta = await chain.head.meta;
+    const slotDuration = await (0, exports.getSlotDuration)(chain);
+    const newSlot = Math.floor(timestamp / slotDuration);
+    // new timestamp
+    const storage = [
+        [(0, _1.compactHex)(meta.query.timestamp.now()), (0, util_1.u8aToHex)(meta.registry.createType('u64', timestamp).toU8a())],
+    ];
+    if (meta.consts.babe) {
+        // new slot
+        storage.push([
+            (0, _1.compactHex)(meta.query.babe.currentSlot()),
+            (0, util_1.u8aToHex)(meta.registry.createType('Slot', newSlot).toU8a()),
+        ]);
+        // new epoch
+        const epochDuration = meta.consts.babe.epochDuration.toNumber();
+        const newEpoch = Math.floor(timestamp / epochDuration);
+        storage.push([
+            (0, _1.compactHex)(meta.query.babe.epochIndex()),
+            (0, util_1.u8aToHex)(meta.registry.createType('u64', newEpoch).toU8a()),
+        ]);
+    }
+    else if (meta.query.aura) {
+        // new slot
+        storage.push([
+            (0, _1.compactHex)(meta.query.aura.currentSlot()),
+            (0, util_1.u8aToHex)(meta.registry.createType('Slot', newSlot).toU8a()),
+        ]);
+    }
+    await (0, set_storage_1.setStorage)(chain, storage);
+};
+exports.timeTravel = timeTravel;

package/dist/xcm/index.d.ts

@@ -0,0 +1,3 @@
+import { Blockchain } from '../blockchain';
+export declare const connectDownward: (relaychain: Blockchain, parachain: Blockchain) => Promise<void>;
+export declare const connectParachains: (parachains: Blockchain[]) => Promise<void>;

package/dist/xcm/index.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectParachains = exports.connectDownward = void 0;
+const util_1 = require("@polkadot/util");
+const utils_1 = require("../utils");
+const logger_1 = require("../logger");
+const set_storage_1 = require("../utils/set-storage");
+const logger = logger_1.defaultLogger.child({ name: 'xcm' });
+const connectDownward = async (relaychain, parachain) => {
+    const meta = await relaychain.head.meta;
+    const paraId = await (0, utils_1.getParaId)(parachain);
+    const downwardMessageQueuesKey = (0, utils_1.compactHex)(meta.query.dmp.downwardMessageQueues(paraId));
+    await relaychain.headState.subscribeStorage([downwardMessageQueuesKey], async (head, pairs) => {
+        const value = pairs[0][1];
+        if (!value)
+            return;
+        const meta = await relaychain.head.meta;
+        const downwardMessageQueuesKey = (0, utils_1.compactHex)(meta.query.dmp.downwardMessageQueues(paraId));
+        // clear relaychain message queue
+        await (0, set_storage_1.setStorage)(relaychain, [[downwardMessageQueuesKey, null]], head.hash);
+        const downwardMessages = meta.registry
+            .createType('Vec<PolkadotCorePrimitivesInboundDownwardMessage>', (0, util_1.hexToU8a)(value))
+            .toJSON();
+        logger.debug({ downwardMessages }, 'downward_message');
+        await parachain.newBlock({ inherent: { downwardMessages } });
+    });
+    logger.info(`Connected relaychain '${await relaychain.api.getSystemChain()}' with parachain '${await parachain.api.getSystemChain()}'`);
+};
+exports.connectDownward = connectDownward;
+const connectParachains = async (parachains) => {
+    const list = {};
+    for (const chain of parachains) {
+        const paraId = await (0, utils_1.getParaId)(chain);
+        list[paraId.toNumber()] = chain;
+    }
+    await connectHorizontal(list);
+    logger.info('Parachains connected');
+};
+exports.connectParachains = connectParachains;
+const connectHorizontal = async (parachains) => {
+    for (const [id, chain] of Object.entries(parachains)) {
+        const meta = await chain.head.meta;
+        const hrmpOutboundMessagesKey = (0, utils_1.compactHex)(meta.query.parachainSystem.hrmpOutboundMessages());
+        await chain.headState.subscribeStorage([hrmpOutboundMessagesKey], async (head, pairs) => {
+            const value = pairs[0][1];
+            if (!value)
+                return;
+            const meta = await chain.head.meta;
+            const hrmpOutboundMessagesKey = (0, utils_1.compactHex)(meta.query.parachainSystem.hrmpOutboundMessages());
+            // clear sender message queue
+            await (0, set_storage_1.setStorage)(chain, [[hrmpOutboundMessagesKey, null]], head.hash);
+            const outboundHrmpMessage = meta.registry
+                .createType('Vec<PolkadotCorePrimitivesOutboundHrmpMessage>', (0, util_1.hexToU8a)(value))
+                .toJSON();
+            logger.info({ outboundHrmpMessage }, 'outboundHrmpMessage');
+            for (const { recipient, data } of outboundHrmpMessage) {
+                const horizontalMessages = {
+                    [Number(id)]: [{ sentAt: chain.head.number, data }],
+                };
+                const receiver = parachains[recipient];
+                if (receiver) {
+                    await receiver.newBlock({ inherent: { horizontalMessages } });
+                }
+            }
+        });
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acala-network/chopsticks",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "author": "Bryan Chen <xlchen1291@gmail.com>",
@@ -24,10 +24,12 @@
     "test:dev": "LOG_LEVEL=trace vitest --inspect",
     "dev": "LOG_LEVEL=trace ts-node-dev --transpile-only --inspect --notify=false src/index.ts -- dev --config=configs/dev.yml",
     "dev:karura": "ts-node-dev --transpile-only --inspect --notify=false src/index.ts -- dev --config=configs/karura.yml",
-    "dev:acala": "ts-node-dev --transpile-only --inspect --notify=false src/index.ts -- dev --config=configs/acala.yml"
+    "dev:acala": "ts-node-dev --transpile-only --inspect --notify=false src/index.ts -- dev --config=configs/acala.yml",
+    "dev:moonriver": "ts-node-dev --transpile-only --inspect --notify=false src/index.ts -- dev --config=configs/moonriver.yml",
+    "dev:moonbeam": "ts-node-dev --transpile-only --inspect --notify=false src/index.ts -- dev --config=configs/moonbeam.yml"
   },
   "dependencies": {
-    "@acala-network/chopsticks-executor": "0.2.3",
+    "@acala-network/chopsticks-executor": "0.3.0",
     "@polkadot/api": "^9.10.1",
     "@polkadot/rpc-provider": "^9.10.1",
     "@polkadot/types": "^9.10.1",
@@ -35,8 +37,9 @@
     "@polkadot/types-known": "^9.10.1",
     "@polkadot/util": "^10.2.1",
     "@polkadot/util-crypto": "^10.2.1",
-    "axios": "^1.2.1",
+    "axios": "^1.2.2",
     "js-yaml": "^4.1.0",
+    "jsondiffpatch": "^0.4.1",
     "lodash": "^4.17.21",
     "pino": "^8.7.0",
     "pino-pretty": "^9.1.1",
@@ -51,13 +54,13 @@
   "devDependencies": {
     "@types/js-yaml": "^4.0.5",
     "@types/lodash": "^4.14.191",
-    "@types/node": "^18.11.10",
+    "@types/node": "^18.11.18",
     "@types/rimraf": "^3",
     "@types/ws": "^8.5.3",
-    "@types/yargs": "^17.0.15",
+    "@types/yargs": "^17.0.18",
     "@typescript-eslint/eslint-plugin": "^5.45.0",
     "@typescript-eslint/parser": "^5.45.0",
-    "eslint": "^8.29.0",
+    "eslint": "^8.31.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-import": "^2.26.0",
     "eslint-plugin-sort-imports-es6-autofix": "^0.6.0",

package/dist/bindings.d.ts

@@ -1,2 +0,0 @@
-import { Blockchain } from './blockchain';
-export declare const setupBindings: (chain: Blockchain) => void;