@dedot/api 0.0.1-alpha.32

package/client/DedotClient.js

@@ -0,0 +1,182 @@
+import { $H256, PortableRegistry } from '@dedot/codecs';
+import { u32 } from '@dedot/shape';
+import { assert, concatU8a, noop, twox64Concat, u8aToHex, xxhashAsU8a } from '@dedot/utils';
+import { ConstantExecutor, ErrorExecutor, EventExecutor, RuntimeApiExecutorV2, StorageQueryExecutorV2, TxExecutorV2, } from '../executor/index.js';
+import { ChainHead, ChainSpec, Transaction, TransactionWatch } from '../json-rpc/index.js';
+import { newProxyChain } from '../proxychain.js';
+import { BaseSubstrateClient, ensurePresence } from './BaseSubstrateClient.js';
+/**
+ * @name DedotClient
+ * @description New promised-based API Client for Polkadot & Substrate based on JSON-RPC V2
+ *
+ * __Unstable, use with caution.__
+ */
+export class DedotClient extends BaseSubstrateClient {
+    _chainHead;
+    _chainSpec;
+    _txBroadcaster;
+    #apiAtCache = {};
+    /**
+     * Use factory methods (`create`, `new`) to create `DedotClient` instances.
+     *
+     * @param options
+     */
+    constructor(options) {
+        super('v2', options);
+    }
+    /**
+     * Factory method to create a new DedotClient instance
+     *
+     * @param options
+     */
+    static async create(options) {
+        return new DedotClient(options).connect();
+    }
+    /**
+     * Alias for __DedotClient.create__
+     *
+     * @param options
+     */
+    static async new(options) {
+        return DedotClient.create(options);
+    }
+    get chainSpec() {
+        return ensurePresence(this._chainSpec);
+    }
+    get chainHead() {
+        return ensurePresence(this._chainHead);
+    }
+    get txBroadcaster() {
+        this.chainHead; // Ensure chain head is initialized
+        assert(this._txBroadcaster, 'JSON-RPC method to broadcast transactions is not supported by the server/node.');
+        return this._txBroadcaster;
+    }
+    async #initializeTxBroadcaster(rpcMethods) {
+        const tx = new Transaction(this, { rpcMethods });
+        if (await tx.supported())
+            return tx;
+        const txWatch = new TransactionWatch(this, { rpcMethods });
+        if (await txWatch.supported())
+            return txWatch;
+    }
+    /**
+     * Initialize APIs before usage
+     */
+    async doInitialize() {
+        const rpcMethods = (await this.rpc.rpc_methods()).methods;
+        this._chainHead = new ChainHead(this, { rpcMethods });
+        this._chainSpec = new ChainSpec(this, { rpcMethods });
+        this._txBroadcaster = await this.#initializeTxBroadcaster(rpcMethods);
+        // Fetching node information
+        let [_, genesisHash] = await Promise.all([
+            this.chainHead.follow(),
+            this.chainSpec.genesisHash().catch(() => undefined),
+        ]);
+        this._genesisHash = genesisHash || (await this.#getGenesisHashFallback());
+        this._runtimeVersion = await this.chainHead.bestRuntimeVersion();
+        let metadata;
+        if (await this.shouldPreloadMetadata()) {
+            metadata = await this.fetchMetadata();
+        }
+        await this.setupMetadata(metadata);
+        this.subscribeRuntimeUpgrades();
+    }
+    /**
+     * Ref: https://github.com/paritytech/polkadot-sdk/blob/bbd51ce867967f71657b901f1a956ad4f75d352e/substrate/frame/system/src/lib.rs#L909-L913
+     * @private
+     */
+    async #getGenesisHashFallback() {
+        const pallet = xxhashAsU8a('System', 128);
+        const item = xxhashAsU8a('BlockHash', 128);
+        const blockHeightAt0 = twox64Concat(u32.encode(0));
+        const key = u8aToHex(concatU8a(pallet, item, blockHeightAt0));
+        const storageValue = await this.chainHead.storage([{ type: 'value', key }]);
+        const rawGenesisHash = storageValue.at(0)?.value;
+        assert(rawGenesisHash, 'Genesis hash not found!');
+        // Here we assume that in most case the hash is stored as a H256
+        return $H256.tryDecode(rawGenesisHash);
+    }
+    subscribeRuntimeUpgrades() {
+        this.chainHead.on('bestBlock', this.onRuntimeUpgrade);
+    }
+    unsubscribeRuntimeUpgrades() {
+        this.chainHead.off('bestBlock', this.onRuntimeUpgrade);
+    }
+    onRuntimeUpgrade = async (block) => {
+        const runtimeUpgraded = block.runtime && block.runtime.specVersion !== this._runtimeVersion?.specVersion;
+        if (!runtimeUpgraded)
+            return;
+        this._runtimeVersion = block.runtime;
+        const newMetadata = await this.fetchMetadata(undefined, this._runtimeVersion);
+        await this.setupMetadata(newMetadata);
+    };
+    async beforeDisconnect() {
+        await this.chainHead.unfollow();
+    }
+    onDisconnected = async () => {
+        this.chainHead.unfollow().catch(noop);
+    };
+    cleanUp() {
+        super.cleanUp();
+        this._chainHead = undefined;
+        this._chainSpec = undefined;
+        this._txBroadcaster = undefined;
+        this.#apiAtCache = {};
+    }
+    get query() {
+        return newProxyChain({
+            executor: new StorageQueryExecutorV2(this, this.chainHead),
+        });
+    }
+    get call() {
+        return this.callAt();
+    }
+    callAt(blockHash) {
+        return newProxyChain({
+            executor: new RuntimeApiExecutorV2(this, this.chainHead, blockHash),
+        });
+    }
+    get tx() {
+        return newProxyChain({ executor: new TxExecutorV2(this) });
+    }
+    /**
+     * Get a new API instance at a specific block hash
+     * For now, this only supports pinned block hashes from the chain head
+     *
+     * @param hash
+     */
+    async at(hash) {
+        if (this.#apiAtCache[hash])
+            return this.#apiAtCache[hash];
+        const targetBlock = this.chainHead.findBlock(hash);
+        assert(targetBlock, 'Block is not pinned!');
+        let targetVersion = targetBlock.runtime;
+        if (!targetVersion) {
+            // fallback to fetching on-chain runtime if we can't find it in the block
+            targetVersion = this.toSubstrateRuntimeVersion(await this.callAt(hash).core.version());
+        }
+        let metadata = this.metadata;
+        let registry = this.registry;
+        if (targetVersion && targetVersion.specVersion !== this.runtimeVersion.specVersion) {
+            metadata = await this.fetchMetadata(hash, targetVersion);
+            registry = new PortableRegistry(metadata.latest, this.options.hasher);
+        }
+        const api = {
+            rpcVersion: 'v2',
+            atBlockHash: hash,
+            options: this.options,
+            genesisHash: this.genesisHash,
+            runtimeVersion: targetVersion,
+            metadata,
+            registry,
+            rpc: this.rpc,
+        };
+        api.consts = newProxyChain({ executor: new ConstantExecutor(api) });
+        api.events = newProxyChain({ executor: new EventExecutor(api) });
+        api.errors = newProxyChain({ executor: new ErrorExecutor(api) });
+        api.query = newProxyChain({ executor: new StorageQueryExecutorV2(api, this.chainHead) });
+        api.call = newProxyChain({ executor: new RuntimeApiExecutorV2(api, this.chainHead) });
+        this.#apiAtCache[hash] = api;
+        return api;
+    }
+}

