@acala-network/chopsticks-core 0.8.0-0

package/lib/genesis-provider.js

@@ -0,0 +1,172 @@
+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 _a, _GenesisProvider_isConnected, _GenesisProvider_eventemitter, _GenesisProvider_isReadyPromise, _GenesisProvider_genesis, _GenesisProvider_stateRoot;
+import { EventEmitter } from 'eventemitter3';
+import { stringToHex } from '@polkadot/util';
+import axios from 'axios';
+import { genesisSchema } from './schema';
+import { calculateStateRoot, emptyTaskHandler, runTask } from './executor';
+import { isUrl } from './utils';
+export class GenesisProvider {
+    constructor(genesis) {
+        _GenesisProvider_isConnected.set(this, false);
+        _GenesisProvider_eventemitter.set(this, void 0);
+        _GenesisProvider_isReadyPromise.set(this, void 0);
+        _GenesisProvider_genesis.set(this, void 0);
+        _GenesisProvider_stateRoot.set(this, void 0);
+        this.clone = () => {
+            return new GenesisProvider(__classPrivateFieldGet(this, _GenesisProvider_genesis, "f"));
+        };
+        this.connect = () => __awaiter(this, void 0, void 0, function* () {
+            __classPrivateFieldSet(this, _GenesisProvider_isConnected, true, "f");
+            __classPrivateFieldGet(this, _GenesisProvider_eventemitter, "f").emit('connected');
+        });
+        this.disconnect = () => __awaiter(this, void 0, void 0, function* () {
+            __classPrivateFieldSet(this, _GenesisProvider_isConnected, false, "f");
+            __classPrivateFieldGet(this, _GenesisProvider_eventemitter, "f").emit('disconnected');
+        });
+        this.on = (type, sub) => {
+            __classPrivateFieldGet(this, _GenesisProvider_eventemitter, "f").on(type, sub);
+            return () => {
+                __classPrivateFieldGet(this, _GenesisProvider_eventemitter, "f").removeListener(type, sub);
+            };
+        };
+        this.getHeader = () => __awaiter(this, void 0, void 0, function* () {
+            return {
+                blockHash: this.blockHash,
+                number: 0,
+                stateRoot: yield __classPrivateFieldGet(this, _GenesisProvider_stateRoot, "f"),
+                digest: {
+                    logs: [],
+                },
+            };
+        });
+        this.getBlock = () => __awaiter(this, void 0, void 0, function* () {
+            return {
+                block: {
+                    header: yield this.getHeader(),
+                    extrinsics: [],
+                },
+            };
+        });
+        this.send = (method, params, _isCacheable) => __awaiter(this, void 0, void 0, function* () {
+            yield this.isReady;
+            switch (method) {
+                case 'system_properties':
+                    return __classPrivateFieldGet(this, _GenesisProvider_genesis, "f").properties;
+                case 'system_chain':
+                    return __classPrivateFieldGet(this, _GenesisProvider_genesis, "f").id;
+                case 'system_name':
+                    return __classPrivateFieldGet(this, _GenesisProvider_genesis, "f").name;
+                case 'state_getMetadata': {
+                    const code = __classPrivateFieldGet(this, _GenesisProvider_genesis, "f").genesis.raw.top[stringToHex(':code')];
+                    return runTask({
+                        wasm: code,
+                        calls: [['Metadata_metadata', []]],
+                        mockSignatureHost: false,
+                        allowUnresolvedImports: true,
+                        runtimeLogLevel: 0,
+                    }, this._jsCallback);
+                }
+                case 'chain_getHeader':
+                    return this.getHeader();
+                case 'chain_getBlock':
+                    return this.getBlock();
+                case 'chain_getBlockHash':
+                    return this.blockHash;
+                case 'state_getKeysPaged':
+                case 'state_getKeysPagedAt':
+                    return [];
+                case 'state_getStorage':
+                case 'state_getStorageAt':
+                    return __classPrivateFieldGet(this, _GenesisProvider_genesis, "f").genesis.raw.top[params[0]];
+                default:
+                    throw Error(`${method} not implemented`);
+            }
+        });
+        this.subscribe = (_type, _method, _params, _cb) => __awaiter(this, void 0, void 0, function* () {
+            throw Error('unimplemented');
+        });
+        this.unsubscribe = (_type, _method, _id) => __awaiter(this, void 0, void 0, function* () {
+            throw Error('unimplemented');
+        });
+        __classPrivateFieldSet(this, _GenesisProvider_genesis, genesis, "f");
+        __classPrivateFieldSet(this, _GenesisProvider_stateRoot, calculateStateRoot(Object.entries(__classPrivateFieldGet(this, _GenesisProvider_genesis, "f").genesis.raw.top).reduce((accu, item) => {
+            accu.push(item);
+            return accu;
+        }, []), 1), "f");
+        __classPrivateFieldSet(this, _GenesisProvider_eventemitter, new EventEmitter(), "f");
+        __classPrivateFieldSet(this, _GenesisProvider_isReadyPromise, new Promise((resolve, reject) => {
+            __classPrivateFieldGet(this, _GenesisProvider_eventemitter, "f").once('connected', () => {
+                resolve();
+            });
+            __classPrivateFieldGet(this, _GenesisProvider_eventemitter, "f").once('error', reject);
+        }), "f");
+    }
+    get isClonable() {
+        return true;
+    }
+    get hasSubscriptions() {
+        return false;
+    }
+    get isConnected() {
+        return __classPrivateFieldGet(this, _GenesisProvider_isConnected, "f");
+    }
+    get isReady() {
+        this.connect();
+        return __classPrivateFieldGet(this, _GenesisProvider_isReadyPromise, "f");
+    }
+    get blockHash() {
+        return '0x91b171bb158e2d3848fa23a9f1c25182fb8e20313b2c1eb49219da7a70ce90c3';
+    }
+    get _jsCallback() {
+        const storage = __classPrivateFieldGet(this, _GenesisProvider_genesis, "f").genesis.raw.top;
+        return Object.assign(Object.assign({}, emptyTaskHandler), { getStorage: function (key) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return storage[key];
+                });
+            }, getStateRoot: function () {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return '0x49416764844ff0d8bad851e8abe686dff9dd2de78621180ef8e9f99bb7a480f1';
+                });
+            }, getNextKey: function (_prefix, _key) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    return undefined;
+                });
+            } });
+    }
+}
+_a = GenesisProvider, _GenesisProvider_isConnected = new WeakMap(), _GenesisProvider_eventemitter = new WeakMap(), _GenesisProvider_isReadyPromise = new WeakMap(), _GenesisProvider_genesis = new WeakMap(), _GenesisProvider_stateRoot = new WeakMap();
+GenesisProvider.fromUrl = (url) => __awaiter(void 0, void 0, void 0, function* () {
+    const getFile = (url) => __awaiter(void 0, void 0, void 0, function* () {
+        if (isUrl(url)) {
+            return axios.get(url).then((x) => x.data);
+        }
+        else if (typeof process === 'object') {
+            const { lstatSync, readFileSync } = yield import('node:fs');
+            if (lstatSync(url).isFile()) {
+                return JSON.parse(String(readFileSync(url)));
+            }
+        }
+        throw Error(`invalid genesis path or url ${url}`);
+    });
+    return new GenesisProvider(genesisSchema.parse(yield getFile(url)));
+});

