@acala-network/chopsticks 0.2.2 → 0.3.0

package/dist/blockchain/index.d.ts

@@ -1,35 +1,36 @@
 import { DataSource } from 'typeorm';
-import { Header } from '@polkadot/types/interfaces';
+import { HexString } from '@polkadot/util/types';
 import { Api } from '../api';
 import { Block } from './block';
-import { BuildBlockMode } from './txpool';
+import { BuildBlockMode, BuildBlockParams } from './txpool';
 import { HeadState } from './head-state';
-import { InherentProvider } from './inherents';
-import { TaskManager } from '../task';
+import { InherentProvider } from './inherent';
 export interface Options {
     api: Api;
-    tasks: TaskManager;
     buildBlockMode?: BuildBlockMode;
     inherentProvider: InherentProvider;
     db?: DataSource;
     header: {
         number: number;
-        hash: string;
+        hash: HexString;
     };
+    mockSignatureHost?: boolean;
+    allowUnresolvedImports?: boolean;
 }
 export declare class Blockchain {
     #private;
     readonly api: Api;
-    readonly tasks: TaskManager;
     readonly db: DataSource | undefined;
+    readonly mockSignatureHost: boolean;
+    readonly allowUnresolvedImports: boolean;
     readonly headState: HeadState;
-    constructor({ api, tasks, buildBlockMode, inherentProvider, db, header }: Options);
+    constructor({ api, buildBlockMode, inherentProvider, db, header, mockSignatureHost, allowUnresolvedImports, }: Options);
     get head(): Block;
+    get pendingExtrinsics(): HexString[];
     getBlockAt(number?: number): Promise<Block | undefined>;
-    getBlock(hash?: string): Promise<Block | undefined>;
-    newTempBlock(parent: Block, header: Header): Block;
+    getBlock(hash?: HexString): Promise<Block | undefined>;
     unregisterBlock(block: Block): void;
-    setHead(block: Block): void;
-    submitExtrinsic(extrinsic: string): Promise<string>;
-    newBlock(): Promise<Block>;
+    setHead(block: Block): Promise<void>;
+    submitExtrinsic(extrinsic: HexString): Promise<HexString>;
+    newBlock(params?: BuildBlockParams): Promise<Block>;
 }

package/dist/blockchain/index.js

@@ -6,22 +6,24 @@ const util_1 = require("@polkadot/util");
 const block_1 = require("./block");
 const txpool_1 = require("./txpool");
 const head_state_1 = require("./head-state");
