@acala-network/chopsticks-core 0.8.0-0

package/lib/blockchain/inherent/parachain/validation-data.js

@@ -0,0 +1,165 @@
+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';
+import { hexToU8a, u8aConcat } from '@polkadot/util';
+import _ from 'lodash';
+import { WELL_KNOWN_KEYS, dmqMqcHead, hrmpChannels, hrmpEgressChannelIndex, hrmpIngressChannelIndex, upgradeGoAheadSignal, } from '../../../utils/proof';
+import { blake2AsHex, blake2AsU8a } from '@polkadot/util-crypto';
+import { compactHex, getParaId } from '../../../utils';
+import { createProof, decodeProof } from '../../../executor';
+const MOCK_VALIDATION_DATA = {
+    validationData: {
+        relayParentNumber: 1000,
+        relayParentStorageRoot: '0x49416764844ff0d8bad851e8abe686dff9dd2de78621180ef8e9f99bb7a480f1',
+        maxPovSize: 5242880,
+    },
+    relayChainState: {
+        trieNodes: [
+            '0x5f04b49d95320d9021994c850f25b8e385f902000030000080000008000000000010000000100005000000050000000a0000000a000000000050000000100000e8764817000000040000000400000000000000000000000000000000000000000000000000000000000000000000000800000000200000040000000400000000001000b0040000000000000000000014000000040000000400000000000000010100000000060000006400000002000000c8000000020000001900000000000000020000000200000000c817a804000000',
+            '0x80011080ace5323aee784b03389c0e2cc68d81973f8fa26d395f333ecad7399271c781e1808e5db75be813c05205986cbd6fdede707a4d26816063a41eb42ebc262c734fad',
+            '0x8004648086a9239b72237f5bf119e2a880c32f5866460632700509cb874c60f67fe815ea80f6f6801e4b41e2e6d8ec194dba122bfb9eb33feb2545ef5144cea79551f7cc5280c629a7e712d763fe83b35d2a082430af6737a89f23219c0eb3051c83bc5af5ad80fed5ecd6097308a6540f8cf31aeaad186e6898d2ecc0e623767c521c70e39953',
+            '0x800804809f3ada68c357b5e0a3ebb39ef181acfa9943af4725c244330a4b2c60837612e88082ad3fbdf392429afeacc70177704b760bb145547c1f152e1fcf651916b43820',
+            '0x8008208042793f557c1d003b647e2eda79c2b5088c7d8cab2e82c1dcc87f4343cca91ae4485ead6eef5c4b1c68eaa71ea17a02d9de0400',
+            '0x80210280de38445d825563f8e218255a417c16971afa85b4f2ef18fbe08fbc5b976dc0d6801a2ff24096295cfccf1adda80b8dfffe380b9f3b54d7a3cdb67864a4655e62968022a699b2cc90a6654c84163d2a498506b192afe7cd9777227e5288e8ff069c0f',
+            '0x80400180ebebd1a1cd0bbc6714b7fb0ac854cca5a4c4e34e69485da48be3c8087b56e09b80128645c79ca6581c248a412fd7b8bc532a187600e6e1cc20c915538ba4df6a79',
+            '0x80ffbe80d9302a505e2b1ac931f539aed33bf791d1982906ae64c7197324044f191e9bca80972cd2f703f9c94fd516e14b7013c6f1545095855b6c4b36f21d89dad30aa54d80b2495ce4d07001927bb0857611f8d3a1449e791d0b010e3861c32dec0c44179680f5929c8ef9b0ac6ec8a529c91348d8cd6c169920dd37d055544a6c31c53b11e380402a0bf7ff07cee790d9cc065fc138ff6afa7db016d898d65b2b716af354c6f68042aef1dafffd1d9debbb8e6c4eb48b5c141ddf0aad2b0f3f4ddf53e6b38e65c080b31fa0392c1abdce1aa29d1544c94634ecab87ecaba6409db33aaa7621992a8280b1f4de7c3ac5665016d561a60659cd2d8f2d3e0a97e2ea9749279bd8e35eb1f180816ac87a2893694016b21768137a76ea459190ea0fc3c645d85e1a3d4eb194fe802e563b43e7334454c841953424be8c2b7a1c3295dbc391045cb6b88388ad5e7080b1ed3b02e5989b7d134ca056c778f1f5b6ffd377b2d8064483da6e94b82b0e40800cb3299c44a5db8fdcb4932e1b6ab0385d6ef1c9f8d85e0a75b787b6f4fd6c3c805a44c30e2676dc2d4c17451f51d9502e85064387999f366e6f3d404509a7780f80d6788ca71c6aabe421c352027acdb9532563dc5f1b25e6154b721f431e9990ed',
+            '0x9d0da05ca59913bc38a8630590f2627c154080834dda0ba5adf00d798e981a28a13e728cf83e35aefc87318440a61869f724474c5f0a351b6a99a5b21324516e668bb86a570400505f0e7b9012096b41c4eb3aaf947f6ea4290800007c7700e67da63472835bb0b737093a19ad4c63f5a4efb16ffa83d00700000400',
+            '0x9e207f03cfdce586301014700e2c25931040505f0e7b9012096b41c4eb3aaf947f6ea4290800004c5f0ec2d17a76153ff51817f12d9cfc3c7f0400',
+            '0x9e710b30bd2eab0352ddcc26417aa1945fc180699a53b51a9709a3a86039c49b5ef278e9fc244dae27e1a0380c91bff5b0488580c0d4096d94e724b8e86f952e5456c7253776de04c405582d2c350ee172d3eaa77c77081e0bfde17b36573208a06cb5cfba6b63f5a4efb16ffa83d00700000402803d0ae0b8f6832e8fabf0ec62521c2487c58b69eb97060faa8059b00ff6b7262d505f0e7b9012096b41c4eb3aaf947f6ea4290800004c5f03c716fb8fff3de61a883bb76adb34a20400806c8122e0f7f786071d6a51b330d612eccdcbe8d8f79936accabd640506dffdf380a6abfb72ed49b586829cca4ce631c092d45a017ab0d68288d308873025cfe5d280521b868fc212b25f021984cf02ced547cd45952b88360766839dfde7d4683e61',
+            '0x9ede3d8a54d27e44a9d5ce189618f22d1008505f0e7b9012096b41c4eb3aaf947f6ea42908010080c74756edffa217dfb07ab596d82753deff985ac215e5cc2997d29afe1d397c16',
+            '0x9ef78c98723ddc9073523ef3beefda0c1004505f0e7b9012096b41c4eb3aaf947f6ea4290800007c77095dac46c07a40d91506e7637ec4ba5763f5a4efb16ffa83d00700000400',
+        ],
+    },
+};
+export class SetValidationData {
+    createInherents(parent, params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const meta = yield parent.meta;
+            if (!((_a = meta.tx.parachainSystem) === null || _a === void 0 ? void 0 : _a.setValidationData)) {
+                return [];
+            }
+            const extrinsics = yield parent.extrinsics;
+            let newData;
+            if (parent.number === 0) {
+                // chain started with genesis, mock 1st validationData
+                newData = MOCK_VALIDATION_DATA;
+            }
+            else {
+                const validationDataExtrinsic = 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 && '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 downwardMessages = [];
+                const horizontalMessages = {};
+                const paraId = yield getParaId(parent.chain);
+                const dmqMqcHeadKey = dmqMqcHead(paraId);
+                const hrmpIngressChannelIndexKey = hrmpIngressChannelIndex(paraId);
+                const hrmpEgressChannelIndexKey = hrmpEgressChannelIndex(paraId);
+                // TODO: refactor this to have a single decodeProof
+                const decoded = yield decodeProof(extrinsic.validationData.relayParentStorageRoot, [...Object.values(WELL_KNOWN_KEYS), dmqMqcHeadKey, hrmpIngressChannelIndexKey, hrmpEgressChannelIndexKey], extrinsic.relayChainState.trieNodes);
+                for (const key of Object.values(WELL_KNOWN_KEYS)) {
+                    newEntries.push([key, decoded[key]]);
+                }
+                newEntries.push([hrmpIngressChannelIndexKey, decoded[hrmpIngressChannelIndexKey]]);
+                newEntries.push([hrmpEgressChannelIndexKey, decoded[hrmpEgressChannelIndexKey]]);
+                // inject downward messages
+                let dmqMqcHeadHash = decoded[dmqMqcHeadKey];
+                if (dmqMqcHeadHash) {
+                    for (const { msg, sentAt } of params.downwardMessages) {
+                        // calculate new hash
+                        dmqMqcHeadHash = blake2AsHex(u8aConcat(meta.registry.createType('Hash', dmqMqcHeadHash).toU8a(), meta.registry.createType('BlockNumber', sentAt).toU8a(), blake2AsU8a(meta.registry.createType('Bytes', msg).toU8a(), 256)), 256);
+                        downwardMessages.push({
+                            msg,
+                            sentAt,
+                        });
+                    }
+                    newEntries.push([dmqMqcHeadKey, dmqMqcHeadHash]);
+                }
+                const hrmpIngressChannels = meta.registry
+                    .createType('Vec<ParaId>', decoded[hrmpIngressChannelIndexKey])
+                    .toJSON();
+                const hrmpEgressChannels = meta.registry
+                    .createType('Vec<ParaId>', decoded[hrmpEgressChannelIndexKey])
+                    .toJSON();
+                const hrmpMessages = Object.assign(Object.assign({}, _.mapValues(extrinsic.horizontalMessages, () => [])), params.horizontalMessages);
+                // inject horizontal messages
+                for (const id of hrmpIngressChannels) {
+                    const messages = hrmpMessages[id];
+                    const sender = Number(id);
+                    const channelId = meta.registry.createType('HrmpChannelId', {
+                        sender,
+                        receiver: paraId.toNumber(),
+                    });
+                    const hrmpChannelKey = hrmpChannels(channelId);
+                    const decoded = yield 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', hexToU8a(abridgedHrmpRaw))
+                        .toJSON();
+                    const paraMessages = [];
+                    for (const { data, sentAt } of messages) {
+                        // calculate new hash
+                        const bytes = meta.registry.createType('Bytes', data);
+                        abridgedHrmp.mqcHead = blake2AsHex(u8aConcat(meta.registry.createType('Hash', abridgedHrmp.mqcHead).toU8a(), meta.registry.createType('BlockNumber', sentAt).toU8a(), blake2AsU8a(bytes.toU8a(), 256)), 256);
+                        abridgedHrmp.msgCount = abridgedHrmp.msgCount + 1;
+                        abridgedHrmp.totalSize = abridgedHrmp.totalSize + bytes.length;
+                        paraMessages.push({
+                            data,
+                            sentAt,
+                        });
+                    }
+                    horizontalMessages[sender] = paraMessages;
+                    newEntries.push([hrmpChannelKey, meta.registry.createType('AbridgedHrmpChannel', abridgedHrmp).toHex()]);
+                }
+                // inject hrmpEgressChannels proof
+                for (const id of hrmpEgressChannels) {
+                    // const messages = hrmpMessages[id]
+                    const receiver = Number(id);
+                    const channelId = meta.registry.createType('HrmpChannelId', {
+                        sender: paraId.toNumber(),
+                        receiver,
+                    });
+                    const hrmpChannelKey = hrmpChannels(channelId);
+                    const decoded = yield decodeProof(extrinsic.validationData.relayParentStorageRoot, [hrmpChannelKey], extrinsic.relayChainState.trieNodes);
+                    newEntries.push([hrmpChannelKey, decoded[hrmpChannelKey]]);
+                }
+                const upgradeKey = upgradeGoAheadSignal(paraId);
+                const pendingUpgrade = yield parent.get(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 } = yield createProof(extrinsic.relayChainState.trieNodes, newEntries);
+                newData = Object.assign(Object.assign({}, extrinsic), { downwardMessages,
+                    horizontalMessages, validationData: Object.assign(Object.assign({}, extrinsic.validationData), { relayParentStorageRoot: trieRootHash, relayParentNumber: extrinsic.validationData.relayParentNumber + 2 }), relayChainState: {
+                        trieNodes: nodes,
+                    } });
+            }
+            const inherent = new GenericExtrinsic(meta.registry, meta.tx.parachainSystem.setValidationData(newData));
+            return [inherent.toHex()];
+        });
+    }
+}