package/client/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Dedot.js';
+export * from './DedotClient.js';

package/client/index.js

@@ -0,0 +1,2 @@
+export * from './Dedot.js';
+export * from './DedotClient.js';

package/executor/ConstantExecutor.d.ts

@@ -0,0 +1,10 @@
+import { GenericSubstrateApi } from '@dedot/types';
+import { Executor } from './Executor.js';
+/**
+ * @name ConstantExecutor
+ *
+ * Find & decode the constant value from metadata
+ */
+export declare class ConstantExecutor<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> extends Executor<ChainApi> {
+    doExecute(pallet: string, constantName: string): unknown;
+}

package/executor/ConstantExecutor.js

@@ -0,0 +1,16 @@
+import { assert, stringCamelCase, UnknownApiError } from '@dedot/utils';
+import { Executor } from './Executor.js';
+/**
+ * @name ConstantExecutor
+ *
+ * Find & decode the constant value from metadata
+ */
+export class ConstantExecutor extends Executor {
+    doExecute(pallet, constantName) {
+        const targetPallet = this.getPallet(pallet);
+        const constantDef = targetPallet.constants.find((one) => stringCamelCase(one.name) === constantName);
+        assert(constantDef, new UnknownApiError(`Constant ${constantName} not found in pallet ${pallet}`));
+        const $codec = this.registry.findCodec(constantDef.typeId);
+        return $codec.tryDecode(constantDef.value);
+    }
+}

