@dedot/api 0.0.1-alpha.32

package/cjs/client/DedotClient.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DedotClient = void 0;
+const codecs_1 = require("@dedot/codecs");
+const shape_1 = require("@dedot/shape");
+const utils_1 = require("@dedot/utils");
+const index_js_1 = require("../executor/index.js");
+const index_js_2 = require("../json-rpc/index.js");
+const proxychain_js_1 = require("../proxychain.js");
+const BaseSubstrateClient_js_1 = require("./BaseSubstrateClient.js");
+/**
+ * @name DedotClient
+ * @description New promised-based API Client for Polkadot & Substrate based on JSON-RPC V2
+ *
+ * __Unstable, use with caution.__
+ */
+class DedotClient extends BaseSubstrateClient_js_1.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 (0, BaseSubstrateClient_js_1.ensurePresence)(this._chainSpec);
+    }
+    get chainHead() {
+        return (0, BaseSubstrateClient_js_1.ensurePresence)(this._chainHead);
+    }
+    get txBroadcaster() {
+        this.chainHead; // Ensure chain head is initialized
+        (0, utils_1.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 index_js_2.Transaction(this, { rpcMethods });
+        if (await tx.supported())
+            return tx;
+        const txWatch = new index_js_2.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 index_js_2.ChainHead(this, { rpcMethods });
+        this._chainSpec = new index_js_2.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 = (0, utils_1.xxhashAsU8a)('System', 128);
+        const item = (0, utils_1.xxhashAsU8a)('BlockHash', 128);
+        const blockHeightAt0 = (0, utils_1.twox64Concat)(shape_1.u32.encode(0));
+        const key = (0, utils_1.u8aToHex)((0, utils_1.concatU8a)(pallet, item, blockHeightAt0));
+        const storageValue = await this.chainHead.storage([{ type: 'value', key }]);
+        const rawGenesisHash = storageValue.at(0)?.value;
+        (0, utils_1.assert)(rawGenesisHash, 'Genesis hash not found!');
+        // Here we assume that in most case the hash is stored as a H256
+        return codecs_1.$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(utils_1.noop);
+    };
+    cleanUp() {
+        super.cleanUp();
+        this._chainHead = undefined;
+        this._chainSpec = undefined;
+        this._txBroadcaster = undefined;
+        this.#apiAtCache = {};
+    }
+    get query() {
+        return (0, proxychain_js_1.newProxyChain)({
+            executor: new index_js_1.StorageQueryExecutorV2(this, this.chainHead),
+        });
+    }
+    get call() {
+        return this.callAt();
+    }
+    callAt(blockHash) {
+        return (0, proxychain_js_1.newProxyChain)({
+            executor: new index_js_1.RuntimeApiExecutorV2(this, this.chainHead, blockHash),
+        });
+    }
+    get tx() {
+        return (0, proxychain_js_1.newProxyChain)({ executor: new index_js_1.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);
+        (0, utils_1.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 codecs_1.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 = (0, proxychain_js_1.newProxyChain)({ executor: new index_js_1.ConstantExecutor(api) });
+        api.events = (0, proxychain_js_1.newProxyChain)({ executor: new index_js_1.EventExecutor(api) });
+        api.errors = (0, proxychain_js_1.newProxyChain)({ executor: new index_js_1.ErrorExecutor(api) });
+        api.query = (0, proxychain_js_1.newProxyChain)({ executor: new index_js_1.StorageQueryExecutorV2(api, this.chainHead) });
+        api.call = (0, proxychain_js_1.newProxyChain)({ executor: new index_js_1.RuntimeApiExecutorV2(api, this.chainHead) });
+        this.#apiAtCache[hash] = api;
+        return api;
+    }
+}
+exports.DedotClient = DedotClient;

package/cjs/client/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Dedot.js"), exports);
+__exportStar(require("./DedotClient.js"), exports);

package/cjs/executor/ConstantExecutor.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConstantExecutor = void 0;
+const utils_1 = require("@dedot/utils");
+const Executor_js_1 = require("./Executor.js");
+/**
+ * @name ConstantExecutor
+ *
+ * Find & decode the constant value from metadata
+ */
+class ConstantExecutor extends Executor_js_1.Executor {
+    doExecute(pallet, constantName) {
+        const targetPallet = this.getPallet(pallet);
+        const constantDef = targetPallet.constants.find((one) => (0, utils_1.stringCamelCase)(one.name) === constantName);
+        (0, utils_1.assert)(constantDef, new utils_1.UnknownApiError(`Constant ${constantName} not found in pallet ${pallet}`));
+        const $codec = this.registry.findCodec(constantDef.typeId);
+        return $codec.tryDecode(constantDef.value);
+    }
+}
+exports.ConstantExecutor = ConstantExecutor;

package/cjs/executor/ErrorExecutor.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorExecutor = void 0;
+const utils_1 = require("@dedot/utils");
+const Executor_js_1 = require("./Executor.js");
+/**
+ * @name ErrorExecutor
+ * @description Find pallet error information from metadata
+ */
+class ErrorExecutor extends Executor_js_1.Executor {
+    doExecute(pallet, errorName) {
+        const targetPallet = this.getPallet(pallet);
+        const errorTypeId = targetPallet.error;
+        (0, utils_1.assert)(errorTypeId, new utils_1.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 ((0, utils_1.isObject)(errorInfo) && errorInfo.tag === 'Module') {
+                    errorInfo = errorInfo.value;
+                }
+                if ((0, utils_1.isObject)(errorInfo) && (0, utils_1.isNumber)(errorInfo.index) && (0, utils_1.isHex)(errorInfo.error)) {
+                    return errorInfo.index === targetPallet.index && (0, utils_1.hexToU8a)(errorInfo.error)[0] === errorDef.index;
+                }
+                return false;
+            },
+        };
+    }
+    #getErrorDef(errorTypeId, errorName) {
+        const def = this.metadata.types[errorTypeId];
+        (0, utils_1.assert)(def, new utils_1.UnknownApiError(`Error def not found for id ${errorTypeId}`));
+        const { tag, value } = def.type;
+        (0, utils_1.assert)(tag === 'Enum', new utils_1.UnknownApiError(`Error type should be an enum, found: ${tag}`));
+        const errorDef = value.members.find(({ name }) => (0, utils_1.stringPascalCase)(name) === errorName);
+        (0, utils_1.assert)(errorDef, new utils_1.UnknownApiError(`Error def not found for ${errorName}`));
+        return {
+            ...errorDef,
+            fieldCodecs: errorDef.fields.map(({ typeId }) => this.registry.findCodec(typeId)),
+        };
+    }
+}
+exports.ErrorExecutor = ErrorExecutor;

