@acala-network/chopsticks-core 0.8.5-5 → 0.9.0

package/dist/esm/blockchain/index.js

@@ -0,0 +1,413 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Blockchain_instances, _Blockchain_runtimeLogLevel, _Blockchain_txpool, _Blockchain_inherentProvider, _Blockchain_head, _Blockchain_blocksByNumber, _Blockchain_blocksByHash, _Blockchain_loadingBlocks, _Blockchain_maxMemoryBlockCount, _Blockchain_registerBlock;
+import { blake2AsHex } from '@polkadot/util-crypto';
+import { u8aConcat, u8aToHex } from '@polkadot/util';
+import { Block } from './block';
+import { TxPool } from './txpool';
+import { HeadState } from './head-state';
+import { OffchainWorker } from '../offchain';
+import { compactHex } from '../utils';
+import { defaultLogger } from '../logger';
+import { dryRunExtrinsic, dryRunInherents } from './block-builder';
+import { releaseWorker } from '../wasm-executor';
+const logger = defaultLogger.child({ name: 'blockchain' });
+/**
+ * Local blockchain which provides access to blocks, txpool and methods
+ * to manipulate the chain such as build blocks, submit extrinsics, xcm and more!
+ *
+ * @example
+ *
+ * ```ts
+ * const chain = new Blockchain({
+ *  api,
+ *  buildBlockMode: BuildBlockMode.Manual,
+ *  inherentProvider: inherents,
+ *  header: {
+ *    hash: blockHash,
+ *    number: Number(header.number),
+ *  },
+ *  mockSignatureHost: true,
+ *  allowUnresolvedImports: true,
+ *  registeredTypes: {},
+ * })
+ * // build a block
+ * chain.newBlock()
+ * ```
+ */
+export class Blockchain {
+    /**
+     * @param options - Options for instantiating the blockchain
+     */
+    constructor({ api, buildBlockMode, inherentProvider, db, header, mockSignatureHost = false, allowUnresolvedImports = false, runtimeLogLevel = 0, registeredTypes = {}, offchainWorker = false, maxMemoryBlockCount = 500, }) {
+        _Blockchain_instances.add(this);
+        this.uid = Math.random().toString(36).substring(2);
+        _Blockchain_runtimeLogLevel.set(this, void 0);
+        _Blockchain_txpool.set(this, void 0);
+        _Blockchain_inherentProvider.set(this, void 0);
+        _Blockchain_head.set(this, void 0);
+        _Blockchain_blocksByNumber.set(this, new Map());
+        _Blockchain_blocksByHash.set(this, new Map());
+        _Blockchain_loadingBlocks.set(this, {}
+        /** For subscribing and managing the head state. */
+        );
+        _Blockchain_maxMemoryBlockCount.set(this, void 0);
+        this.api = api;
+        this.db = db;
+        this.mockSignatureHost = mockSignatureHost;
+        this.allowUnresolvedImports = allowUnresolvedImports;
+        __classPrivateFieldSet(this, _Blockchain_runtimeLogLevel, runtimeLogLevel, "f");
+        this.registeredTypes = registeredTypes;
+        __classPrivateFieldSet(this, _Blockchain_head, new Block(this, header.number, header.hash), "f");
+        __classPrivateFieldGet(this, _Blockchain_instances, "m", _Blockchain_registerBlock).call(this, __classPrivateFieldGet(this, _Blockchain_head, "f"));
+        __classPrivateFieldSet(this, _Blockchain_txpool, new TxPool(this, inherentProvider, buildBlockMode), "f");
+        __classPrivateFieldSet(this, _Blockchain_inherentProvider, inherentProvider, "f");
+        this.headState = new HeadState(__classPrivateFieldGet(this, _Blockchain_head, "f"));
+        if (offchainWorker) {
+            this.offchainWorker = new OffchainWorker();
+        }
+        __classPrivateFieldSet(this, _Blockchain_maxMemoryBlockCount, maxMemoryBlockCount, "f");
+    }
+    get head() {
+        return __classPrivateFieldGet(this, _Blockchain_head, "f");
+    }
+    get txPool() {
+        return __classPrivateFieldGet(this, _Blockchain_txpool, "f");
+    }
+    get runtimeLogLevel() {
+        return __classPrivateFieldGet(this, _Blockchain_runtimeLogLevel, "f");
+    }
+    set runtimeLogLevel(level) {
+        __classPrivateFieldSet(this, _Blockchain_runtimeLogLevel, level, "f");
+        logger.debug(`Runtime log level set to ${logger.level}`);
+    }
+    async saveBlockToDB(block) {
+        if (this.db) {
+            const { hash, number, header, extrinsics } = block;
+            // delete old ones with the same block number if any, keep the latest one
+            await this.db.saveBlock({
+                hash,
+                number,
+                header: (await header).toHex(),
+                extrinsics: await extrinsics,
+                parentHash: (await block.parentBlock)?.hash || null,
+                storageDiff: await block.storageDiff(),
+            });
+        }
+    }
+    /**
+     * Try to load block from db and register it.
+     * If pass in number, get block by number, else get block by hash.
+     */
+    async loadBlockFromDB(hashOrNumber) {
+        if (this.db) {
+            const blockData = typeof hashOrNumber === 'number'
+                ? await this.db.queryBlockByNumber(hashOrNumber)
+                : await this.db.queryBlock(hashOrNumber);
+            if (blockData) {
+                const { hash, number, header, extrinsics } = blockData;
+                const parentHash = blockData.parentHash || undefined;
+                let parentBlock = parentHash ? __classPrivateFieldGet(this, _Blockchain_blocksByHash, "f").get(parentHash) : undefined;
+                if (!parentBlock) {
+                    parentBlock = await this.getBlock(parentHash);
+                }
+                const storageDiff = blockData.storageDiff ?? undefined;
+                const registry = await this.head.registry;
+                const block = new Block(this, number, hash, parentBlock, {
+                    header: registry.createType('Header', header),
+                    extrinsics,
+                    storage: parentBlock?.storage,
+                    storageDiff,
+                });
+                __classPrivateFieldGet(this, _Blockchain_instances, "m", _Blockchain_registerBlock).call(this, block);
+                return block;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Get block by number.
+     */
+    async getBlockAt(number) {
+        if (number === null || number === undefined) {
+            return this.head;
+        }
+        if (number > __classPrivateFieldGet(this, _Blockchain_head, "f").number) {
+            return undefined;
+        }
+        if (!__classPrivateFieldGet(this, _Blockchain_blocksByNumber, "f").has(number)) {
+            const blockFromDB = await this.loadBlockFromDB(number);
+            if (blockFromDB) {
+                return blockFromDB;
+            }
+            const hash = await this.api.getBlockHash(number);
+            if (!hash) {
+                return undefined;
+            }
+            const block = new Block(this, number, hash);
+            __classPrivateFieldGet(this, _Blockchain_instances, "m", _Blockchain_registerBlock).call(this, block);
+        }
+        return __classPrivateFieldGet(this, _Blockchain_blocksByNumber, "f").get(number);
+    }
+    /**
+     * Get block by hash.
+     */
+    async getBlock(hash) {
+        await this.api.isReady;
+        if (hash == null) {
+            hash = this.head.hash;
+        }
+        if (!__classPrivateFieldGet(this, _Blockchain_blocksByHash, "f").has(hash)) {
+            const loadingBlock = __classPrivateFieldGet(this, _Blockchain_loadingBlocks, "f")[hash];
+            if (loadingBlock) {
+                await loadingBlock;
+            }
+            else {
+                const loadingBlock = (async () => {
+                    try {
+                        const blockFromDB = await this.loadBlockFromDB(hash);
+                        if (!blockFromDB) {
+                            const header = await this.api.getHeader(hash);
+                            if (!header) {
+                                throw new Error(`Block ${hash} not found`);
+                            }
+                            const block = new Block(this, Number(header.number), hash);
+                            __classPrivateFieldGet(this, _Blockchain_instances, "m", _Blockchain_registerBlock).call(this, block);
+                        }
+                    }
+                    catch (e) {
+                        logger.debug(`getBlock(${hash}) failed: ${e}`);
+                    }
+                })();
+                __classPrivateFieldGet(this, _Blockchain_loadingBlocks, "f")[hash] = loadingBlock;
+                await loadingBlock;
+                delete __classPrivateFieldGet(this, _Blockchain_loadingBlocks, "f")[hash];
+            }
+        }
+        return __classPrivateFieldGet(this, _Blockchain_blocksByHash, "f").get(hash);
+    }
+    /**
+     * Get all blocks in memory.
+     */
+    blocksInMemory() {
+        return Array.from(__classPrivateFieldGet(this, _Blockchain_blocksByNumber, "f").values());
+    }
+    /**
+     * Remove block from memory and db.
+     */
+    async unregisterBlock(block) {
+        if (block.hash === this.head.hash) {
+            throw new Error('Cannot unregister head block');
+        }
+        if (__classPrivateFieldGet(this, _Blockchain_blocksByNumber, "f").get(block.number)?.hash === block.hash) {
+            __classPrivateFieldGet(this, _Blockchain_blocksByNumber, "f").delete(block.number);
+        }
+        __classPrivateFieldGet(this, _Blockchain_blocksByHash, "f").delete(block.hash);
+        // delete from db
+        if (this.db) {
+            await this.db.deleteBlock(block.hash);
+        }
+    }
+    async onNewBlock(block) {
+        await this.setHead(block);
+        await this.saveBlockToDB(block);
+    }
+    /**
+     * Set block as head.
+     */
+    async setHead(block) {
+        logger.debug({
+            number: block.number,
+            hash: block.hash,
+        }, 'setHead');
+        __classPrivateFieldSet(this, _Blockchain_head, block, "f");
+        __classPrivateFieldGet(this, _Blockchain_instances, "m", _Blockchain_registerBlock).call(this, block);
+        await this.headState.setHead(block);
+        if (this.offchainWorker) {
+            await this.offchainWorker.run(block);
+        }
+    }
+    /**
+     * Submit extrinsic to txpool.
+     */
+    async submitExtrinsic(extrinsic) {
+        const validity = await this.validateExtrinsic(extrinsic);
+        if (validity.isOk) {
+            await __classPrivateFieldGet(this, _Blockchain_txpool, "f").submitExtrinsic(extrinsic);
+            return blake2AsHex(extrinsic, 256);
+        }
+        throw validity.asErr;
+    }
+    /**
+     * Validate extrinsic by calling `TaggedTransactionQueue_validate_transaction`.
+     */
+    async validateExtrinsic(extrinsic, source = '0x02' /** External */) {
+        const args = u8aToHex(u8aConcat(source, extrinsic, this.head.hash));
+        const res = await this.head.call('TaggedTransactionQueue_validate_transaction', [args]);
+        const registry = await this.head.registry;
+        return registry.createType('TransactionValidity', res.result);
+    }
+    submitUpwardMessages(id, ump) {
+        __classPrivateFieldGet(this, _Blockchain_txpool, "f").submitUpwardMessages(id, ump);
+        logger.debug({ id, ump }, 'submitUpwardMessages');
+    }
+    submitDownwardMessages(dmp) {
+        __classPrivateFieldGet(this, _Blockchain_txpool, "f").submitDownwardMessages(dmp);
+        logger.debug({ dmp }, 'submitDownwardMessages');
+    }
+    submitHorizontalMessages(id, hrmp) {
+        __classPrivateFieldGet(this, _Blockchain_txpool, "f").submitHorizontalMessages(id, hrmp);
+        logger.debug({ id, hrmp }, 'submitHorizontalMessages');
+    }
+    /**
+     * Build a new block with optional params. Use this when you don't have all the {@link BuildBlockParams}
+     */
+    async newBlock(params) {
+        await __classPrivateFieldGet(this, _Blockchain_txpool, "f").buildBlock(params);
+        return __classPrivateFieldGet(this, _Blockchain_head, "f");
+    }
+    /**
+     * Build a new block with {@link BuildBlockParams}.
+     */
+    async newBlockWithParams(params) {
+        await __classPrivateFieldGet(this, _Blockchain_txpool, "f").buildBlockWithParams(params);
+        return __classPrivateFieldGet(this, _Blockchain_head, "f");
+    }
+    /**
+     * Get the upcoming blocks.
+     */
+    async upcomingBlocks() {
+        return __classPrivateFieldGet(this, _Blockchain_txpool, "f").upcomingBlocks();
+    }
+    /**
+     * Dry run extrinsic in block `at`.
+     */
+    async dryRunExtrinsic(extrinsic, at) {
+        await this.api.isReady;
+        const head = at ? await this.getBlock(at) : this.head;
+        if (!head) {
+            throw new Error(`Cannot find block ${at}`);
+        }
+        const registry = await head.registry;
+        const inherents = await __classPrivateFieldGet(this, _Blockchain_inherentProvider, "f").createInherents(head, {
+            transactions: [],
+            downwardMessages: [],
+            upwardMessages: [],
+            horizontalMessages: {},
+        });
+        const { result, storageDiff } = await dryRunExtrinsic(head, inherents, extrinsic);
+        const outcome = registry.createType('ApplyExtrinsicResult', result);
+        return { outcome, storageDiff };
+    }
+    /**
+     * Dry run hrmp messages in block `at`.
+     * Return the storage diff.
+     */
+    async dryRunHrmp(hrmp, at) {
+        await this.api.isReady;
+        const head = at ? await this.getBlock(at) : this.head;
+        if (!head) {
+            throw new Error(`Cannot find block ${at}`);
+        }
+        const inherents = await __classPrivateFieldGet(this, _Blockchain_inherentProvider, "f").createInherents(head, {
+            transactions: [],
+            downwardMessages: [],
+            upwardMessages: [],
+            horizontalMessages: hrmp,
+        });
+        return dryRunInherents(head, inherents);
+    }
+    /**
+     * Dry run dmp messages in block `at`.
+     * Return the storage diff.
+     */
+    async dryRunDmp(dmp, at) {
+        await this.api.isReady;
+        const head = at ? await this.getBlock(at) : this.head;
+        if (!head) {
+            throw new Error(`Cannot find block ${at}`);
+        }
+        const inherents = await __classPrivateFieldGet(this, _Blockchain_inherentProvider, "f").createInherents(head, {
+            transactions: [],
+            downwardMessages: dmp,
+            upwardMessages: [],
+            horizontalMessages: {},
+        });
+        return dryRunInherents(head, inherents);
+    }
+    /**
+     * Dry run ump messages in block `at`.
+     * Return the storage diff.
+     */
+    async dryRunUmp(ump, at) {
+        await this.api.isReady;
+        const head = at ? await this.getBlock(at) : this.head;
+        if (!head) {
+            throw new Error(`Cannot find block ${at}`);
+        }
+        const meta = await head.meta;
+        const needsDispatch = meta.registry.createType('Vec<u32>', Object.keys(ump));
+        const storageValues = [
+            [compactHex(meta.query.ump.needsDispatch()), needsDispatch.toHex()],
+        ];
+        for (const [paraId, messages] of Object.entries(ump)) {
+            const upwardMessages = meta.registry.createType('Vec<Bytes>', messages);
+            if (upwardMessages.length === 0)
+                throw new Error('No upward meesage');
+            const queueSize = meta.registry.createType('(u32, u32)', [
+                upwardMessages.length,
+                upwardMessages.map((x) => x.byteLength).reduce((s, i) => s + i, 0),
+            ]);
+            storageValues.push([compactHex(meta.query.ump.relayDispatchQueues(paraId)), upwardMessages.toHex()]);
+            storageValues.push([compactHex(meta.query.ump.relayDispatchQueueSize(paraId)), queueSize.toHex()]);
+        }
+        head.pushStorageLayer().setAll(storageValues);
+        const inherents = await __classPrivateFieldGet(this, _Blockchain_inherentProvider, "f").createInherents(head, {
+            transactions: [],
+            downwardMessages: [],
+            upwardMessages: [],
+            horizontalMessages: {},
+        });
+        return dryRunInherents(head, inherents);
+    }
+    /**
+     * Get inherents of head.
+     */
+    async getInherents() {
+        await this.api.isReady;
+        const inherents = await __classPrivateFieldGet(this, _Blockchain_inherentProvider, "f").createInherents(this.head, {
+            transactions: [],
+            downwardMessages: [],
+            upwardMessages: [],
+            horizontalMessages: {},
+        });
+        return inherents;
+    }
+    /**
+     * Close the db and release worker.
+     */
+    async close() {
+        await releaseWorker();
+        await this.api.disconnect();
+        await this.db?.close();
+    }
+}
+_Blockchain_runtimeLogLevel = new WeakMap(), _Blockchain_txpool = new WeakMap(), _Blockchain_inherentProvider = new WeakMap(), _Blockchain_head = new WeakMap(), _Blockchain_blocksByNumber = new WeakMap(), _Blockchain_blocksByHash = new WeakMap(), _Blockchain_loadingBlocks = new WeakMap(), _Blockchain_maxMemoryBlockCount = new WeakMap(), _Blockchain_instances = new WeakSet(), _Blockchain_registerBlock = function _Blockchain_registerBlock(block) {
+    // if exceed max memory block count, delete the oldest block
+    if (__classPrivateFieldGet(this, _Blockchain_blocksByNumber, "f").size === __classPrivateFieldGet(this, _Blockchain_maxMemoryBlockCount, "f")) {
+        const { hash, number } = __classPrivateFieldGet(this, _Blockchain_blocksByNumber, "f").values().next().value;
+        __classPrivateFieldGet(this, _Blockchain_blocksByNumber, "f").delete(number);
+        __classPrivateFieldGet(this, _Blockchain_blocksByHash, "f").delete(hash);
+    }
+    __classPrivateFieldGet(this, _Blockchain_blocksByNumber, "f").set(block.number, block);
+    __classPrivateFieldGet(this, _Blockchain_blocksByHash, "f").set(block.hash, block);
+};

package/dist/esm/blockchain/inherent/index.js

@@ -0,0 +1,40 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _InherentProviders_base, _InherentProviders_providers;
+import { GenericExtrinsic } from '@polkadot/types';
+import { getCurrentTimestamp, getSlotDuration } from '../../utils/time-travel';
+export { SetValidationData } from './parachain/validation-data';
+export { ParaInherentEnter } from './para-enter';
+export { SetBabeRandomness } from './parachain/babe-randomness';
+export { SetNimbusAuthorInherent } from './parachain/nimbus-author-inherent';
+export class SetTimestamp {
+    async createInherents(parent) {
+        const meta = await parent.meta;
+        const slotDuration = await getSlotDuration(parent.chain);
+        const currentTimestamp = await getCurrentTimestamp(parent.chain);
+        return [new GenericExtrinsic(meta.registry, meta.tx.timestamp.set(currentTimestamp + BigInt(slotDuration))).toHex()];
+    }
+}
+export class InherentProviders {
+    constructor(base, providers) {
+        _InherentProviders_base.set(this, void 0);
+        _InherentProviders_providers.set(this, void 0);
+        __classPrivateFieldSet(this, _InherentProviders_base, base, "f");
+        __classPrivateFieldSet(this, _InherentProviders_providers, providers, "f");
+    }
+    async createInherents(parent, params) {
+        const base = await __classPrivateFieldGet(this, _InherentProviders_base, "f").createInherents(parent, params);
+        const extra = await Promise.all(__classPrivateFieldGet(this, _InherentProviders_providers, "f").map((provider) => provider.createInherents(parent, params)));
+        return [...base, ...extra.flat()];
+    }
+}
+_InherentProviders_base = new WeakMap(), _InherentProviders_providers = new WeakMap();

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

@@ -0,0 +1,29 @@
+import { GenericExtrinsic } from '@polkadot/types';
+export 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 GenericExtrinsic(meta.registry, meta.tx.paraInherent.enter(newData)).toHex()];
+    }
+}

package/dist/esm/blockchain/inherent/parachain/babe-randomness.js

@@ -0,0 +1,11 @@
+import { GenericExtrinsic } from '@polkadot/types';
+// Support for Moonbeam pallet-randomness mandatory inherent
+export class SetBabeRandomness {
+    async createInherents(parent, _params) {
+        const meta = await parent.meta;
+        if (!meta.tx.randomness?.setBabeRandomnessResults) {
+            return [];
+        }
+        return [new GenericExtrinsic(meta.registry, meta.tx.randomness.setBabeRandomnessResults()).toHex()];
+    }
+}

package/dist/esm/blockchain/inherent/parachain/nimbus-author-inherent.js

@@ -0,0 +1,11 @@
+import { GenericExtrinsic } from '@polkadot/types';
+// Support for Nimbus Author Inherent
+export class SetNimbusAuthorInherent {
+    async createInherents(parent, _params) {
+        const meta = await parent.meta;
+        if (!meta.tx.authorInherent?.kickOffAuthorshipValidation) {
+            return [];
+        }
+        return [new GenericExtrinsic(meta.registry, meta.tx.authorInherent.kickOffAuthorshipValidation()).toHex()];
+    }
+}