package/executor/ErrorExecutor.d.ts

@@ -0,0 +1,10 @@
+import type { GenericPalletError, GenericSubstrateApi } from '@dedot/types';
+import { Executor } from './Executor.js';
+/**
+ * @name ErrorExecutor
+ * @description Find pallet error information from metadata
+ */
+export declare class ErrorExecutor<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> extends Executor<ChainApi> {
+    #private;
+    doExecute(pallet: string, errorName: string): GenericPalletError;
+}

package/executor/ErrorExecutor.js

@@ -0,0 +1,42 @@
+import { assert, hexToU8a, isHex, isNumber, isObject, stringPascalCase, UnknownApiError } from '@dedot/utils';
+import { Executor } from './Executor.js';
+/**
+ * @name ErrorExecutor
+ * @description Find pallet error information from metadata
+ */
+export class ErrorExecutor extends Executor {
+    doExecute(pallet, errorName) {
+        const targetPallet = this.getPallet(pallet);
+        const errorTypeId = targetPallet.error;
+        assert(errorTypeId, new UnknownApiError(`Not found error with id ${errorTypeId} in pallet ${pallet}`));
+        const errorDef = this.#getErrorDef(errorTypeId, errorName);
+        return {
+            meta: {
+                ...errorDef,
+                pallet: targetPallet.name,
+                palletIndex: targetPallet.index,
+            },
+            is: (errorInfo) => {
+                if (isObject(errorInfo) && errorInfo.tag === 'Module') {
+                    errorInfo = errorInfo.value;
+                }
+                if (isObject(errorInfo) && isNumber(errorInfo.index) && isHex(errorInfo.error)) {
+                    return errorInfo.index === targetPallet.index && hexToU8a(errorInfo.error)[0] === errorDef.index;
+                }
+                return false;
+            },
+        };
+    }
+    #getErrorDef(errorTypeId, errorName) {
+        const def = this.metadata.types[errorTypeId];
+        assert(def, new UnknownApiError(`Error def not found for id ${errorTypeId}`));
+        const { tag, value } = def.type;
+        assert(tag === 'Enum', new UnknownApiError(`Error type should be an enum, found: ${tag}`));
+        const errorDef = value.members.find(({ name }) => stringPascalCase(name) === errorName);
+        assert(errorDef, new UnknownApiError(`Error def not found for ${errorName}`));
+        return {
+            ...errorDef,
+            fieldCodecs: errorDef.fields.map(({ typeId }) => this.registry.findCodec(typeId)),
+        };
+    }
+}

package/executor/EventExecutor.d.ts