package/cjs/executor/EventExecutor.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventExecutor = void 0;
+const utils_1 = require("@dedot/utils");
+const Executor_js_1 = require("./Executor.js");
+/**
+ * @name EventExecutor
+ * @description Find pallet event information from metadata
+ */
+class EventExecutor extends Executor_js_1.Executor {
+    doExecute(pallet, errorName) {
+        const targetPallet = this.getPallet(pallet);
+        const eventTypeId = targetPallet.event;
+        (0, utils_1.assert)(eventTypeId, new utils_1.UnknownApiError(`Not found event with id ${eventTypeId} in pallet ${pallet}`));
+        const eventDef = this.#getEventDef(eventTypeId, errorName);
+        const is = (event) => {
+            const palletCheck = (0, utils_1.stringCamelCase)(event.pallet) === pallet;
+            if (typeof event.palletEvent === 'string') {
+                return palletCheck && (0, utils_1.stringPascalCase)(event.palletEvent) === errorName;
+            }
+            else if (typeof event.palletEvent === 'object') {
+                return palletCheck && (0, utils_1.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];
+        (0, utils_1.assert)(def, new utils_1.UnknownApiError(`Event def not found for id ${eventTypeId}`));
+        const { tag, value } = def.type;
+        (0, utils_1.assert)(tag === 'Enum', new utils_1.UnknownApiError(`Event type should be an enum, found: ${tag}`));
+        const eventDef = value.members.find(({ name }) => (0, utils_1.stringPascalCase)(name) === errorName);
+        (0, utils_1.assert)(eventDef, new utils_1.UnknownApiError(`Event def not found for ${errorName}`));
+        return {
+            ...eventDef,
+            fieldCodecs: eventDef.fields.map(({ typeId }) => this.registry.findCodec(typeId)),
+        };
+    }
+}
+exports.EventExecutor = EventExecutor;

package/cjs/executor/Executor.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Executor = void 0;
+const utils_1 = require("@dedot/utils");
+/**
+ * @name Executor
+ * @description Execution abstraction for a specific action
+ */
+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) => (0, utils_1.stringCamelCase)(p.name) === name);
+        (0, utils_1.assert)(targetPallet, new utils_1.UnknownApiError(`Pallet not found: ${name}`));
+        return targetPallet;
+    }
+    execute(...paths) {
+        try {
+            return this.doExecute(...paths);
+        }
+        catch (e) {
+            if (!this.api.options?.throwOnUnknownApi && e instanceof utils_1.UnknownApiError) {
+                return undefined;
+            }
+            throw e;
+        }
+    }
+}
+exports.Executor = Executor;