package/lib/index.d.ts

@@ -0,0 +1,13 @@
+export * from './api';
+export * from './blockchain';
+export * from './blockchain/block';
+export * from './blockchain/block-builder';
+export * from './blockchain/txpool';
+export * from './blockchain/storage-layer';
+export * from './utils';
+export * from './executor';
+export * from './schema';
+export * from './xcm';
+export * from './setup';
+export * from './blockchain/inherent';
+export * from './logger';

package/lib/index.js

@@ -0,0 +1,13 @@
+export * from './api';
+export * from './blockchain';
+export * from './blockchain/block';
+export * from './blockchain/block-builder';
+export * from './blockchain/txpool';
+export * from './blockchain/storage-layer';
+export * from './utils';
+export * from './executor';
+export * from './schema';
+export * from './xcm';
+export * from './setup';
+export * from './blockchain/inherent';
+export * from './logger';

package/lib/logger.d.ts

@@ -0,0 +1,7 @@
+export declare const defaultLogger: import("pino").Logger<{
+    level: string;
+    transport: {
+        target: string;
+    };
+}>;
+export declare const truncate: (val: any) => any;

package/lib/logger.js

@@ -0,0 +1,34 @@
+import createLogger from 'pino';
+export const defaultLogger = createLogger({
+    level: (typeof process === 'object' && process.env.LOG_LEVEL) || 'info',
+    transport: {
+        target: 'pino-pretty',
+    },
+});
+const innerTruncate = (level = 0) => (val) => {
+    const verboseLog = typeof process === 'object' ? !!process.env.VERBOSE_LOG : false;
+    const levelLimit = verboseLog ? 10 : 5;
+    if (val == null) {
+        return val;
+    }
+    if (level > levelLimit) {
+        return '( Too Deep )';
+    }
+    switch (typeof val) {
+        case 'string':
+            if (val.length > 66 && !verboseLog) {
+                return val.slice(0, 34) + '…' + val.slice(-32);
+            }
+            else {
+                return val;
+            }
+        case 'object':
+            if (Array.isArray(val)) {
+                return val.map(innerTruncate(level + 1));
+            }
+            return Object.fromEntries(Object.entries(val.toJSON ? val.toJSON() : val).map(([k, v]) => [k, innerTruncate(level + 1)(v)]));
+        default:
+            return val;
+    }
+};
+export const truncate = (val) => innerTruncate(0)(val);