@@ -0,0 +1,10 @@
+import type { GenericPalletEvent, GenericSubstrateApi } from '@dedot/types';
+import { Executor } from './Executor.js';
+/**
+ * @name EventExecutor
+ * @description Find pallet event information from metadata
+ */
+export declare class EventExecutor<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> extends Executor<ChainApi> {
+    #private;
+    doExecute(pallet: string, errorName: string): GenericPalletEvent;
+}

package/executor/EventExecutor.js

@@ -0,0 +1,48 @@
+import { assert, stringCamelCase, stringPascalCase, UnknownApiError } from '@dedot/utils';
+import { Executor } from './Executor.js';
+/**
+ * @name EventExecutor
+ * @description Find pallet event information from metadata
+ */
+export class EventExecutor extends Executor {
+    doExecute(pallet, errorName) {
+        const targetPallet = this.getPallet(pallet);
+        const eventTypeId = targetPallet.event;
+        assert(eventTypeId, new UnknownApiError(`Not found event with id ${eventTypeId} in pallet ${pallet}`));
+        const eventDef = this.#getEventDef(eventTypeId, errorName);
+        const is = (event) => {
+            const palletCheck = stringCamelCase(event.pallet) === pallet;
+            if (typeof event.palletEvent === 'string') {
+                return palletCheck && stringPascalCase(event.palletEvent) === errorName;
+            }
+            else if (typeof event.palletEvent === 'object') {
+                return palletCheck && stringPascalCase(event.palletEvent.name) === errorName;
+            }
+            return false;
+        };
+        const as = (event) => {
+            return is(event) ? event : undefined;
+        };
+        return {
+            is,
+            as,
+            meta: {
+                ...eventDef,
+                pallet: targetPallet.name,
+                palletIndex: targetPallet.index,
+            },
+        };
+    }
+    #getEventDef(eventTypeId, errorName) {
+        const def = this.metadata.types[eventTypeId];
+        assert(def, new UnknownApiError(`Event def not found for id ${eventTypeId}`));
+        const { tag, value } = def.type;
+        assert(tag === 'Enum', new UnknownApiError(`Event type should be an enum, found: ${tag}`));
+        const eventDef = value.members.find(({ name }) => stringPascalCase(name) === errorName);
+        assert(eventDef, new UnknownApiError(`Event def not found for ${errorName}`));
+        return {
+            ...eventDef,
+            fieldCodecs: eventDef.fields.map(({ typeId }) => this.registry.findCodec(typeId)),
+        };
+    }
+}

package/executor/Executor.d.ts