package/cjs/executor/RuntimeApiExecutor.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuntimeApiExecutor = exports.FallbackRuntimeApiSpecs = exports.FallbackRuntimeApis = void 0;
+const runtime_specs_1 = require("@dedot/runtime-specs");
+const utils_1 = require("@dedot/utils");
+const Executor_js_1 = require("./Executor.js");
+exports.FallbackRuntimeApis = { '0x37e397fc7c91f5e4': 2 };
+exports.FallbackRuntimeApiSpecs = { Metadata: runtime_specs_1.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.
+ */
+class RuntimeApiExecutor extends Executor_js_1.Executor {
+    doExecute(runtimeApi, method) {
+        const runtimeApiName = (0, utils_1.stringPascalCase)(runtimeApi);
+        const methodName = (0, utils_1.stringSnakeCase)(method);
+        const callName = this.#callName({ runtimeApiName, methodName });
+        const callSpec = this.#findRuntimeApiMethodSpec(runtimeApiName, methodName);
+        (0, utils_1.assert)(callSpec, new utils_1.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 = (0, utils_1.u8aToHex)((0, utils_1.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 ((0, utils_1.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 (!(0, utils_1.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(exports.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 = (0, utils_1.calcRuntimeApiHash)(runtimeApi);
+        try {
+            return this.api.runtimeVersion.apis[runtimeApiHash] || exports.FallbackRuntimeApis[runtimeApiHash];
+        }
+        catch {
+            return exports.FallbackRuntimeApis[runtimeApiHash];
+        }
+    }
+    #findDefinedSpec(specs, runtimeApi, method, runtimeApiVersion) {
+        if (!specs)
+            return undefined;
+        const methodSpecs = (0, runtime_specs_1.toRuntimeApiSpecs)(specs).map(runtime_specs_1.toRuntimeApiMethods).flat();
+        return methodSpecs.find(({ runtimeApiName, methodName, version }) => `${(0, utils_1.stringPascalCase)(runtimeApiName)}_${(0, utils_1.stringSnakeCase)(methodName)}` === `${runtimeApi}_${method}` &&
+            runtimeApiVersion === version);
+    }
+}
+exports.RuntimeApiExecutor = RuntimeApiExecutor;

package/cjs/executor/StorageQueryExecutor.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageQueryExecutor = void 0;
+const utils_1 = require("@dedot/utils");
+const QueryableStorage_js_1 = require("../storage/QueryableStorage.js");
+const Executor_js_1 = require("./Executor.js");
+const DEFAULT_KEYS_PAGE_SIZE = 1000;
+const DEFAULT_ENTRIES_PAGE_SIZE = 250;
+/**
+ * @name StorageQueryExecutor
+ * @description Execute a query to on-chain storage
+ */
+class StorageQueryExecutor extends Executor_js_1.Executor {
+    doExecute(pallet, storage) {
+        const entry = new QueryableStorage_js_1.QueryableStorage(this.registry, pallet, storage);
+        const extractArgs = (args) => {
+            const inArgs = args.slice();
+            const lastArg = args.at(-1);
+            const callback = (0, utils_1.isFunction)(lastArg) ? inArgs.pop() : undefined;
+            return [inArgs, callback];
+        };
+        const getStorageKey = (...args) => {
+            const [inArgs] = extractArgs(args);
+            return entry.encodeKey(inArgs.at(0));
+        };
+        const getStorage = async (keys) => {
+            const results = await this.queryStorage(keys, this.atBlockHash);
+            return keys.reduce((o, key) => {
+                o[key] = entry.decodeValue(results[key]);
+                return o;
+            }, {});
+        };
+        const queryFn = async (...args) => {
+            const [inArgs, callback] = extractArgs(args);
+            const encodedKey = entry.encodeKey(inArgs.at(0));
+            // if a callback is passed, make a storage subscription and return an unsub function
+            if (callback) {
+                return await this.subscribeStorage([encodedKey], (changes) => {
+                    if (changes.length === 0)
+                        return;
+                    callback(entry.decodeValue(changes[0]));
+                });
+            }
+            else {
+                const results = await getStorage([encodedKey]);
+                return results[encodedKey];
+            }
+        };
+        queryFn.rawKey = getStorageKey;
+        queryFn.meta = {
+            pallet: entry.pallet.name,
+            palletIndex: entry.pallet.index,
+            ...entry.storageEntry,
+        };
+        const isMap = entry.storageEntry.type.tag === 'Map';
+        if (isMap) {
+            const queryMultiFn = async (...args) => {
+                const [inArgs, callback] = extractArgs(args);
+                const multiArgs = inArgs.at(0);
+                (0, utils_1.assert)(Array.isArray(multiArgs), 'First param for multi query should be an array');
+                const encodedKeys = multiArgs.map((arg) => entry.encodeKey(arg));
+                // if a callback is passed, make a storage subscription and return an unsub function
+                if (callback) {
+                    return await this.subscribeStorage(encodedKeys, (changes) => {
+                        callback(changes.map((change) => entry.decodeValue(change)));
+                    });
+                }
+                else {
+                    const result = await getStorage(encodedKeys);
+                    return encodedKeys.map((key) => result[key]);
+                }
+            };
+            // @ts-ignore
+            queryFn.multi = queryMultiFn;
+            Object.assign(queryFn, this.exposeStorageMapMethods(entry));
+        }
+        return queryFn;
+    }
+    exposeStorageMapMethods(entry) {
+        const rawKeys = async (pagination) => {
+            const pageSize = pagination?.pageSize || DEFAULT_KEYS_PAGE_SIZE;
+            const startKey = pagination?.startKey || entry.prefixKey;
+            return await this.api.rpc.state_getKeysPaged(entry.prefixKey, pageSize, startKey, this.atBlockHash);
+        };
+        const pagedKeys = async (pagination) => {
+            const storageKeys = await rawKeys({ pageSize: DEFAULT_KEYS_PAGE_SIZE, ...pagination });
+            return storageKeys.map((key) => entry.decodeKey(key));
+        };
+        const pagedEntries = async (pagination) => {
+            const storageKeys = await rawKeys({ pageSize: DEFAULT_ENTRIES_PAGE_SIZE, ...pagination });
+            const storageMap = await this.queryStorage(storageKeys, this.atBlockHash);
+            return storageKeys.map((key) => [entry.decodeKey(key), entry.decodeValue(storageMap[key])]);
+        };
+        return { pagedKeys, pagedEntries };
+    }
+    async queryStorage(keys, hash) {
+        const changeSets = await this.api.rpc.state_queryStorageAt(keys, hash);
+        return changeSets[0].changes.reduce((o, [key, value]) => {
+            o[key] = value ?? undefined;
+            return o;
+        }, {});
+    }
+    subscribeStorage(keys, callback) {
+        const lastChanges = {};
+        return this.api.rpc.state_subscribeStorage(keys, (changeSet) => {
+            changeSet.changes.forEach(([key, value]) => {
+                if (lastChanges[key] !== value) {
+                    lastChanges[key] = value ?? undefined;
+                }
+            });
+            return callback(keys.map((key) => lastChanges[key]));
+        });
+    }
+}
+exports.StorageQueryExecutor = StorageQueryExecutor;

package/cjs/executor/TxExecutor.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxExecutor = void 0;
+const utils_1 = require("@dedot/utils");
+const index_js_1 = require("../extrinsic/index.js");
+const Executor_js_1 = require("./Executor.js");
+/**
+ * @name TxExecutor
+ * @description Execute a transaction instruction, returns a submittable extrinsic
+ */
+class TxExecutor extends Executor_js_1.Executor {
+    doExecute(pallet, functionName) {
+        const targetPallet = this.getPallet(pallet);
+        (0, utils_1.assert)(targetPallet.calls, new utils_1.UnknownApiError(`Tx calls are not available for pallet ${targetPallet.name}`));
+        const txType = this.metadata.types[targetPallet.calls];
+        (0, utils_1.assert)(txType.type.tag === 'Enum', new utils_1.UnknownApiError('Tx type defs should be enum'));
+        const isFlatEnum = txType.type.value.members.every((m) => m.fields.length === 0);
+        const txCallDef = txType.type.value.members.find((m) => (0, utils_1.stringCamelCase)(m.name) === functionName);
+        (0, utils_1.assert)(txCallDef, new utils_1.UnknownApiError(`Tx call spec not found for ${pallet}.${functionName}`));
+        const txCallFn = (...args) => {
+            let call;
+            if (isFlatEnum) {
+                call = {
+                    pallet: (0, utils_1.stringPascalCase)(targetPallet.name),
+                    palletCall: (0, utils_1.stringPascalCase)(txCallDef.name),
+                };
+            }
+            else {
+                const callParams = txCallDef.fields.reduce((o, { name }, idx) => {
+                    o[(0, utils_1.stringCamelCase)(name)] = args[idx];
+                    return o;
+                }, {});
+                call = {
+                    pallet: (0, utils_1.stringPascalCase)(targetPallet.name),
+                    palletCall: {
+                        name: (0, utils_1.stringPascalCase)(txCallDef.name),
+                        params: callParams,
+                    },
+                };
+            }
+            return this.createExtrinsic(call);
+        };
+        txCallFn.meta = {
+            ...txCallDef,
+            fieldCodecs: txCallDef.fields.map(({ typeId }) => this.registry.findCodec(typeId)),
+            pallet: targetPallet.name,
+            palletIndex: targetPallet.index,
+        };
+        return txCallFn;
+    }
+    createExtrinsic(call) {
+        return new index_js_1.SubmittableExtrinsic(this.api, call);
+    }
+}
+exports.TxExecutor = TxExecutor;