package/lib/offchain.d.ts

@@ -0,0 +1,10 @@
+import { Block } from './blockchain/block';
+import { HexString } from '@polkadot/util/types';
+export declare class OffchainWorker {
+    readonly pendingExtrinsics: HexString[];
+    readonly offchainStorage: Map<string, string | null | undefined>;
+    get(key: string): string | null | undefined;
+    set(key: string, value: string | null | undefined): void;
+    run(block: Block): Promise<void>;
+    pushExtrinsic(block: Block, extrinsic: HexString): Promise<`0x${string}`>;
+}

package/lib/offchain.js

@@ -0,0 +1,49 @@
+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 { blake2AsHex } from '@polkadot/util-crypto';
+import { defaultLogger } from './logger';
+import { queueScheduler } from 'rxjs';
+const logger = defaultLogger.child({ name: 'offchain' });
+export class OffchainWorker {
+    constructor() {
+        this.pendingExtrinsics = [];
+        this.offchainStorage = new Map();
+    }
+    get(key) {
+        return this.offchainStorage.get(key);
+    }
+    set(key, value) {
+        this.offchainStorage.set(key, value);
+    }
+    run(block) {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger.info({ number: block.number, hash: block.hash }, `Run Offchain Worker for block #${block.number.toLocaleString()}`);
+            const header = yield block.header;
+            yield block.call('OffchainWorkerApi_offchain_worker', [header.toHex()]);
+            logger.info(`Offchain Worker complete for block #${block.number.toLocaleString()}`);
+            const txs = this.pendingExtrinsics.splice(0);
+            if (txs.length > 0) {
+                queueScheduler.schedule((transactions) => __awaiter(this, void 0, void 0, function* () {
+                    yield block.chain.txPool.buildBlock({ transactions });
+                }), 100, txs);
+            }
+        });
+    }
+    pushExtrinsic(block, extrinsic) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const validity = yield block.chain.validateExtrinsic(extrinsic, '0x01');
+            if (validity.isOk) {
+                this.pendingExtrinsics.push(extrinsic);
+                return blake2AsHex(extrinsic, 256);
+            }
+            throw validity.asErr;
+        });
+    }
+}