@@ -0,0 +1,149 @@
+import type { BlockHash, PalletDefLatest } from '@dedot/codecs';
+import type { GenericSubstrateApi } from '@dedot/types';
+import { ISubstrateClientAt } from '../types.js';
+/**
+ * @name Executor
+ * @description Execution abstraction for a specific action
+ */
+export declare abstract class Executor<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> {
+    #private;
+    api: ISubstrateClientAt<ChainApi>;
+    constructor(api: ISubstrateClientAt<ChainApi>, atBlockHash?: BlockHash);
+    get atBlockHash(): `0x${string}` | undefined;
+    get registry(): import("@dedot/codecs").PortableRegistry;
+    get metadata(): {
+        types: {
+            id: number;
+            path: string[];
+            params: {
+                name: string;
+                typeId: number | undefined;
+            }[];
+            type: {
+                tag: "Struct";
+                value: {
+                    fields: import("@dedot/codecs").Field[];
+                };
+            } | {
+                tag: "Enum";
+                value: {
+                    members: {
+                        name: string;
+                        fields: import("@dedot/codecs").Field[];
+                        index: number;
+                        docs: string[];
+                    }[];
+                };
+            } | {
+                tag: "Sequence";
+                value: {
+                    typeParam: number;
+                };
+            } | {
+                tag: "SizedVec";
+                value: {
+                    len: number;
+                    typeParam: number;
+                };
+            } | {
+                tag: "Tuple";
+                value: {
+                    fields: number[];
+                };
+            } | {
+                tag: "Primitive";
+                value: {
+                    kind: "bool" | "char" | "str" | "u8" | "u16" | "u32" | "u64" | "u128" | "u256" | "i8" | "i16" | "i32" | "i64" | "i128" | "i256";
+                };
+            } | {
+                tag: "Compact";
+                value: {
+                    typeParam: number;
+                };
+            } | {
+                tag: "BitSequence";
+                value: {
+                    bitOrderType: number;
+                    bitStoreType: number;
+                };
+            };
+            docs: string[];
+        }[];
+        pallets: {
+            name: string;
+            storage: {
+                prefix: string;
+                entries: {
+                    name: string;
+                    modifier: string;
+                    type: {
+                        tag: "Plain";
+                        value: {
+                            valueTypeId: number;
+                        };
+                    } | {
+                        tag: "Map";
+                        value: {
+                            hashers: ("identity" | "blake2_128" | "blake2_256" | "blake2_128Concat" | "twox128" | "twox256" | "twox64Concat")[];
+                            keyTypeId: number;
+                            valueTypeId: number;
+                        };
+                    };
+                    default: `0x${string}`;
+                    docs: string[];
+                }[];
+            } | undefined;
+            calls: number | undefined;
+            event: number | undefined;
+            constants: {
+                name: string;
+                typeId: number;
+                value: `0x${string}`;
+                docs: string[];
+            }[];
+            error: number | undefined;
+            index: number;
+            docs: string[];
+        }[];
+        extrinsic: {
+            version: number;
+            addressTypeId: number;
+            callTypeId: number;
+            signatureTypeId: number;
+            extraTypeId: number;
+            signedExtensions: {
+                ident: string;
+                typeId: number;
+                additionalSigned: number;
+            }[];
+        };
+        runtimeType: number;
+        apis: {
+            name: string;
+            methods: {
+                name: string;
+                inputs: {
+                    name: string;
+                    typeId: number;
+                }[];
+                output: number;
+                docs: string[];
+            }[];
+            docs: string[];
+        }[];
+        outerEnums: {
+            callEnumTypeId: number;
+            eventEnumTypeId: number;
+            errorEnumTypeId: number;
+        };
+        custom: {
+            map: ReadonlyMap<string, {
+                typeId: number;
+                value: `0x${string}`;
+            }>;
+        };
+    };
+    getPallet(name: string): PalletDefLatest;
+    execute(...paths: string[]): unknown;
+    abstract doExecute(...paths: string[]): unknown;
+}

package/executor/Executor.js

@@ -0,0 +1,38 @@
+import { assert, stringCamelCase, UnknownApiError } from '@dedot/utils';
+/**
+ * @name Executor
+ * @description Execution abstraction for a specific action
+ */
+export class Executor {
+    api;
+    #atBlockHash;
+    constructor(api, atBlockHash) {
+        this.api = api;
+        this.#atBlockHash = atBlockHash;
+    }
+    get atBlockHash() {
+        return this.#atBlockHash || this.api.atBlockHash;
+    }
+    get registry() {
+        return this.api.registry;
+    }
+    get metadata() {
+        return this.registry.metadata;
+    }
+    getPallet(name) {
+        const targetPallet = this.metadata.pallets.find((p) => stringCamelCase(p.name) === name);
+        assert(targetPallet, new UnknownApiError(`Pallet not found: ${name}`));
+        return targetPallet;
+    }
+    execute(...paths) {
+        try {
+            return this.doExecute(...paths);
+        }
+        catch (e) {
+            if (!this.api.options?.throwOnUnknownApi && e instanceof UnknownApiError) {
+                return undefined;
+            }
+            throw e;
+        }
+    }
+}

