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

package/dist/esm/blockchain/inherent/parachain/validation-data.js

@@ -0,0 +1,165 @@
+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 '../../../wasm-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 {
+    async createInherents(parent, params) {
+        const meta = await parent.meta;
+        if (!meta.tx.parachainSystem?.setValidationData) {
+            return [];
+        }
+        const extrinsics = await 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) => {
+                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 downwardMessages = [];
+            const horizontalMessages = {};
+            const paraId = await 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 = await 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 = {
+                // reset values, we just need the keys
+                ..._.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 = await 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 = await decodeProof(extrinsic.validationData.relayParentStorageRoot, [hrmpChannelKey], extrinsic.relayChainState.trieNodes);
+                newEntries.push([hrmpChannelKey, decoded[hrmpChannelKey]]);
+            }
+            const upgradeKey = upgradeGoAheadSignal(paraId);
+            const pendingUpgrade = await 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 } = await createProof(extrinsic.relayChainState.trieNodes, newEntries);
+            newData = {
+                ...extrinsic,
+                downwardMessages,
+                horizontalMessages,
+                validationData: {
+                    ...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/dist/esm/blockchain/storage-layer.js

@@ -0,0 +1,215 @@
+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 { defaultLogger } from '../logger';
+import KeyCache, { PREFIX_LENGTH } 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");
+    }
+    async get(key, _cache) {
+        if (__classPrivateFieldGet(this, _RemoteStorageLayer_db, "f")) {
+            const res = await __classPrivateFieldGet(this, _RemoteStorageLayer_db, "f").queryStorage(__classPrivateFieldGet(this, _RemoteStorageLayer_at, "f"), key);
+            if (res) {
+                return res.value ?? undefined;
+            }
+        }
+        logger.trace({ at: __classPrivateFieldGet(this, _RemoteStorageLayer_at, "f"), key }, 'RemoteStorageLayer get');
+        const data = await __classPrivateFieldGet(this, _RemoteStorageLayer_api, "f").getStorage(key, __classPrivateFieldGet(this, _RemoteStorageLayer_at, "f"));
+        __classPrivateFieldGet(this, _RemoteStorageLayer_db, "f")?.saveStorage(__classPrivateFieldGet(this, _RemoteStorageLayer_at, "f"), key, data);
+        return data ?? undefined;
+    }
+    async foldInto(_into) {
+        return this;
+    }
+    async fold() { }
+    async getKeysPaged(prefix, pageSize, startKey) {
+        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 < PREFIX_LENGTH || startKey.length < PREFIX_LENGTH) {
+            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 = await __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 = await __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, new Map());
+        _StorageLayer_keys.set(this, []);
+        _StorageLayer_deletedPrefix.set(this, []);
+        _StorageLayer_parent.set(this, void 0);
+        __classPrivateFieldSet(this, _StorageLayer_parent, parent, "f");
+    }
+    async get(key, cache) {
+        if (__classPrivateFieldGet(this, _StorageLayer_store, "f").has(key)) {
+            return __classPrivateFieldGet(this, _StorageLayer_store, "f").get(key);
+        }
+        if (__classPrivateFieldGet(this, _StorageLayer_deletedPrefix, "f").some((dp) => key.startsWith(dp))) {
+            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").set(key, val);
+            }
+            return val;
+        }
+        return undefined;
+    }
+    set(key, value) {
+        switch (value) {
+            case StorageValueKind.Deleted:
+                __classPrivateFieldGet(this, _StorageLayer_store, "f").set(key, StorageValueKind.Deleted);
+                __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").set(k, StorageValueKind.Deleted);
+                        __classPrivateFieldGet(this, _StorageLayer_instances, "m", _StorageLayer_removeKey).call(this, k);
+                    }
+                }
+                break;
+            case undefined:
+                __classPrivateFieldGet(this, _StorageLayer_store, "f").delete(key);
+                __classPrivateFieldGet(this, _StorageLayer_instances, "m", _StorageLayer_removeKey).call(this, key);
+                break;
+            default:
+                __classPrivateFieldGet(this, _StorageLayer_store, "f").set(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);
+        }
+    }
+    async foldInto(into) {
+        const newParent = await __classPrivateFieldGet(this, _StorageLayer_parent, "f")?.foldInto(into);
+        for (const deletedPrefix of __classPrivateFieldGet(this, _StorageLayer_deletedPrefix, "f")) {
+            into.set(deletedPrefix, StorageValueKind.DeletedPrefix);
+        }
+        for (const [key, value] of __classPrivateFieldGet(this, _StorageLayer_store, "f")) {
+            into.set(key, await value);
+        }
+        return newParent;
+    }
+    async fold() {
+        if (__classPrivateFieldGet(this, _StorageLayer_parent, "f")) {
+            __classPrivateFieldSet(this, _StorageLayer_parent, await __classPrivateFieldGet(this, _StorageLayer_parent, "f").foldInto(this), "f");
+        }
+    }
+    async getKeysPaged(prefix, pageSize, startKey) {
+        if (!__classPrivateFieldGet(this, _StorageLayer_deletedPrefix, "f").some((dp) => startKey.startsWith(dp))) {
+            const remote = (await __classPrivateFieldGet(this, _StorageLayer_parent, "f")?.getKeysPaged(prefix, pageSize, startKey)) ?? [];
+            for (const key of remote) {
+                if (__classPrivateFieldGet(this, _StorageLayer_store, "f").get(key) === StorageValueKind.Deleted) {
+                    continue;
+                }
+                if (__classPrivateFieldGet(this, _StorageLayer_deletedPrefix, "f").some((dp) => key.startsWith(dp))) {
+                    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;
+    }
+    /**
+     * Merge the storage layer into the given object, can be used to get sotrage diff.
+     */
+    async mergeInto(into) {
+        for (const [key, maybeValue] of __classPrivateFieldGet(this, _StorageLayer_store, "f")) {
+            const value = await 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/dist/esm/blockchain/txpool.js

@@ -0,0 +1,208 @@
+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 _TxPool_instances, _TxPool_chain, _TxPool_pool, _TxPool_ump, _TxPool_dmp, _TxPool_hrmp, _TxPool_mode, _TxPool_inherentProvider, _TxPool_pendingBlocks, _TxPool_isBuilding, _TxPool_getSigner, _TxPool_maybeBuildBlock, _TxPool_batchBuildBlock, _TxPool_buildBlockIfNeeded, _TxPool_buildBlock;
+import { EventEmitter } from 'eventemitter3';
+import _ from 'lodash';
+import { defer } from '../utils';
+import { buildBlock } from './block-builder';
+import { defaultLogger, truncate } from '../logger';
+const logger = defaultLogger.child({ name: 'txpool' });
+export const APPLY_EXTRINSIC_ERROR = 'TxPool::ApplyExtrinsicError';
+export var BuildBlockMode;
+(function (BuildBlockMode) {
+    /** One block per batch (default) */
+    BuildBlockMode[BuildBlockMode["Batch"] = 0] = "Batch";
+    /** One block per tx */
+    BuildBlockMode[BuildBlockMode["Instant"] = 1] = "Instant";
+    /** Only build when triggered */
+    BuildBlockMode[BuildBlockMode["Manual"] = 2] = "Manual";
+})(BuildBlockMode || (BuildBlockMode = {}));
+export class TxPool {
+    constructor(chain, inherentProvider, mode = BuildBlockMode.Batch) {
+        _TxPool_instances.add(this);
+        _TxPool_chain.set(this, void 0);
+        _TxPool_pool.set(this, []);
+        _TxPool_ump.set(this, {});
+        _TxPool_dmp.set(this, []);
+        _TxPool_hrmp.set(this, {});
+        _TxPool_mode.set(this, void 0);
+        _TxPool_inherentProvider.set(this, void 0);
+        _TxPool_pendingBlocks.set(this, []);
+        this.event = new EventEmitter();
+        _TxPool_isBuilding.set(this, false);
+        _TxPool_batchBuildBlock.set(this, _.debounce(this.buildBlock, 100, { maxWait: 1000 }));
+        __classPrivateFieldSet(this, _TxPool_chain, chain, "f");
+        __classPrivateFieldSet(this, _TxPool_mode, mode, "f");
+        __classPrivateFieldSet(this, _TxPool_inherentProvider, inherentProvider, "f");
+    }
+    get pendingExtrinsics() {
+        return __classPrivateFieldGet(this, _TxPool_pool, "f").map(({ extrinsic }) => extrinsic);
+    }
+    get ump() {
+        return __classPrivateFieldGet(this, _TxPool_ump, "f");
+    }
+    get dmp() {
+        return __classPrivateFieldGet(this, _TxPool_dmp, "f");
+    }
+    get hrmp() {
+        return __classPrivateFieldGet(this, _TxPool_hrmp, "f");
+    }
+    get mode() {
+        return __classPrivateFieldGet(this, _TxPool_mode, "f");
+    }
+    set mode(mode) {
+        __classPrivateFieldSet(this, _TxPool_mode, mode, "f");
+    }
+    clear() {
+        __classPrivateFieldGet(this, _TxPool_pool, "f").length = 0;
+        for (const id of Object.keys(__classPrivateFieldGet(this, _TxPool_ump, "f"))) {
+            delete __classPrivateFieldGet(this, _TxPool_ump, "f")[id];
+        }
+        __classPrivateFieldGet(this, _TxPool_dmp, "f").length = 0;
+        for (const id of Object.keys(__classPrivateFieldGet(this, _TxPool_hrmp, "f"))) {
+            delete __classPrivateFieldGet(this, _TxPool_hrmp, "f")[id];
+        }
+    }
+    pendingExtrinsicsBy(address) {
+        return __classPrivateFieldGet(this, _TxPool_pool, "f").filter(({ signer }) => signer === address).map(({ extrinsic }) => extrinsic);
+    }
+    async submitExtrinsic(extrinsic) {
+        logger.debug({ extrinsic: truncate(extrinsic) }, 'submit extrinsic');
+        __classPrivateFieldGet(this, _TxPool_pool, "f").push({ extrinsic, signer: await __classPrivateFieldGet(this, _TxPool_instances, "m", _TxPool_getSigner).call(this, extrinsic) });
+        __classPrivateFieldGet(this, _TxPool_instances, "m", _TxPool_maybeBuildBlock).call(this);
+    }
+    submitUpwardMessages(id, ump) {
+        logger.debug({ id, ump: truncate(ump) }, 'submit upward messages');
+        if (!__classPrivateFieldGet(this, _TxPool_ump, "f")[id]) {
+            __classPrivateFieldGet(this, _TxPool_ump, "f")[id] = [];
+        }
+        __classPrivateFieldGet(this, _TxPool_ump, "f")[id].push(...ump);
+        __classPrivateFieldGet(this, _TxPool_instances, "m", _TxPool_maybeBuildBlock).call(this);
+    }
+    submitDownwardMessages(dmp) {
+        logger.debug({ dmp: truncate(dmp) }, 'submit downward messages');
+        __classPrivateFieldGet(this, _TxPool_dmp, "f").push(...dmp);
+        __classPrivateFieldGet(this, _TxPool_instances, "m", _TxPool_maybeBuildBlock).call(this);
+    }
+    submitHorizontalMessages(id, hrmp) {
+        logger.debug({ id, hrmp: truncate(hrmp) }, 'submit horizontal messages');
+        if (!__classPrivateFieldGet(this, _TxPool_hrmp, "f")[id]) {
+            __classPrivateFieldGet(this, _TxPool_hrmp, "f")[id] = [];
+        }
+        __classPrivateFieldGet(this, _TxPool_hrmp, "f")[id].push(...hrmp);
+        __classPrivateFieldGet(this, _TxPool_instances, "m", _TxPool_maybeBuildBlock).call(this);
+    }
+    async buildBlockWithParams(params) {
+        __classPrivateFieldGet(this, _TxPool_pendingBlocks, "f").push({
+            params,
+            deferred: defer(),
+        });
+        __classPrivateFieldGet(this, _TxPool_instances, "m", _TxPool_buildBlockIfNeeded).call(this);
+        await this.upcomingBlocks();
+    }
+    async buildBlock(params) {
+        const transactions = params?.transactions || __classPrivateFieldGet(this, _TxPool_pool, "f").splice(0).map(({ extrinsic }) => extrinsic);
+        const upwardMessages = params?.upwardMessages || { ...__classPrivateFieldGet(this, _TxPool_ump, "f") };
+        const downwardMessages = params?.downwardMessages || __classPrivateFieldGet(this, _TxPool_dmp, "f").splice(0);
+        const horizontalMessages = params?.horizontalMessages || { ...__classPrivateFieldGet(this, _TxPool_hrmp, "f") };
+        const unsafeBlockHeight = params?.unsafeBlockHeight;
+        if (!params?.upwardMessages) {
+            for (const id of Object.keys(__classPrivateFieldGet(this, _TxPool_ump, "f"))) {
+                delete __classPrivateFieldGet(this, _TxPool_ump, "f")[id];
+            }
+        }
+        if (!params?.horizontalMessages) {
+            for (const id of Object.keys(__classPrivateFieldGet(this, _TxPool_hrmp, "f"))) {
+                delete __classPrivateFieldGet(this, _TxPool_hrmp, "f")[id];
+            }
+        }
+        await this.buildBlockWithParams({
+            transactions,
+            upwardMessages,
+            downwardMessages,
+            horizontalMessages,
+            unsafeBlockHeight,
+        });
+    }
+    async upcomingBlocks() {
+        const count = __classPrivateFieldGet(this, _TxPool_pendingBlocks, "f").length;
+        if (count > 0) {
+            await __classPrivateFieldGet(this, _TxPool_pendingBlocks, "f")[count - 1].deferred.promise;
+        }
+        return count;
+    }
+}
+_TxPool_chain = new WeakMap(), _TxPool_pool = new WeakMap(), _TxPool_ump = new WeakMap(), _TxPool_dmp = new WeakMap(), _TxPool_hrmp = new WeakMap(), _TxPool_mode = new WeakMap(), _TxPool_inherentProvider = new WeakMap(), _TxPool_pendingBlocks = new WeakMap(), _TxPool_isBuilding = new WeakMap(), _TxPool_batchBuildBlock = new WeakMap(), _TxPool_instances = new WeakSet(), _TxPool_getSigner = async function _TxPool_getSigner(extrinsic) {
+    const registry = await __classPrivateFieldGet(this, _TxPool_chain, "f").head.registry;
+    const tx = registry.createType('GenericExtrinsic', extrinsic);
+    return tx.signer.toString();
+}, _TxPool_maybeBuildBlock = function _TxPool_maybeBuildBlock() {
+    switch (__classPrivateFieldGet(this, _TxPool_mode, "f")) {
+        case BuildBlockMode.Batch:
+            __classPrivateFieldGet(this, _TxPool_batchBuildBlock, "f").call(this);
+            break;
+        case BuildBlockMode.Instant:
+            this.buildBlock();
+            break;
+        case BuildBlockMode.Manual:
+            // does nothing
+            break;
+    }
+}, _TxPool_buildBlockIfNeeded = async function _TxPool_buildBlockIfNeeded() {
+    if (__classPrivateFieldGet(this, _TxPool_isBuilding, "f"))
+        return;
+    if (__classPrivateFieldGet(this, _TxPool_pendingBlocks, "f").length === 0)
+        return;
+    __classPrivateFieldSet(this, _TxPool_isBuilding, true, "f");
+    try {
+        await __classPrivateFieldGet(this, _TxPool_instances, "m", _TxPool_buildBlock).call(this);
+    }
+    finally {
+        __classPrivateFieldSet(this, _TxPool_isBuilding, false, "f");
+    }
+    __classPrivateFieldGet(this, _TxPool_instances, "m", _TxPool_buildBlockIfNeeded).call(this);
+}, _TxPool_buildBlock = async function _TxPool_buildBlock() {
+    await __classPrivateFieldGet(this, _TxPool_chain, "f").api.isReady;
+    const pending = __classPrivateFieldGet(this, _TxPool_pendingBlocks, "f")[0];
+    if (!pending) {
+        throw new Error('Unreachable');
+    }
+    const { params, deferred } = pending;
+    logger.trace({ params }, 'build block');
+    const head = __classPrivateFieldGet(this, _TxPool_chain, "f").head;
+    const inherents = await __classPrivateFieldGet(this, _TxPool_inherentProvider, "f").createInherents(head, params);
+    const [newBlock, pendingExtrinsics] = await buildBlock(head, inherents, params.transactions, params.upwardMessages, {
+        onApplyExtrinsicError: (extrinsic, error) => {
+            this.event.emit(APPLY_EXTRINSIC_ERROR, [extrinsic, error]);
+        },
+        onPhaseApplied: logger.level.toLowerCase() === 'trace'
+            ? (phase, resp) => {
+                switch (phase) {
+                    case 'initialize':
+                        logger.trace(truncate(resp.storageDiff), 'Initialize block');
+                        break;
+                    case 'finalize':
+                        logger.trace(truncate(resp.storageDiff), 'Finalize block');
+                        break;
+                    default:
+                        logger.trace(truncate(resp.storageDiff), `Apply extrinsic ${phase}`);
+                }
+            }
+            : undefined,
+    }, params.unsafeBlockHeight);
+    for (const extrinsic of pendingExtrinsics) {
+        __classPrivateFieldGet(this, _TxPool_pool, "f").push({ extrinsic, signer: await __classPrivateFieldGet(this, _TxPool_instances, "m", _TxPool_getSigner).call(this, extrinsic) });
+    }
+    await __classPrivateFieldGet(this, _TxPool_chain, "f").onNewBlock(newBlock);
+    __classPrivateFieldGet(this, _TxPool_pendingBlocks, "f").shift();
+    deferred.resolve();
+};