package/lib/schema/index.d.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+export declare const genesisSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    properties: z.ZodObject<{
+        ss58Format: z.ZodOptional<z.ZodNumber>;
+        tokenDecimals: z.ZodOptional<z.ZodUnion<[z.ZodNumber, z.ZodArray<z.ZodNumber, "many">]>>;
+        tokenSymbol: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    }, "strip", z.ZodTypeAny, {
+        ss58Format?: number | undefined;
+        tokenDecimals?: number | number[] | undefined;
+        tokenSymbol?: string | string[] | undefined;
+    }, {
+        ss58Format?: number | undefined;
+        tokenDecimals?: number | number[] | undefined;
+        tokenSymbol?: string | string[] | undefined;
+    }>;
+    genesis: z.ZodObject<{
+        raw: z.ZodObject<{
+            top: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            top: Record<string, string>;
+        }, {
+            top: Record<string, string>;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        raw: {
+            top: Record<string, string>;
+        };
+    }, {
+        raw: {
+            top: Record<string, string>;
+        };
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    id: string;
+    properties: {
+        ss58Format?: number | undefined;
+        tokenDecimals?: number | number[] | undefined;
+        tokenSymbol?: string | string[] | undefined;
+    };
+    genesis: {
+        raw: {
+            top: Record<string, string>;
+        };
+    };
+}, {
+    name: string;
+    id: string;
+    properties: {
+        ss58Format?: number | undefined;
+        tokenDecimals?: number | number[] | undefined;
+        tokenSymbol?: string | string[] | undefined;
+    };
+    genesis: {
+        raw: {
+            top: Record<string, string>;
+        };
+    };
+}>;
+export type Genesis = z.infer<typeof genesisSchema>;

package/lib/schema/index.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+export const genesisSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    properties: z.object({
+        ss58Format: z.number().optional(),
+        tokenDecimals: z.union([z.number(), z.array(z.number())]).optional(),
+        tokenSymbol: z.union([z.string(), z.array(z.string())]).optional(),
+    }),
+    genesis: z.object({ raw: z.object({ top: z.record(z.string()) }) }),
+});

package/lib/setup.d.ts

@@ -0,0 +1,20 @@
+import '@polkadot/types-codec';
+import { RegisteredTypes } from '@polkadot/types/types';
+import { Blockchain } from './blockchain';
+import { BuildBlockMode } from './blockchain/txpool';
+import { Genesis } from './schema';
+type Options = {
+    endpoint?: string;
+    block?: string | number | null;
+    genesis?: string | Genesis;
+    buildBlockMode?: BuildBlockMode;
+    db?: string;
+    mockSignatureHost?: boolean;
+    allowUnresolvedImports?: boolean;
+    runtimeLogLevel?: number;
+    registeredTypes?: RegisteredTypes;
+    offchainWorker?: boolean;
+    maxMemoryBlockCount?: number;
+};
+export declare const setup: (options: Options) => Promise<Blockchain>;
+export {};

package/lib/setup.js

@@ -0,0 +1,74 @@
+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 '@polkadot/types-codec';
+import { WsProvider } from '@polkadot/api';
+import { Api } from './api';
+import { Blockchain } from './blockchain';
+import { GenesisProvider } from './genesis-provider';
+import { InherentProviders, ParaInherentEnter, SetBabeRandomness, SetNimbusAuthorInherent, SetTimestamp, SetValidationData, } from './blockchain/inherent';
+import { defaultLogger } from './logger';
+import { openDb } from './db';
+export const setup = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    let provider;
+    if (options.genesis) {
+        if (typeof options.genesis === 'string') {
+            provider = yield GenesisProvider.fromUrl(options.genesis);
+        }
+        else {
+            provider = new GenesisProvider(options.genesis);
+        }
+    }
+    else {
+        provider = new WsProvider(options.endpoint);
+    }
+    const api = new Api(provider);
+    yield api.isReady;
+    let blockHash;
+    if (options.block == null) {
+        blockHash = yield api.getBlockHash();
+    }
+    else if (typeof options.block === 'string' && options.block.startsWith('0x')) {
+        blockHash = options.block;
+    }
+    else if (Number.isInteger(+options.block)) {
+        blockHash = yield api.getBlockHash(Number(options.block));
+    }
+    else {
+        throw new Error(`Invalid block number or hash: ${options.block}`);
+    }
+    defaultLogger.debug(Object.assign(Object.assign({}, options), { blockHash }), 'Args');
+    let db;
+    if (options.db) {
+        db = yield openDb(options.db);
+    }
+    const header = yield api.getHeader(blockHash);
+    const inherents = new InherentProviders(new SetTimestamp(), [
+        new SetValidationData(),
+        new ParaInherentEnter(),
+        new SetNimbusAuthorInherent(),
+        new SetBabeRandomness(),
+    ]);
+    return new Blockchain({
+        api,
+        buildBlockMode: options.buildBlockMode,
+        inherentProvider: inherents,
+        db,
+        header: {
+            hash: blockHash,
+            number: Number(header.number),
+        },
+        mockSignatureHost: options.mockSignatureHost,
+        allowUnresolvedImports: options.allowUnresolvedImports,
+        runtimeLogLevel: options.runtimeLogLevel,
+        registeredTypes: options.registeredTypes || {},
+        offchainWorker: options.offchainWorker,
+        maxMemoryBlockCount: options.maxMemoryBlockCount,
+    });
+});