package/executor/RuntimeApiExecutor.d.ts

@@ -0,0 +1,27 @@
+import { BlockHash } from '@dedot/codecs';
+import type { GenericRuntimeApiMethod, GenericSubstrateApi, RuntimeApiMethodParamSpec, RuntimeApiMethodSpec, RuntimeApiSpec } from '@dedot/types';
+import { HexString } from '@dedot/utils';
+import { Executor } from './Executor.js';
+export declare const FallbackRuntimeApis: Record<string, number>;
+export declare const FallbackRuntimeApiSpecs: {
+    Metadata: RuntimeApiSpec[];
+};
+export interface StateCallParams {
+    func: string;
+    params: HexString;
+    at?: BlockHash;
+}
+/**
+ * @name RuntimeApiExecutor
+ * @description Execute a runtime api call,
+ * runtime api definitions/specs are either from Metadata V15
+ * or defined externally when initializing `Dedot` instance
+ * via `ApiOptions.runtimeApis` option.
+ */
+export declare class RuntimeApiExecutor<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> extends Executor<ChainApi> {
+    #private;
+    doExecute(runtimeApi: string, method: string): GenericRuntimeApiMethod;
+    protected stateCall(callParams: StateCallParams): Promise<HexString>;
+    tryDecode(callSpec: RuntimeApiMethodSpec, raw: any): unknown;
+    tryEncode(paramSpec: RuntimeApiMethodParamSpec, value: any): Uint8Array;
+}

package/executor/RuntimeApiExecutor.js

