@acala-network/chopsticks-core 0.8.0-0

package/lib/blockchain/index.js

@@ -0,0 +1,351 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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_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 { BlockEntity } from '../db/entities';
+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';
+const logger = defaultLogger.child({ name: 'blockchain' });
+export class Blockchain {
+    constructor({ api, buildBlockMode, inherentProvider, db, header, mockSignatureHost = false, allowUnresolvedImports = false, runtimeLogLevel = 0, registeredTypes = {}, offchainWorker = false, maxMemoryBlockCount = 2000, }) {
+        _Blockchain_instances.add(this);
+        this.uid = Math.random().toString(36).substring(2);
+        _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, {});
+        _Blockchain_loadingBlocks.set(this, {});
+        _Blockchain_maxMemoryBlockCount.set(this, void 0);
+        this.api = api;
+        this.db = db;
+        this.mockSignatureHost = mockSignatureHost;
+        this.allowUnresolvedImports = allowUnresolvedImports;
+        this.runtimeLogLevel = runtimeLogLevel;
+        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");
+    }
+    saveBlockToDB(block) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.db) {
+                const { hash, number, header, extrinsics } = block;
+                // delete old ones with the same block number if any, keep the latest one
+                yield this.db.transaction((transactionalEntityManager) => __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    yield transactionalEntityManager.getRepository(BlockEntity).delete({ number });
+                    yield transactionalEntityManager.getRepository(BlockEntity).upsert({
+                        hash,
+                        number,
+                        header: yield header,
+                        extrinsics: yield extrinsics,
+                        parentHash: (_a = (yield block.parentBlock)) === null || _a === void 0 ? void 0 : _a.hash,
+                        storageDiff: yield block.storageDiff(),
+                    }, ['hash']);
+                }));
+            }
+        });
+    }
+    /**
+     * Try to load block from db and register it
+     * If pass in number, get block by number, else get block by hash
+     */
+    loadBlockFromDB(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.db) {
+                const blockData = yield this.db
+                    .getRepository(BlockEntity)
+                    .findOne({ where: { [typeof key === 'number' ? 'number' : 'hash']: key } });
+                if (blockData) {
+                    const { hash, number, header, extrinsics, parentHash, storageDiff } = blockData;
+                    const parentBlock = parentHash ? __classPrivateFieldGet(this, _Blockchain_blocksByHash, "f")[parentHash] : undefined;
+                    const block = new Block(this, number, hash, parentBlock, { header, extrinsics, storageDiff });
+                    __classPrivateFieldGet(this, _Blockchain_instances, "m", _Blockchain_registerBlock).call(this, block);
+                    return block;
+                }
+            }
+            return undefined;
+        });
+    }
+    getBlockAt(number) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (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 = yield this.loadBlockFromDB(number);
+                if (blockFromDB) {
+                    return blockFromDB;
+                }
+                const hash = yield this.api.getBlockHash(number);
+                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);
+        });
+    }
+    getBlock(hash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.api.isReady;
+            if (hash == null) {
+                hash = this.head.hash;
+            }
+            if (!__classPrivateFieldGet(this, _Blockchain_blocksByHash, "f")[hash]) {
+                const loadingBlock = __classPrivateFieldGet(this, _Blockchain_loadingBlocks, "f")[hash];
+                if (loadingBlock) {
+                    yield loadingBlock;
+                }
+                else {
+                    const loadingBlock = (() => __awaiter(this, void 0, void 0, function* () {
+                        try {
+                            const blockFromDB = yield this.loadBlockFromDB(hash);
+                            if (!blockFromDB) {
+                                const header = yield this.api.getHeader(hash);
+                                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;
+                    yield loadingBlock;
+                    delete __classPrivateFieldGet(this, _Blockchain_loadingBlocks, "f")[hash];
+                }
+            }
+            return __classPrivateFieldGet(this, _Blockchain_blocksByHash, "f")[hash];
+        });
+    }
+    blocksInMemory() {
+        return Array.from(__classPrivateFieldGet(this, _Blockchain_blocksByNumber, "f").values());
+    }
+    unregisterBlock(block) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (block.hash === this.head.hash) {
+                throw new Error('Cannot unregister head block');
+            }
+            if (((_a = __classPrivateFieldGet(this, _Blockchain_blocksByNumber, "f").get(block.number)) === null || _a === void 0 ? void 0 : _a.hash) === block.hash) {
+                __classPrivateFieldGet(this, _Blockchain_blocksByNumber, "f").delete(block.number);
+            }
+            delete __classPrivateFieldGet(this, _Blockchain_blocksByHash, "f")[block.hash];
+            // delete from db
+            if (this.db) {
+                yield this.db.getRepository(BlockEntity).delete({ hash: block.hash });
+            }
+        });
+    }
+    onNewBlock(block) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.setHead(block);
+            yield this.saveBlockToDB(block);
+        });
+    }
+    setHead(block) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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);
+            yield this.headState.setHead(block);
+            if (this.offchainWorker) {
+                yield this.offchainWorker.run(block);
+            }
+        });
+    }
+    submitExtrinsic(extrinsic) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const validity = yield this.validateExtrinsic(extrinsic);
+            if (validity.isOk) {
+                yield __classPrivateFieldGet(this, _Blockchain_txpool, "f").submitExtrinsic(extrinsic);
+                return blake2AsHex(extrinsic, 256);
+            }
+            throw validity.asErr;
+        });
+    }
+    validateExtrinsic(extrinsic, source = '0x02' /** External */) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const args = u8aToHex(u8aConcat(source, extrinsic, this.head.hash));
+            const res = yield this.head.call('TaggedTransactionQueue_validate_transaction', [args]);
+            const registry = yield 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');
+    }
+    newBlock(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield __classPrivateFieldGet(this, _Blockchain_txpool, "f").buildBlock(params);
+            return __classPrivateFieldGet(this, _Blockchain_head, "f");
+        });
+    }
+    newBlockWithParams(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield __classPrivateFieldGet(this, _Blockchain_txpool, "f").buildBlockWithParams(params);
+            return __classPrivateFieldGet(this, _Blockchain_head, "f");
+        });
+    }
+    upcomingBlocks() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return __classPrivateFieldGet(this, _Blockchain_txpool, "f").upcomingBlocks();
+        });
+    }
+    dryRunExtrinsic(extrinsic, at) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.api.isReady;
+            const head = at ? yield this.getBlock(at) : this.head;
+            if (!head) {
+                throw new Error(`Cannot find block ${at}`);
+            }
+            const registry = yield head.registry;
+            const inherents = yield __classPrivateFieldGet(this, _Blockchain_inherentProvider, "f").createInherents(head, {
+                transactions: [],
+                downwardMessages: [],
+                upwardMessages: [],
+                horizontalMessages: {},
+            });
+            const { result, storageDiff } = yield dryRunExtrinsic(head, inherents, extrinsic);
+            const outcome = registry.createType('ApplyExtrinsicResult', result);
+            return { outcome, storageDiff };
+        });
+    }
+    dryRunHrmp(hrmp, at) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.api.isReady;
+            const head = at ? yield this.getBlock(at) : this.head;
+            if (!head) {
+                throw new Error(`Cannot find block ${at}`);
+            }
+            const inherents = yield __classPrivateFieldGet(this, _Blockchain_inherentProvider, "f").createInherents(head, {
+                transactions: [],
+                downwardMessages: [],
+                upwardMessages: [],
+                horizontalMessages: hrmp,
+            });
+            return dryRunInherents(head, inherents);
+        });
+    }
+    dryRunDmp(dmp, at) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.api.isReady;
+            const head = at ? yield this.getBlock(at) : this.head;
+            if (!head) {
+                throw new Error(`Cannot find block ${at}`);
+            }
+            const inherents = yield __classPrivateFieldGet(this, _Blockchain_inherentProvider, "f").createInherents(head, {
+                transactions: [],
+                downwardMessages: dmp,
+                upwardMessages: [],
+                horizontalMessages: {},
+            });
+            return dryRunInherents(head, inherents);
+        });
+    }
+    dryRunUmp(ump, at) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.api.isReady;
+            const head = at ? yield this.getBlock(at) : this.head;
+            if (!head) {
+                throw new Error(`Cannot find block ${at}`);
+            }
+            const meta = yield 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 = yield __classPrivateFieldGet(this, _Blockchain_inherentProvider, "f").createInherents(head, {
+                transactions: [],
+                downwardMessages: [],
+                upwardMessages: [],
+                horizontalMessages: {},
+            });
+            return dryRunInherents(head, inherents);
+        });
+    }
+    getInherents() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.api.isReady;
+            const inherents = yield __classPrivateFieldGet(this, _Blockchain_inherentProvider, "f").createInherents(this.head, {
+                transactions: [],
+                downwardMessages: [],
+                upwardMessages: [],
+                horizontalMessages: {},
+            });
+            return inherents;
+        });
+    }
+}
+_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 firstKey = __classPrivateFieldGet(this, _Blockchain_blocksByNumber, "f").keys().next().value;
+        __classPrivateFieldGet(this, _Blockchain_blocksByNumber, "f").delete(firstKey);
+    }
+    __classPrivateFieldGet(this, _Blockchain_blocksByNumber, "f").set(block.number, block);
+    __classPrivateFieldGet(this, _Blockchain_blocksByHash, "f")[block.hash] = block;
+};

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