package/lib/blockchain/storage-layer.d.ts

@@ -0,0 +1,32 @@
+import { DataSource } from 'typeorm';
+import { Api } from '../api';
+export declare const enum StorageValueKind {
+    Deleted = "Deleted",
+    DeletedPrefix = "DeletedPrefix"
+}
+export type StorageValue = string | StorageValueKind | undefined;
+export interface StorageLayerProvider {
+    get(key: string, cache: boolean): Promise<StorageValue>;
+    foldInto(into: StorageLayer): Promise<StorageLayerProvider | undefined>;
+    fold(): Promise<void>;
+    getKeysPaged(prefix: string, pageSize: number, startKey: string): Promise<string[]>;
+}
+export declare class RemoteStorageLayer implements StorageLayerProvider {
+    #private;
+    constructor(api: Api, at: string, db: DataSource | undefined);
+    get(key: string): Promise<StorageValue>;
+    foldInto(_into: StorageLayer): Promise<StorageLayerProvider>;
+    fold(): Promise<void>;
+    getKeysPaged(prefix: string, pageSize: number, startKey: string): Promise<string[]>;
+}
+export declare class StorageLayer implements StorageLayerProvider {
+    #private;
+    constructor(parent?: StorageLayerProvider);
+    get(key: string, cache: boolean): Promise<StorageValue | undefined>;
+    set(key: string, value: StorageValue): void;
+    setAll(values: Record<string, StorageValue | null> | [string, StorageValue | null][]): void;
+    foldInto(into: StorageLayer): Promise<StorageLayerProvider | undefined>;
+    fold(): Promise<void>;
+    getKeysPaged(prefix: string, pageSize: number, startKey: string): Promise<string[]>;
+    mergeInto(into: Record<string, string | null>): Promise<void>;
+}