@@ -0,0 +1,117 @@
+import { Metadata, toRuntimeApiMethods, toRuntimeApiSpecs } from '@dedot/runtime-specs';
+import { assert, calcRuntimeApiHash, concatU8a, isNumber, stringPascalCase, stringSnakeCase, u8aToHex, UnknownApiError, } from '@dedot/utils';
+import { Executor } from './Executor.js';
+export const FallbackRuntimeApis = { '0x37e397fc7c91f5e4': 2 };
+export const FallbackRuntimeApiSpecs = { Metadata };
+/**
+ * @name RuntimeApiExecutor
+ * @description Execute a runtime api call,
+ * runtime api definitions/specs are either from Metadata V15
+ * or defined externally when initializing `Dedot` instance
+ * via `ApiOptions.runtimeApis` option.
+ */
+export class RuntimeApiExecutor extends Executor {
+    doExecute(runtimeApi, method) {
+        const runtimeApiName = stringPascalCase(runtimeApi);
+        const methodName = stringSnakeCase(method);
+        const callName = this.#callName({ runtimeApiName, methodName });
+        const callSpec = this.#findRuntimeApiMethodSpec(runtimeApiName, methodName);
+        assert(callSpec, new UnknownApiError(`Runtime api spec not found for ${callName}`));
+        const callFn = async (...args) => {
+            const { params } = callSpec;
+            const formattedInputs = params.map((param, index) => this.tryEncode(param, args[index]));
+            const bytes = u8aToHex(concatU8a(...formattedInputs));
+            const callParams = {
+                func: callName,
+                params: bytes,
+                at: this.atBlockHash,
+            };
+            const result = await this.stateCall(callParams);
+            return this.tryDecode(callSpec, result);
+        };
+        callFn.meta = callSpec;
+        return callFn;
+    }
+    stateCall(callParams) {
+        const { func, params, at } = callParams;
+        const args = [func, params];
+        if (at)
+            args.push(at);
+        return this.api.rpc.state_call(...args);
+    }
+    tryDecode(callSpec, raw) {
+        const $codec = this.#findCodec(callSpec, `Codec not found to decode respond data for ${this.#callName(callSpec)}`);
+        return $codec.tryDecode(raw);
+    }
+    tryEncode(paramSpec, value) {
+        const $codec = this.#findCodec(paramSpec, `Codec not found to encode input for param ${paramSpec.name}`);
+        return $codec.tryEncode(value);
+    }
+    #findCodec(spec, error) {
+        const { codec, typeId, type } = spec;
+        if (codec)
+            return codec;
+        if (isNumber(typeId)) {
+            return this.registry.findCodec(typeId);
+        }
+        throw new Error(error || 'Codec not found');
+    }
+    #callName({ runtimeApiName, methodName }) {
+        return `${runtimeApiName}_${methodName}`;
+    }
+    #findRuntimeApiMethodSpec(runtimeApi, method) {
+        const targetVersion = this.#findTargetRuntimeApiVersion(runtimeApi);
+        if (!isNumber(targetVersion))
+            return undefined;
+        const userDefinedSpec = this.#findDefinedSpec(this.api.options.runtimeApis, runtimeApi, method, targetVersion);
+        if (userDefinedSpec)
+            return userDefinedSpec;
+        const methodDef = this.#findRuntimeApiMethodDef(runtimeApi, method);
+        if (methodDef) {
+            return this.#toMethodSpec(runtimeApi, methodDef);
+        }
+        return this.#findDefinedSpec(FallbackRuntimeApiSpecs, runtimeApi, method, targetVersion);
+    }
+    #findRuntimeApiMethodDef(runtimeApi, method) {
+        try {
+            for (const api of this.metadata.apis) {
+                if (api.name !== runtimeApi)
+                    continue;
+                for (const apiMethod of api.methods) {
+                    if (apiMethod.name === method)
+                        return apiMethod;
+                }
+            }
+        }
+        catch { }
+    }
+    #toMethodSpec(runtimeApi, methodDef) {
+        const { name, inputs, output, docs } = methodDef;
+        return {
+            docs,
+            runtimeApiName: runtimeApi,
+            methodName: name,
+            typeId: output,
+            params: inputs.map(({ name, typeId }) => ({
+                name,
+                typeId,
+            })),
+        };
+    }
+    #findTargetRuntimeApiVersion(runtimeApi) {
+        const runtimeApiHash = calcRuntimeApiHash(runtimeApi);
+        try {
+            return this.api.runtimeVersion.apis[runtimeApiHash] || FallbackRuntimeApis[runtimeApiHash];
+        }
+        catch {
+            return FallbackRuntimeApis[runtimeApiHash];
+        }
+    }
+    #findDefinedSpec(specs, runtimeApi, method, runtimeApiVersion) {
+        if (!specs)
+            return undefined;
+        const methodSpecs = toRuntimeApiSpecs(specs).map(toRuntimeApiMethods).flat();
+        return methodSpecs.find(({ runtimeApiName, methodName, version }) => `${stringPascalCase(runtimeApiName)}_${stringSnakeCase(methodName)}` === `${runtimeApi}_${method}` &&
+            runtimeApiVersion === version);
+    }
+}

package/executor/StorageQueryExecutor.d.ts

@@ -0,0 +1,14 @@
+import { BlockHash, Option, StorageData, StorageKey } from '@dedot/codecs';
+import type { AsyncMethod, Callback, GenericStorageQuery, GenericSubstrateApi, Unsub } from '@dedot/types';
+import { QueryableStorage } from '../storage/QueryableStorage.js';
+import { Executor } from './Executor.js';
+/**
+ * @name StorageQueryExecutor
+ * @description Execute a query to on-chain storage
+ */
+export declare class StorageQueryExecutor<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> extends Executor<ChainApi> {
+    doExecute(pallet: string, storage: string): GenericStorageQuery;
+    protected exposeStorageMapMethods(entry: QueryableStorage): Record<string, AsyncMethod>;
+    protected queryStorage(keys: StorageKey[], hash?: BlockHash): Promise<Record<StorageKey, Option<StorageData>>>;
+    protected subscribeStorage(keys: StorageKey[], callback: Callback<Array<StorageData | undefined>>): Promise<Unsub>;
+}