@@ -0,0 +1,19 @@
+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 { SetBabeRandomness } from './parachain/babe-randomness';
+export { SetNimbusAuthorInherent } from './parachain/nimbus-author-inherent';
+export interface CreateInherents {
+    createInherents(parent: Block, params: BuildBlockParams): 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): Promise<HexString[]>;
+}

package/lib/blockchain/inherent/index.js

@@ -0,0 +1,53 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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 {
+    createInherents(parent) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const meta = yield parent.meta;
+            const slotDuration = yield getSlotDuration(parent.chain);
+            const currentTimestamp = yield getCurrentTimestamp(parent.chain);
+            return [new GenericExtrinsic(meta.registry, meta.tx.timestamp.set(currentTimestamp + 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");
+    }
+    createInherents(parent, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const base = yield __classPrivateFieldGet(this, _InherentProviders_base, "f").createInherents(parent, params);
+            const extra = yield 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/lib/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): Promise<HexString[]>;
+}

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

@@ -0,0 +1,37 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { GenericExtrinsic } from '@polkadot/types';
+export class ParaInherentEnter {
+    createInherents(parent, _params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const meta = yield parent.meta;
+            if (!((_a = meta.tx.paraInherent) === null || _a === void 0 ? void 0 : _a.enter)) {
+                return [];
+            }
+            const extrinsics = yield parent.extrinsics;
+            const paraEnterExtrinsic = extrinsics.find((extrinsic) => {
+                var _a, _b;
+                const firstArg = (_b = (_a = meta.registry.createType('GenericExtrinsic', extrinsic)) === null || _a === void 0 ? void 0 : _a.args) === null || _b === void 0 ? void 0 : _b[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 = (yield parent.header).toJSON();
+            const newData = Object.assign(Object.assign({}, extrinsic), { bitfields: [], backedCandidates: [], parentHeader });
+            // TODO: fill with data
+            return [new GenericExtrinsic(meta.registry, meta.tx.paraInherent.enter(newData)).toHex()];
+        });
+    }
+}

package/lib/blockchain/inherent/parachain/babe-randomness.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 SetBabeRandomness implements CreateInherents {
+    createInherents(parent: Block, _params: BuildBlockParams): Promise<HexString[]>;
+}

package/lib/blockchain/inherent/parachain/babe-randomness.js

@@ -0,0 +1,23 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { GenericExtrinsic } from '@polkadot/types';
+// Support for Moonbeam pallet-randomness mandatory inherent
+export class SetBabeRandomness {
+    createInherents(parent, _params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const meta = yield parent.meta;
+            if (!((_a = meta.tx.randomness) === null || _a === void 0 ? void 0 : _a.setBabeRandomnessResults)) {
+                return [];
+            }
+            return [new GenericExtrinsic(meta.registry, meta.tx.randomness.setBabeRandomnessResults()).toHex()];
+        });
+    }
+}

package/lib/blockchain/inherent/parachain/nimbus-author-inherent.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 SetNimbusAuthorInherent implements CreateInherents {
+    createInherents(parent: Block, _params: BuildBlockParams): Promise<HexString[]>;
+}

package/lib/blockchain/inherent/parachain/nimbus-author-inherent.js

@@ -0,0 +1,23 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { GenericExtrinsic } from '@polkadot/types';
+// Support for Nimbus Author Inherent
+export class SetNimbusAuthorInherent {
+    createInherents(parent, _params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const meta = yield parent.meta;
+            if (!((_a = meta.tx.authorInherent) === null || _a === void 0 ? void 0 : _a.kickOffAuthorshipValidation)) {
+                return [];
+            }
+            return [new GenericExtrinsic(meta.registry, meta.tx.authorInherent.kickOffAuthorshipValidation()).toHex()];
+        });
+    }
+}

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

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