package/lib/blockchain/storage-layer.js

@@ -0,0 +1,242 @@
+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 _RemoteStorageLayer_api, _RemoteStorageLayer_at, _RemoteStorageLayer_db, _RemoteStorageLayer_keyCache, _StorageLayer_instances, _StorageLayer_store, _StorageLayer_keys, _StorageLayer_deletedPrefix, _StorageLayer_parent, _StorageLayer_addKey, _StorageLayer_removeKey;
+import _ from 'lodash';
+import { KeyValuePair } from '../db/entities';
+import { defaultLogger } from '../logger';
+import KeyCache from '../utils/key-cache';
+const logger = defaultLogger.child({ name: 'layer' });
+const BATCH_SIZE = 1000;
+export var StorageValueKind;
+(function (StorageValueKind) {
+    StorageValueKind["Deleted"] = "Deleted";
+    StorageValueKind["DeletedPrefix"] = "DeletedPrefix";
+})(StorageValueKind || (StorageValueKind = {}));
+export class RemoteStorageLayer {
+    constructor(api, at, db) {
+        _RemoteStorageLayer_api.set(this, void 0);
+        _RemoteStorageLayer_at.set(this, void 0);
+        _RemoteStorageLayer_db.set(this, void 0);
+        _RemoteStorageLayer_keyCache.set(this, new KeyCache());
+        __classPrivateFieldSet(this, _RemoteStorageLayer_api, api, "f");
+        __classPrivateFieldSet(this, _RemoteStorageLayer_at, at, "f");
+        __classPrivateFieldSet(this, _RemoteStorageLayer_db, db, "f");
+    }
+    get(key) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const keyValuePair = (_a = __classPrivateFieldGet(this, _RemoteStorageLayer_db, "f")) === null || _a === void 0 ? void 0 : _a.getRepository(KeyValuePair);
+            if (__classPrivateFieldGet(this, _RemoteStorageLayer_db, "f")) {
+                const res = yield (keyValuePair === null || keyValuePair === void 0 ? void 0 : keyValuePair.findOne({ where: { key, blockHash: __classPrivateFieldGet(this, _RemoteStorageLayer_at, "f") } }));
+                if (res) {
+                    return res.value;
+                }
+            }
+            logger.trace({ at: __classPrivateFieldGet(this, _RemoteStorageLayer_at, "f"), key }, 'RemoteStorageLayer get');
+            const data = yield __classPrivateFieldGet(this, _RemoteStorageLayer_api, "f").getStorage(key, __classPrivateFieldGet(this, _RemoteStorageLayer_at, "f"));
+            keyValuePair === null || keyValuePair === void 0 ? void 0 : keyValuePair.upsert({ key, blockHash: __classPrivateFieldGet(this, _RemoteStorageLayer_at, "f"), value: data }, ['key', 'blockHash']);
+            return data;
+        });
+    }
+    foldInto(_into) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this;
+        });
+    }
+    fold() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    getKeysPaged(prefix, pageSize, startKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (pageSize > BATCH_SIZE)
+                throw new Error(`pageSize must be less or equal to ${BATCH_SIZE}`);
+            logger.trace({ at: __classPrivateFieldGet(this, _RemoteStorageLayer_at, "f"), prefix, pageSize, startKey }, 'RemoteStorageLayer getKeysPaged');
+            // can't handle keyCache without prefix
+            if (prefix.length < 66) {
+                return __classPrivateFieldGet(this, _RemoteStorageLayer_api, "f").getKeysPaged(prefix, pageSize, startKey, __classPrivateFieldGet(this, _RemoteStorageLayer_at, "f"));
+            }
+            let batchComplete = false;
+            const keysPaged = [];
+            while (keysPaged.length < pageSize) {
+                const nextKey = yield __classPrivateFieldGet(this, _RemoteStorageLayer_keyCache, "f").next(startKey);
+                if (nextKey) {
+                    keysPaged.push(nextKey);
+                    startKey = nextKey;
+                    continue;
+                }
+                // batch fetch was completed
+                if (batchComplete) {
+                    break;
+                }
+                // fetch a batch of keys
+                const batch = yield __classPrivateFieldGet(this, _RemoteStorageLayer_api, "f").getKeysPaged(prefix, BATCH_SIZE, startKey, __classPrivateFieldGet(this, _RemoteStorageLayer_at, "f"));
+                batchComplete = batch.length < BATCH_SIZE;
+                // feed the key cache
+                if (batch.length > 0) {
+                    __classPrivateFieldGet(this, _RemoteStorageLayer_keyCache, "f").feed([startKey, ...batch]);
+                }
+                if (batch.length === 0) {
+                    // no more keys were found
+                    break;
+                }
+            }
+            return keysPaged;
+        });
+    }
+}
+_RemoteStorageLayer_api = new WeakMap(), _RemoteStorageLayer_at = new WeakMap(), _RemoteStorageLayer_db = new WeakMap(), _RemoteStorageLayer_keyCache = new WeakMap();
+export class StorageLayer {
+    constructor(parent) {
+        _StorageLayer_instances.add(this);
+        _StorageLayer_store.set(this, {});
+        _StorageLayer_keys.set(this, []);
+        _StorageLayer_deletedPrefix.set(this, []);
+        _StorageLayer_parent.set(this, void 0);
+        __classPrivateFieldSet(this, _StorageLayer_parent, parent, "f");
+    }
+    get(key, cache) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (key in __classPrivateFieldGet(this, _StorageLayer_store, "f")) {
+                return __classPrivateFieldGet(this, _StorageLayer_store, "f")[key];
+            }
+            if (__classPrivateFieldGet(this, _StorageLayer_deletedPrefix, "f").some((prefix) => key.startsWith(prefix))) {
+                return StorageValueKind.Deleted;
+            }
+            if (__classPrivateFieldGet(this, _StorageLayer_parent, "f")) {
+                const val = __classPrivateFieldGet(this, _StorageLayer_parent, "f").get(key, false);
+                if (cache) {
+                    __classPrivateFieldGet(this, _StorageLayer_store, "f")[key] = val;
+                }
+                return val;
+            }
+            return undefined;
+        });
+    }
+    set(key, value) {
+        switch (value) {
+            case StorageValueKind.Deleted:
+                __classPrivateFieldGet(this, _StorageLayer_store, "f")[key] = value;
+                __classPrivateFieldGet(this, _StorageLayer_instances, "m", _StorageLayer_removeKey).call(this, key);
+                break;
+            case StorageValueKind.DeletedPrefix:
+                __classPrivateFieldGet(this, _StorageLayer_deletedPrefix, "f").push(key);
+                for (const k of __classPrivateFieldGet(this, _StorageLayer_keys, "f")) {
+                    if (k.startsWith(key)) {
+                        __classPrivateFieldGet(this, _StorageLayer_store, "f")[k] = StorageValueKind.Deleted;
+                        __classPrivateFieldGet(this, _StorageLayer_instances, "m", _StorageLayer_removeKey).call(this, k);
+                    }
+                }
+                break;
+            case undefined:
+                delete __classPrivateFieldGet(this, _StorageLayer_store, "f")[key];
+                __classPrivateFieldGet(this, _StorageLayer_instances, "m", _StorageLayer_removeKey).call(this, key);
+                break;
+            default:
+                __classPrivateFieldGet(this, _StorageLayer_store, "f")[key] = value;
+                __classPrivateFieldGet(this, _StorageLayer_instances, "m", _StorageLayer_addKey).call(this, key);
+                break;
+        }
+    }
+    setAll(values) {
+        if (!Array.isArray(values)) {
+            values = Object.entries(values);
+        }
+        for (const [key, value] of values) {
+            this.set(key, value || StorageValueKind.Deleted);
+        }
+    }
+    foldInto(into) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const newParent = yield ((_a = __classPrivateFieldGet(this, _StorageLayer_parent, "f")) === null || _a === void 0 ? void 0 : _a.foldInto(into));
+            for (const deletedPrefix of __classPrivateFieldGet(this, _StorageLayer_deletedPrefix, "f")) {
+                into.set(deletedPrefix, StorageValueKind.DeletedPrefix);
+            }
+            for (const key of __classPrivateFieldGet(this, _StorageLayer_keys, "f")) {
+                const value = yield __classPrivateFieldGet(this, _StorageLayer_store, "f")[key];
+                into.set(key, value);
+            }
+            return newParent;
+        });
+    }
+    fold() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (__classPrivateFieldGet(this, _StorageLayer_parent, "f")) {
+                __classPrivateFieldSet(this, _StorageLayer_parent, yield __classPrivateFieldGet(this, _StorageLayer_parent, "f").foldInto(this), "f");
+            }
+        });
+    }
+    getKeysPaged(prefix, pageSize, startKey) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!__classPrivateFieldGet(this, _StorageLayer_deletedPrefix, "f").some((prefix) => startKey.startsWith(prefix))) {
+                const remote = (_b = (yield ((_a = __classPrivateFieldGet(this, _StorageLayer_parent, "f")) === null || _a === void 0 ? void 0 : _a.getKeysPaged(prefix, pageSize, startKey)))) !== null && _b !== void 0 ? _b : [];
+                for (const key of remote) {
+                    if (__classPrivateFieldGet(this, _StorageLayer_deletedPrefix, "f").some((prefix) => key.startsWith(prefix))) {
+                        continue;
+                    }
+                    __classPrivateFieldGet(this, _StorageLayer_instances, "m", _StorageLayer_addKey).call(this, key);
+                }
+            }
+            let idx = _.sortedIndex(__classPrivateFieldGet(this, _StorageLayer_keys, "f"), startKey);
+            if (__classPrivateFieldGet(this, _StorageLayer_keys, "f")[idx] === startKey) {
+                ++idx;
+            }
+            const res = [];
+            while (res.length < pageSize) {
+                const key = __classPrivateFieldGet(this, _StorageLayer_keys, "f")[idx];
+                if (!key || !key.startsWith(prefix)) {
+                    break;
+                }
+                res.push(key);
+                ++idx;
+            }
+            return res;
+        });
+    }
+    mergeInto(into) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const [key, maybeValue] of Object.entries(__classPrivateFieldGet(this, _StorageLayer_store, "f"))) {
+                const value = yield maybeValue;
+                if (value === StorageValueKind.Deleted) {
+                    into[key] = null;
+                }
+                else {
+                    into[key] = value;
+                }
+            }
+        });
+    }
+}
+_StorageLayer_store = new WeakMap(), _StorageLayer_keys = new WeakMap(), _StorageLayer_deletedPrefix = new WeakMap(), _StorageLayer_parent = new WeakMap(), _StorageLayer_instances = new WeakSet(), _StorageLayer_addKey = function _StorageLayer_addKey(key) {
+    const idx = _.sortedIndex(__classPrivateFieldGet(this, _StorageLayer_keys, "f"), key);
+    const key2 = __classPrivateFieldGet(this, _StorageLayer_keys, "f")[idx];
+    if (key === key2) {
+        return;
+    }
+    __classPrivateFieldGet(this, _StorageLayer_keys, "f").splice(idx, 0, key);
+}, _StorageLayer_removeKey = function _StorageLayer_removeKey(key) {
+    const idx = _.sortedIndex(__classPrivateFieldGet(this, _StorageLayer_keys, "f"), key);
+    const key2 = __classPrivateFieldGet(this, _StorageLayer_keys, "f")[idx];
+    if (key === key2) {
+        __classPrivateFieldGet(this, _StorageLayer_keys, "f").splice(idx, 1);
+    }
+};