-const shared_1 = require("../rpc/shared");
 const logger_1 = require("../logger");
 const logger = logger_1.defaultLogger.child({ name: 'blockchain' });
 class Blockchain {
     api;
-    tasks;
     db;
+    mockSignatureHost;
+    allowUnresolvedImports;
     #txpool;
     #head;
     #blocksByNumber = [];
     #blocksByHash = {};
+    #loadingBlocks = {};
     headState;
-    constructor({ api, tasks, buildBlockMode, inherentProvider, db, header }) {
+    constructor({ api, buildBlockMode, inherentProvider, db, header, mockSignatureHost = false, allowUnresolvedImports = false, }) {
         this.api = api;
-        this.tasks = tasks;
         this.db = db;
+        this.mockSignatureHost = mockSignatureHost;
+        this.allowUnresolvedImports = allowUnresolvedImports;
         this.#head = new block_1.Block(this, header.number, header.hash);
         this.#registerBlock(this.#head);
         this.#txpool = new txpool_1.TxPool(this, inherentProvider, buildBlockMode);
@@ -34,6 +36,9 @@ class Blockchain {
     get head() {
         return this.#head;
     }
+    get pendingExtrinsics() {
+        return this.#txpool.pendingExtrinsics;
+    }
     async getBlockAt(number) {
         if (number === undefined) {
             return this.head;
@@ -54,29 +59,28 @@ class Blockchain {
             hash = this.head.hash;
         }
         if (!this.#blocksByHash[hash]) {
-            try {
-                const registry = await this.head.registry;
-                const header = registry.createType('Header', await this.api.getHeader(hash));
-                const block = new block_1.Block(this, header.number.toNumber(), hash);
-                this.#registerBlock(block);
+            const loadingBlock = this.#loadingBlocks[hash];
+            if (loadingBlock) {
+                await loadingBlock;
             }
-            catch (e) {
-                logger.debug(`getBlock(${hash}) failed: ${e}`);
-                return undefined;
+            else {
+                const loadingBlock = (async () => {
+                    try {
+                        const header = await this.api.getHeader(hash);
+                        const block = new block_1.Block(this, Number(header.number), hash);
+                        this.#registerBlock(block);
+                    }
+                    catch (e) {
+                        logger.debug(`getBlock(${hash}) failed: ${e}`);
+                    }
+                })();
+                this.#loadingBlocks[hash] = loadingBlock;
+                await loadingBlock;
+                delete this.#loadingBlocks[hash];
             }
         }
         return this.#blocksByHash[hash];
     }
-    newTempBlock(parent, header) {
-        const number = parent.number + 1;
-        const hash = '0x' +
-            Math.round(Math.random() * 100000000)
-                .toString(16)
-                .padEnd(64, '0');
-        const block = new block_1.Block(this, number, hash, parent, { header, extrinsics: [], storage: parent.storage });
-        this.#blocksByHash[hash] = block;
-        return block;
-    }
     unregisterBlock(block) {
         if (block.hash === this.head.hash) {
             throw new Error('Cannot unregister head block');
@@ -86,14 +90,14 @@ class Blockchain {
         }
         delete this.#blocksByHash[block.hash];
     }
-    setHead(block) {
+    async setHead(block) {
         logger.debug({
             number: block.number,
             hash: block.hash,
         }, 'setHead');
         this.#head = block;
         this.#registerBlock(block);
-        this.headState.setHead(block);
+        await this.headState.setHead(block);
     }
     async submitExtrinsic(extrinsic) {
         const source = '0x02'; // External
@@ -105,10 +109,10 @@ class Blockchain {
             this.#txpool.submitExtrinsic(extrinsic);
             return (0, util_crypto_1.blake2AsHex)(extrinsic, 256);
         }
-        throw new shared_1.ResponseError(1, `Extrinsic is invalid: ${validity.asErr.toString()}`);
+        throw new Error(`Extrinsic is invalid: ${validity.asErr.toString()}`);
     }
-    async newBlock() {
-        await this.#txpool.buildBlock();
+    async newBlock(params) {
+        await this.#txpool.buildBlock(params);
         return this.#head;
     }
 }

package/dist/blockchain/inherent/index.d.ts

@@ -0,0 +1,17 @@
+import { Block } from '../block';
+import { BuildBlockParams } from '../txpool';
+import { HexString } from '@polkadot/util/types';
+export { SetValidationData } from './parachain/validation-data';
+export { ParaInherentEnter } from './para-enter';
+export interface CreateInherents {
+    createInherents(parent: Block, params?: BuildBlockParams['inherent']): Promise<HexString[]>;
+}
+export type InherentProvider = CreateInherents;
+export declare class SetTimestamp implements InherentProvider {
+    createInherents(parent: Block): Promise<HexString[]>;
+}
+export declare class InherentProviders implements InherentProvider {
+    #private;
+    constructor(base: InherentProvider, providers: CreateInherents[]);
+    createInherents(parent: Block, params?: BuildBlockParams['inherent']): Promise<HexString[]>;
+}

package/dist/blockchain/inherent/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InherentProviders = exports.SetTimestamp = exports.ParaInherentEnter = exports.SetValidationData = void 0;
+const types_1 = require("@polkadot/types");
+const time_travel_1 = require("../../utils/time-travel");
+var validation_data_1 = require("./parachain/validation-data");
+Object.defineProperty(exports, "SetValidationData", { enumerable: true, get: function () { return validation_data_1.SetValidationData; } });
+var para_enter_1 = require("./para-enter");
+Object.defineProperty(exports, "ParaInherentEnter", { enumerable: true, get: function () { return para_enter_1.ParaInherentEnter; } });
+class SetTimestamp {
+    async createInherents(parent) {
+        const meta = await parent.meta;
+        const slotDuration = await (0, time_travel_1.getSlotDuration)(parent.chain);
+        const currentTimestamp = await (0, time_travel_1.getCurrentTimestamp)(parent.chain);
+        return [new types_1.GenericExtrinsic(meta.registry, meta.tx.timestamp.set(currentTimestamp + slotDuration)).toHex()];
+    }
+}
+exports.SetTimestamp = SetTimestamp;
+class InherentProviders {
+    #base;
+    #providers;
+    constructor(base, providers) {
+        this.#base = base;
+        this.#providers = providers;
+    }
+    async createInherents(parent, params) {
+        const base = await this.#base.createInherents(parent, params);
+        const extra = await Promise.all(this.#providers.map((provider) => provider.createInherents(parent, params)));
+        return [...base, ...extra.flat()];
+    }
+}
+exports.InherentProviders = InherentProviders;

package/dist/blockchain/inherent/para-enter.d.ts

@@ -0,0 +1,7 @@
+import { HexString } from '@polkadot/util/types';
+import { Block } from '../block';
+import { BuildBlockParams } from '../txpool';
+import { CreateInherents } from '.';
+export declare class ParaInherentEnter implements CreateInherents {
+    createInherents(parent: Block, _params?: BuildBlockParams['inherent']): Promise<HexString[]>;
+}

package/dist/blockchain/inherent/para-enter.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParaInherentEnter = void 0;
+const types_1 = require("@polkadot/types");
+class ParaInherentEnter {
+    async createInherents(parent, _params) {
+        const meta = await parent.meta;
+        if (!meta.tx.paraInherent?.enter) {
+            return [];
+        }
+        const extrinsics = await parent.extrinsics;
+        const paraEnterExtrinsic = extrinsics.find((extrinsic) => {
+            const firstArg = meta.registry.createType('GenericExtrinsic', extrinsic)?.args?.[0];
+            return firstArg && 'bitfields' in firstArg;
+        });
+        if (!paraEnterExtrinsic) {
+            throw new Error('Missing paraInherent data from block');
+        }
+        const extrinsic = meta.registry
+            .createType('GenericExtrinsic', paraEnterExtrinsic)
+            .args[0].toJSON();
+        const parentHeader = (await parent.header).toJSON();
+        const newData = {
+            ...extrinsic,
+            bitfields: [],
+            backedCandidates: [],
+            parentHeader,
+        };
+        // TODO: fill with data
+        return [new types_1.GenericExtrinsic(meta.registry, meta.tx.paraInherent.enter(newData)).toHex()];
+    }
+}
+exports.ParaInherentEnter = ParaInherentEnter;

package/dist/blockchain/inherent/parachain/validation-data.d.ts

@@ -0,0 +1,25 @@
+import { HexString } from '@polkadot/util/types';
+import { Block } from '../../../blockchain/block';
+import { BuildBlockParams } from '../../txpool';
+import { CreateInherents } from '..';
+export type ValidationData = {
+    downwardMessages: {
+        sent_at: number;
+        msg: HexString;
+    }[];
+    horizontalMessages: Record<number, {
+        sent_at: number;
+        data: HexString;
+    }[]>;
+    validationData: {
+        relayParentNumber: number;
+        relayParentStorageRoot: HexString;
+        maxPovSize: number;
+    };
+    relayChainState: {
+        trieNodes: HexString[];
+    };
+};
+export declare class SetValidationData implements CreateInherents {
+    createInherents(parent: Block, params?: BuildBlockParams['inherent']): Promise<HexString[]>;
+}

package/dist/blockchain/{inherents.js → inherent/parachain/validation-data.js}

@@ -1,24 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SetValidationData = exports.InherentProviders = exports.SetTimestamp = void 0;
+exports.SetValidationData = void 0;
 const types_1 = require("@polkadot/types");
-const utils_1 = require("../utils");
-const executor_1 = require("../executor");
 const util_1 = require("@polkadot/util");
-const proof_1 = require("../utils/proof");
-class SetTimestamp {
-    #getTimestamp;
-    constructor(getTimestamp = Date.now) {
-        this.#getTimestamp = getTimestamp;
-    }
-    async createInherents(meta, timestamp, _parent) {
-        return [new types_1.GenericExtrinsic(meta.registry, meta.tx.timestamp.set(timestamp)).toHex()];
-    }
-    getTimestamp(blockNumber) {
-        return this.#getTimestamp(blockNumber);
-    }
-}
-exports.SetTimestamp = SetTimestamp;
+const util_crypto_1 = require("@polkadot/util-crypto");
+const utils_1 = require("../../../utils");
+const executor_1 = require("../../../executor");
+const proof_1 = require("../../../utils/proof");
 const MOCK_VALIDATION_DATA = {
     validationData: {
         relayParentNumber: 1000,
@@ -43,60 +31,104 @@ const MOCK_VALIDATION_DATA = {
         ],
     },
 };
-class InherentProviders {
-    #base;
-    #providers;
-    constructor(base, providers) {
-        this.#base = base;
-        this.#providers = providers;
-    }
-    async createInherents(meta, timestamp, parent) {
-        const base = await this.#base.createInherents(meta, timestamp, parent);
-        const extra = await Promise.all(this.#providers.map((provider) => provider.createInherents(meta, timestamp, parent)));
-        return [...base, ...extra.flat()];
-    }
-    getTimestamp(blockNumber) {
-        return this.#base.getTimestamp(blockNumber);
-    }
-}
-exports.InherentProviders = InherentProviders;
 class SetValidationData {
-    #tasks;
-    #expectedIndex;
-    constructor(tasks, expectedIndex) {
-        this.#tasks = tasks;
-        this.#expectedIndex = expectedIndex;
-    }
-    async createInherents(meta, _timestamp, parent) {
+    async createInherents(parent, params) {
+        const meta = await parent.meta;
         if (!meta.tx.parachainSystem?.setValidationData) {
             return [];
         }
-        void this.#tasks; // TODO
-        const parentBlock = await parent.parentBlock;
-        if (!parentBlock) {
-            throw new Error('Parent block not found');
-        }
-        const extrinsics = await parentBlock.extrinsics;
+        const extrinsics = await parent.extrinsics;
         let newData;
-        if (parentBlock.number === 0) {
+        if (parent.number === 0) {
             // chain started with genesis, mock 1st validationData
             newData = MOCK_VALIDATION_DATA;
         }
         else {
-            const method = meta.registry.createType('GenericExtrinsic', extrinsics[this.#expectedIndex]);
-            const extrinsic = method.args[0].toJSON();
+            const validationDataExtrinsic = extrinsics.find((extrinsic) => {
+                const firstArg = meta.registry.createType('GenericExtrinsic', extrinsic)?.args?.[0];
+                return firstArg && 'validationData' in firstArg;
+            });
+            if (!validationDataExtrinsic) {
+                throw new Error('Missing validation data from block');
+            }
+            const extrinsic = meta.registry
+                .createType('GenericExtrinsic', validationDataExtrinsic)
+                .args[0].toJSON();
             const newEntries = [];
-            const upgrade = await parentBlock.get((0, utils_1.compactHex)(meta.query.parachainSystem.pendingValidationCode()));
-            if (upgrade) {
-                const paraIdStorage = await parentBlock.get((0, utils_1.compactHex)(meta.query.parachainInfo.parachainId()));
-                const paraId = meta.registry.createType('u32', (0, util_1.hexToU8a)(paraIdStorage));
-                const upgradeKey = (0, proof_1.upgradeGoAheadSignal)(paraId);
+            const downwardMessages = [];
+            const horizontalMessages = {};
+            const paraId = await (0, utils_1.getParaId)(parent.chain);
+            const dmqMqcHeadKey = (0, proof_1.dmqMqcHead)(paraId);
+            const hrmpIngressChannelIndexKey = (0, proof_1.hrmpIngressChannelIndex)(paraId);
+            const decoded = await (0, executor_1.decodeProof)(extrinsic.validationData.relayParentStorageRoot, [dmqMqcHeadKey, hrmpIngressChannelIndexKey], extrinsic.relayChainState.trieNodes);
+            // inject downward messages
+            if (params?.downwardMessages) {
+                let dmqMqcHeadHash = decoded[dmqMqcHeadKey];
+                if (!dmqMqcHeadHash)
+                    throw new Error('Canoot find dmqMqcHead from validation data');
+                for (const { msg, sentAt } of params.downwardMessages) {
+                    // calculate new hash
+                    dmqMqcHeadHash = (0, util_crypto_1.blake2AsHex)((0, util_1.u8aConcat)(meta.registry.createType('Hash', dmqMqcHeadHash).toU8a(), meta.registry.createType('BlockNumber', sentAt).toU8a(), (0, util_crypto_1.blake2AsU8a)(meta.registry.createType('Bytes', msg).toU8a(), 256)), 256);
+                    downwardMessages.push({
+                        msg,
+                        sent_at: sentAt,
+                    });
+                }
+                newEntries.push([dmqMqcHeadKey, dmqMqcHeadHash]);
+            }
+            const hrmpIngressChannels = meta.registry
+                .createType('Vec<ParaId>', decoded[hrmpIngressChannelIndexKey])
+                .toJSON();
+            // inject horizontal messages
+            if (params?.horizontalMessages) {
+                for (const [id, messages] of Object.entries(params.horizontalMessages)) {
+                    const sender = Number(id);
+                    if (hrmpIngressChannels.includes(sender)) {
+                        const channelId = meta.registry.createType('HrmpChannelId', {
+                            sender,
+                            receiver: paraId.toNumber(),
+                        });
+                        const hrmpChannelKey = (0, proof_1.hrmpChannels)(channelId);
+                        const decoded = await (0, executor_1.decodeProof)(extrinsic.validationData.relayParentStorageRoot, [hrmpChannelKey], extrinsic.relayChainState.trieNodes);
+                        const abridgedHrmpRaw = decoded[hrmpChannelKey];
+                        if (!abridgedHrmpRaw)
+                            throw new Error('Canoot find hrmp channels from validation data');
+                        const abridgedHrmp = meta.registry
+                            .createType('AbridgedHrmpChannel', (0, util_1.hexToU8a)(abridgedHrmpRaw))
+                            .toJSON();
+                        const paraMessages = [];
+                        for (const { data, sentAt } of messages) {
+                            // calculate new hash
+                            const bytes = meta.registry.createType('Bytes', data);
+                            abridgedHrmp.mqcHead = (0, util_crypto_1.blake2AsHex)((0, util_1.u8aConcat)(meta.registry.createType('Hash', abridgedHrmp.mqcHead).toU8a(), meta.registry.createType('BlockNumber', sentAt).toU8a(), (0, util_crypto_1.blake2AsU8a)(bytes.toU8a(), 256)), 256);
+                            abridgedHrmp.msgCount = abridgedHrmp.msgCount + 1;
+                            abridgedHrmp.totalSize = abridgedHrmp.totalSize + bytes.length;
+                            paraMessages.push({
+                                data,
+                                sent_at: sentAt,
+                            });
+                        }
+                        horizontalMessages[sender] = paraMessages;
+                        newEntries.push([hrmpChannelKey, meta.registry.createType('AbridgedHrmpChannel', abridgedHrmp).toHex()]);
+                    }
+                }
+            }
+            const upgradeKey = (0, proof_1.upgradeGoAheadSignal)(paraId);
+            const pendingUpgrade = await parent.get((0, utils_1.compactHex)(meta.query.parachainSystem.pendingValidationCode()));
+            if (pendingUpgrade) {
+                // send goAhead signal
                 const goAhead = meta.registry.createType('UpgradeGoAhead', 'GoAhead');
                 newEntries.push([upgradeKey, goAhead.toHex()]);
             }
+            else {
+                // make sure previous goAhead is removed
+                newEntries.push([upgradeKey, null]);
+            }
             const { trieRootHash, nodes } = await (0, executor_1.createProof)(extrinsic.validationData.relayParentStorageRoot, extrinsic.relayChainState.trieNodes, newEntries);
             newData = {
                 ...extrinsic,
+                downwardMessages,
+                horizontalMessages,
                 validationData: {
                     ...extrinsic.validationData,
                     relayParentStorageRoot: trieRootHash,

package/dist/blockchain/txpool.d.ts

@@ -1,13 +1,29 @@
+import { HexString } from '@polkadot/util/types';
 import { Blockchain } from '.';
-import { InherentProvider } from './inherents';
+import { InherentProvider } from './inherent';
 export declare enum BuildBlockMode {
     Batch = 0,
     Instant = 1,
     Manual = 2
 }
+export interface DownwardMessage {
+    sentAt: number;
+    msg: HexString;
+}
+export interface HorizontalMessage {
+    sentAt: number;
+    data: HexString;
+}
+export interface BuildBlockParams {
+    inherent?: {
+        downwardMessages?: DownwardMessage[];
+        horizontalMessages?: Record<number, HorizontalMessage[]>;
+    };
+}
 export declare class TxPool {
     #private;
     constructor(chain: Blockchain, inherentProvider: InherentProvider, mode?: BuildBlockMode);
-    submitExtrinsic(extrinsic: string): void;
-    buildBlock(): Promise<void>;
+    get pendingExtrinsics(): HexString[];
+    submitExtrinsic(extrinsic: HexString): void;
+    buildBlock(params?: BuildBlockParams): Promise<void>;
 }