package/lib/utils/index.d.ts

@@ -0,0 +1,18 @@
+import { HexString } from '@polkadot/util/types';
+import { StorageKey } from '@polkadot/types';
+import { Blockchain } from '../blockchain';
+export * from './set-storage';
+export * from './time-travel';
+export type GetKeys = (startKey?: string) => Promise<StorageKey<any>[]>;
+export type ProcessKey = (key: StorageKey<any>) => any;
+export declare function fetchKeys(getKeys: GetKeys, processKey: ProcessKey): Promise<void>;
+export declare function fetchKeysToArray(getKeys: GetKeys): Promise<StorageKey<any>[]>;
+export declare const compactHex: (value: Uint8Array) => HexString;
+export declare const getParaId: (chain: Blockchain) => Promise<import("@polkadot/types").U32>;
+export declare const isUrl: (url: string) => boolean;
+export type Deferred<T> = {
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+    promise: Promise<T>;
+};
+export declare function defer<T>(): Deferred<T>;

package/lib/utils/index.js

@@ -0,0 +1,65 @@
+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 { compactStripLength, hexToU8a, u8aToHex } from '@polkadot/util';
+export * from './set-storage';
+export * from './time-travel';
+export function fetchKeys(getKeys, processKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const processKeys = (keys) => __awaiter(this, void 0, void 0, function* () {
+            for (const key of keys) {
+                yield processKey(key);
+            }
+            if (keys.length > 0) {
+                return keys[keys.length - 1];
+            }
+            return undefined;
+        });
+        const keys = yield getKeys();
+        let nextKey = yield processKeys(keys);
+        while (nextKey) {
+            const keys = yield getKeys(nextKey.toHex());
+            nextKey = yield processKeys(keys);
+        }
+    });
+}
+export function fetchKeysToArray(getKeys) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const res = [];
+        yield fetchKeys(getKeys, (key) => res.push(key));
+        return res;
+    });
+}
+export const compactHex = (value) => {
+    return u8aToHex(compactStripLength(value)[1]);
+};
+export const getParaId = (chain) => __awaiter(void 0, void 0, void 0, function* () {
+    const meta = yield chain.head.meta;
+    const raw = yield chain.head.get(compactHex(meta.query.parachainInfo.parachainId()));
+    if (!raw)
+        throw new Error('Cannot find parachain id');
+    return meta.registry.createType('u32', hexToU8a(raw));
+});
+export const isUrl = (url) => {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+export function defer() {
+    const deferred = {};
+    deferred.promise = new Promise((resolve, reject) => {
+        deferred.resolve = resolve;
+        deferred.reject = reject;
+    });
+    return deferred;
+}

package/lib/utils/key-cache.d.ts

@@ -0,0 +1,10 @@
+import { HexString } from '@polkadot/util/types';
+export declare const PREFIX_LENGTH = 66;
+export default class KeyCache {
+    readonly ranges: Array<{
+        prefix: string;
+        keys: string[];
+    }>;
+    feed(keys: HexString[]): void;
+    next(startKey: HexString): Promise<HexString | undefined>;
+}

package/lib/utils/key-cache.js

@@ -0,0 +1,72 @@
+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 _ from 'lodash';
+// 0x + 32 module + 32 method
+export const PREFIX_LENGTH = 66;
+export default class KeyCache {
+    constructor() {
+        this.ranges = [];
+    }
+    feed(keys) {
+        const _keys = keys.filter((key) => key.length >= PREFIX_LENGTH);
+        if (_keys.length === 0)
+            return;
+        const startKey = _keys[0].slice(PREFIX_LENGTH);
+        const endKey = _keys[_keys.length - 1].slice(PREFIX_LENGTH);
+        const grouped = _.groupBy(_keys, (key) => key.slice(0, PREFIX_LENGTH));
+        for (const [prefix, keys] of Object.entries(grouped)) {
+            const ranges = this.ranges.filter((range) => range.prefix === prefix);
+            if (ranges.length === 0) {
+                // no existing range with prefix
+                this.ranges.push({ prefix, keys: keys.map((i) => i.slice(PREFIX_LENGTH)) });
+                continue;
+            }
+            let merged = false;
+            for (const range of ranges) {
+                const startPosition = _.sortedIndex(range.keys, startKey);
+                if (startPosition >= 0 && range.keys[startPosition] === startKey) {
+                    // found existing range with prefix
+                    range.keys.splice(startPosition, keys.length, ...keys.map((i) => i.slice(PREFIX_LENGTH)));
+                    merged = true;
+                    break;
+                }
+                const endPosition = _.sortedIndex(range.keys, endKey);
+                if (endPosition >= 0 && range.keys[endPosition] === endKey) {
+                    // found existing range with prefix
+                    range.keys.splice(0, endPosition + 1, ...keys.map((i) => i.slice(PREFIX_LENGTH)));
+                    merged = true;
+                    break;
+                }
+            }
+            // insert new prefix with range
+            if (!merged) {
+                this.ranges.push({ prefix, keys: keys.map((i) => i.slice(PREFIX_LENGTH)) });
+            }
+        }
+        // TODO: merge ranges if they overlap
+    }
+    next(startKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (startKey.length < PREFIX_LENGTH)
+                return;
+            const prefix = startKey.slice(0, PREFIX_LENGTH);
+            const key = startKey.slice(PREFIX_LENGTH);
+            for (const range of this.ranges.filter((range) => range.prefix === prefix)) {
+                const index = _.sortedIndex(range.keys, key);
+                if (range.keys[index] !== key)
+                    continue;
+                const nextKey = range.keys[index + 1];
+                if (nextKey) {
+                    return [prefix, nextKey].join('');
+                }
+            }
+        });
+    }
+}

package/lib/utils/proof.d.ts

@@ -0,0 +1,15 @@
+import { HrmpChannelId } from '@polkadot/types/interfaces';
+import { u32 } from '@polkadot/types';
+export declare const WELL_KNOWN_KEYS: {
+    EPOCH_INDEX: `0x${string}`;
+    CURRENT_BLOCK_RANDOMNESS: `0x${string}`;
+    ONE_EPOCH_AGO_RANDOMNESS: `0x${string}`;
+    TWO_EPOCHS_AGO_RANDOMNESS: `0x${string}`;
+    CURRENT_SLOT: `0x${string}`;
+    ACTIVE_CONFIG: `0x${string}`;
+};
+export declare const dmqMqcHead: (paraId: u32) => `0x${string}`;
+export declare const upgradeGoAheadSignal: (paraId: u32) => `0x${string}`;
+export declare const hrmpIngressChannelIndex: (paraId: u32) => `0x${string}`;
+export declare const hrmpEgressChannelIndex: (paraId: u32) => `0x${string}`;
+export declare const hrmpChannels: (channelId: HrmpChannelId) => `0x${string}`;