package/lib/blockchain/txpool.d.ts

@@ -0,0 +1,44 @@
+import { EventEmitter } from 'eventemitter3';
+import { HexString } from '@polkadot/util/types';
+import { Blockchain } from '.';
+import { InherentProvider } from './inherent';
+export declare const APPLY_EXTRINSIC_ERROR = "TxPool::ApplyExtrinsicError";
+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 {
+    downwardMessages: DownwardMessage[];
+    upwardMessages: Record<number, HexString[]>;
+    horizontalMessages: Record<number, HorizontalMessage[]>;
+    transactions: HexString[];
+}
+export declare class TxPool {
+    #private;
+    readonly event: EventEmitter<string | symbol, any>;
+    constructor(chain: Blockchain, inherentProvider: InherentProvider, mode?: BuildBlockMode);
+    get pendingExtrinsics(): HexString[];
+    get ump(): Record<number, HexString[]>;
+    get dmp(): DownwardMessage[];
+    get hrmp(): Record<number, HorizontalMessage[]>;
+    get mode(): BuildBlockMode;
+    set mode(mode: BuildBlockMode);
+    clear(): void;
+    pendingExtrinsicsBy(address: string): HexString[];
+    submitExtrinsic(extrinsic: HexString): Promise<void>;
+    submitUpwardMessages(id: number, ump: HexString[]): void;
+    submitDownwardMessages(dmp: DownwardMessage[]): void;
+    submitHorizontalMessages(id: number, hrmp: HorizontalMessage[]): void;
+    buildBlockWithParams(params: BuildBlockParams): Promise<void>;
+    buildBlock(params?: Partial<BuildBlockParams>): Promise<void>;
+    upcomingBlocks(): Promise<number>;
+}