@dedot/api 0.8.1 → 0.8.2-next.6cfafabd.24

package/cjs/client/BaseSubstrateClient.js

@@ -7,6 +7,7 @@ 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 index_js_3 = require("../storage/index.js");
 const SUPPORTED_METADATA_VERSIONS = [15, 14];
 const MetadataApiHash = (0, utils_1.calcRuntimeApiHash)('Metadata'); // 0x37e397fc7c91f5e4
 const MESSAGE = 'Make sure to call `.connect()` method first before using the API interfaces.';
@@ -110,7 +111,7 @@ class BaseSubstrateClient extends index_js_2.JsonRpcClient {
             try {
                 // Get all keys that start with RAW_META/
                 const allKeys = await this._localCache.keys();
-                const metadataKeys = allKeys.filter(k => k.startsWith('RAW_META/') && k !== key);
+                const metadataKeys = allKeys.filter((k) => k.startsWith('RAW_META/') && k !== key);
                 // Remove all other metadata entries
                 for (const metaKey of metadataKeys) {
                     await this._localCache.remove(metaKey);
@@ -308,5 +309,33 @@ class BaseSubstrateClient extends index_js_2.JsonRpcClient {
     setSigner(signer) {
         this._options.signer = signer;
     }
+    async queryMulti(queries, callback) {
+        // Extract keys from queries
+        const keys = queries.map((q) => q.fn.rawKey(...(q.args || [])));
+        const decodeValue = (query, rawValue) => {
+            // Get the QueryableStorage instance from the query function
+            const entry = new index_js_3.QueryableStorage(this.registry, query.meta.pallet, query.meta.name);
+            // Decode the value
+            return entry.decodeValue(rawValue);
+        };
+        // Create service directly when needed
+        let service;
+        if (this.rpcVersion === 'v2') {
+            service = new index_js_3.NewStorageQuery(this);
+        }
+        else {
+            service = new index_js_3.LegacyStorageQuery(this);
+        }
+        // If a callback is provided, set up a subscription
+        if (callback) {
+            return service.subscribe(keys, (results) => {
+                callback(queries.map((q, i) => decodeValue(q.fn, results[keys[i]])));
+            });
+        }
+        else {
+            const results = await service.query(keys);
+            return queries.map((q, i) => decodeValue(q.fn, results[keys[i]]));
+        }
+    }
 }
 exports.BaseSubstrateClient = BaseSubstrateClient;

package/cjs/executor/StorageQueryExecutor.js

@@ -2,7 +2,7 @@
 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 index_js_1 = require("../storage/index.js");
 const Executor_js_1 = require("./Executor.js");
 const DEFAULT_KEYS_PAGE_SIZE = 1000;
 const DEFAULT_ENTRIES_PAGE_SIZE = 250;
@@ -12,7 +12,7 @@ const DEFAULT_ENTRIES_PAGE_SIZE = 250;
  */
 class StorageQueryExecutor extends Executor_js_1.Executor {
     doExecute(pallet, storage) {
-        const entry = new QueryableStorage_js_1.QueryableStorage(this.registry, pallet, storage);
+        const entry = new index_js_1.QueryableStorage(this.registry, pallet, storage);
         const extractArgs = (args) => {
             const inArgs = args.slice();
             const lastArg = args.at(-1);
@@ -101,22 +101,15 @@ class StorageQueryExecutor extends Executor_js_1.Executor {
         };
         return { pagedKeys, pagedEntries };
     }
+    getStorageQuery() {
+        return new index_js_1.LegacyStorageQuery(this.client);
+    }
     async queryStorage(keys, hash) {
-        const changeSets = await this.client.rpc.state_queryStorageAt(keys, hash);
-        return changeSets[0].changes.reduce((o, [key, value]) => {
-            o[key] = value ?? undefined;
-            return o;
-        }, {});
+        return this.getStorageQuery().query(keys, hash);
     }
     subscribeStorage(keys, callback) {
-        const lastChanges = {};
-        return this.client.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]));
+        return this.getStorageQuery().subscribe(keys, (results) => {
+            callback(keys.map((key) => results[key]));
         });
     }
 }

package/cjs/executor/v2/StorageQueryExecutorV2.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StorageQueryExecutorV2 = void 0;
 const utils_1 = require("@dedot/utils");
+const index_js_1 = require("../../storage/index.js");
 const StorageQueryExecutor_js_1 = require("../StorageQueryExecutor.js");
 /**
  * @name StorageQueryExecutorV2
@@ -31,39 +32,12 @@ class StorageQueryExecutorV2 extends StorageQueryExecutor_js_1.StorageQueryExecu
         };
         return { entries };
     }
-    async queryStorage(keys, at) {
-        const results = await this.chainHead.storage(keys.map((key) => ({ type: 'value', key })), undefined, at);
-        return results.reduce((o, r) => {
-            o[r.key] = (r.value ?? undefined);
-            return o;
-        }, {});
-    }
-    async subscribeStorage(keys, callback) {
-        let best = await this.chainHead.bestBlock();
-        let eventToListen = 'bestBlock';
-        // TODO subscribe to finalized data source
-        // initialHash = this.chainHead.finalizedHash;
-        // eventToListen = 'finalizedBlock';
-        const latestChanges = new Map();
-        const pull = async ({ hash }) => {
-            const results = await this.queryStorage(keys, hash);
-            let changed = false;
-            keys.forEach((key) => {
-                const newValue = results[key];
-                if (latestChanges.size > 0 && latestChanges.get(key) === newValue)
-                    return;
-                changed = true;
-                latestChanges.set(key, newValue);
-            });
-            if (!changed)
-                return;
-            callback(keys.map((key) => latestChanges.get(key)));
-        };
-        await pull(best);
-        const unsub = this.chainHead.on(eventToListen, pull);
-        return async () => {
-            unsub();
-        };
+    getStorageQuery() {
+        // @ts-ignore little trick to make querying data client.at instance works here,
+        // TODO need to rethink about this
+        if (!this.client['chainHead'])
+            this.client['chainHead'] = this.chainHead;
+        return new index_js_1.NewStorageQuery(this.client);
     }
 }
 exports.StorageQueryExecutorV2 = StorageQueryExecutorV2;

package/cjs/extrinsic/extensions/ExtraSignedExtension.js

@@ -27,6 +27,7 @@ exports.ExtraSignedExtension = void 0;
 const $ = __importStar(require("@dedot/shape"));
 const utils_1 = require("@dedot/utils");
 const SignedExtension_js_1 = require("./SignedExtension.js");
+const FallbackSignedExtension_js_1 = require("./FallbackSignedExtension.js");
 const index_js_1 = require("./known/index.js");
 class ExtraSignedExtension extends SignedExtension_js_1.SignedExtension {
     #signedExtensions;
@@ -60,13 +61,31 @@ class ExtraSignedExtension extends SignedExtension_js_1.SignedExtension {
             const { signedExtensions: userSignedExtensions = {} } = this.client.options;
             const Extension = userSignedExtensions[extDef.ident] ||
                 index_js_1.knownSignedExtensions[extDef.ident];
-            (0, utils_1.assert)(Extension, `SignedExtension for ${extDef.ident} not found`);
-            return new Extension(this.client, {
-                ...(0, utils_1.ensurePresence)(this.options),
-                def: extDef,
-            });
+            if (Extension) {
+                return new Extension(this.client, {
+                    ...(0, utils_1.ensurePresence)(this.options),
+                    def: extDef,
+                });
+            }
+            else if (this.isRequireNoExternalInputs(extDef)) {
+                return new FallbackSignedExtension_js_1.FallbackSignedExtension(this.client, {
+                    ...(0, utils_1.ensurePresence)(this.options),
+                    def: extDef,
+                }, extDef.ident);
+            }
+            // For extensions that require input but aren't implemented, throw an error
+            throw new Error(`SignedExtension for ${extDef.ident} requires input but is not implemented`);
         });
     }
+    /**
+     * Check if the extension requires no external inputs (e.g: struct or tuple with empty types like `()` or `[]`)
+     * @param extDef - The definition of the signed extension
+     * @returns boolean
+     */
+    isRequireNoExternalInputs(extDef) {
+        return ((0, FallbackSignedExtension_js_1.isEmptyStructOrTuple)(this.registry, extDef.typeId) &&
+            (0, FallbackSignedExtension_js_1.isEmptyStructOrTuple)(this.registry, extDef.additionalSigned));
+    }
     toPayload(call = '0x') {
         const signedExtensions = this.#signedExtensions.map((se) => se.identifier);
         const { version } = this.registry.metadata.extrinsic;

package/cjs/extrinsic/extensions/FallbackSignedExtension.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmptyStructOrTuple = exports.FallbackSignedExtension = void 0;
+const SignedExtension_js_1 = require("./SignedExtension.js");
+/**
+ * A fallback signed extension that can be used for extensions
+ * that don't require external input.
+ *
+ * This extension is automatically used for:
+ * - Unknown extensions with empty struct or tuple types
+ * - Known extensions that don't require input, such as:
+ *   - CheckNonZeroSender: Ensures sender is not the zero address
+ *   - CheckWeight: Block resource (weight) limit check
+ *   - PrevalidateAttests: Validates `attest` calls prior to execution
+ *   - StorageWeightReclaim: Storage weight reclaim mechanism
+ *
+ * These extensions have empty struct or tuple types and don't need explicit implementation.
+ */
+class FallbackSignedExtension extends SignedExtension_js_1.SignedExtension {
+    extensionIdent;
+    constructor(client, options, extensionIdent) {
+        super(client, options);
+        this.extensionIdent = extensionIdent;
+    }
+    get identifier() {
+        return this.extensionIdent;
+    }
+    async init() {
+        // Initialize with empty data and additionalSigned
+        this.data = {};
+        this.additionalSigned = [];
+    }
+    toPayload() {
+        return {}; // No payload contribution
+    }
+}
+exports.FallbackSignedExtension = FallbackSignedExtension;
+/**
+ * Checks if a type is an empty struct or tuple (doesn't require external input).
+ *
+ * @param registry The portable registry
+ * @param typeId The type ID to check
+ * @returns True if the type is an empty struct or tuple, false otherwise
+ */
+function isEmptyStructOrTuple(registry, typeId) {
+    try {
+        const type = registry.findType(typeId);
+        // Check if it's an empty struct
+        if (type.typeDef.type === 'Struct' && type.typeDef.value.fields.length === 0) {
+            return true;
+        }
+        // Check if it's an empty tuple
+        if (type.typeDef.type === 'Tuple' && type.typeDef.value.fields.length === 0) {
+            return true;
+        }
+    }
+    catch (error) {
+        // Ignore errors
+    }
+    // All other cases (including errors) require input
+    return false;
+}
+exports.isEmptyStructOrTuple = isEmptyStructOrTuple;

package/cjs/extrinsic/extensions/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./SignedExtension.js"), exports);
 __exportStar(require("./known/index.js"), exports);
 __exportStar(require("./ExtraSignedExtension.js"), exports);
+__exportStar(require("./FallbackSignedExtension.js"), exports);

package/cjs/extrinsic/extensions/known/index.js

@@ -1,4 +1,15 @@
 "use strict";
+/**
+ * Known signed extensions that require external input.
+ *
+ * Note: Extensions that don't require external input are automatically handled by FallbackSignedExtension:
+ * - CheckNonZeroSender
+ * - CheckWeight
+ * - PrevalidateAttests
+ * - StorageWeightReclaim
+ *
+ * These extensions have empty struct or tuple types and don't need explicit implementation.
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.knownSignedExtensions = void 0;
 const ChargeAssetTxPayment_js_1 = require("./ChargeAssetTxPayment.js");
@@ -6,24 +17,16 @@ const ChargeTransactionPayment_js_1 = require("./ChargeTransactionPayment.js");
 const CheckGenesis_js_1 = require("./CheckGenesis.js");
 const CheckMetadataHash_js_1 = require("./CheckMetadataHash.js");
 const CheckMortality_js_1 = require("./CheckMortality.js");
-const CheckNonZeroSender_js_1 = require("./CheckNonZeroSender.js");
 const CheckNonce_js_1 = require("./CheckNonce.js");
 const CheckSpecVersion_js_1 = require("./CheckSpecVersion.js");
 const CheckTxVersion_js_1 = require("./CheckTxVersion.js");
-const CheckWeight_js_1 = require("./CheckWeight.js");
-const PrevalidateAttests_js_1 = require("./PrevalidateAttests.js");
-const StorageWeightReclaim_js_1 = require("./StorageWeightReclaim.js");
 exports.knownSignedExtensions = {
-    CheckNonZeroSender: CheckNonZeroSender_js_1.CheckNonZeroSender,
     CheckSpecVersion: CheckSpecVersion_js_1.CheckSpecVersion,
     CheckTxVersion: CheckTxVersion_js_1.CheckTxVersion,
     CheckGenesis: CheckGenesis_js_1.CheckGenesis,
     CheckMortality: CheckMortality_js_1.CheckMortality,
     CheckNonce: CheckNonce_js_1.CheckNonce,
-    CheckWeight: CheckWeight_js_1.CheckWeight,
     ChargeTransactionPayment: ChargeTransactionPayment_js_1.ChargeTransactionPayment,
-    PrevalidateAttests: PrevalidateAttests_js_1.PrevalidateAttests,
     ChargeAssetTxPayment: ChargeAssetTxPayment_js_1.ChargeAssetTxPayment,
     CheckMetadataHash: CheckMetadataHash_js_1.CheckMetadataHash,
-    StorageWeightReclaim: StorageWeightReclaim_js_1.StorageWeightReclaim,
 };

package/cjs/storage/BaseStorageQuery.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseStorageQuery = void 0;
+/**
+ * @name BaseStorageQuery
+ * @description
+ * An abstract service that provides functionality for querying and subscribing to
+ * multiple storage items. This service is designed to be extended by version-specific
+ * implementations that handle the details of interacting with different JSON-RPC APIs.
+ *
+ * The service provides a simple interface for:
+ * - Querying multiple storage keys in a single call
+ * - Subscribing to changes in multiple storage keys
+ *
+ * This abstraction eliminates code duplication between different client implementations
+ * and provides a consistent interface for storage operations.
+ */
+class BaseStorageQuery {
+    client;
+    /**
+     * @param client - The substrate client instance
+     */
+    constructor(client) {
+        this.client = client;
+    }
+}
+exports.BaseStorageQuery = BaseStorageQuery;

package/cjs/storage/LegacyStorageQuery.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LegacyStorageQuery = void 0;
+const BaseStorageQuery_js_1 = require("./BaseStorageQuery.js");
+/**
+ * @name LegacyStorageQuery
+ * @description
+ * Implementation of BaseStorageQuery for the legacy JSON-RPC API (v1).
+ * This service handles storage queries using the state_queryStorageAt and
+ * state_subscribeStorage RPC methods.
+ *
+ * It provides:
+ * - One-time queries using state_queryStorageAt
+ * - Subscriptions using state_subscribeStorage
+ * - Efficient change tracking for subscriptions
+ */
+class LegacyStorageQuery extends BaseStorageQuery_js_1.BaseStorageQuery {
+    /**
+     * Query multiple storage items in a single call using state_queryStorageAt
+     *
+     * @param keys - Array of storage keys to query
+     * @param at - Optional block hash to query at (defaults to current/best block)
+     * @returns Promise resolving to a record mapping storage keys to their values
+     */
+    async query(keys, at) {
+        // Query storage at the specified block or current block
+        const changeSets = at
+            ? await this.client.rpc.state_queryStorageAt(keys, at)
+            : await this.client.rpc.state_queryStorageAt(keys);
+        // Create a map of key -> value for easy lookup
+        const results = {};
+        // Initialize all keys with undefined
+        keys.forEach(key => results[key] = undefined);
+        // Update with actual values from the response
+        if (changeSets && changeSets.length > 0) {
+            changeSets[0].changes.forEach(([key, value]) => {
+                results[key] = value ?? undefined;
+            });
+        }
+        return results;
+    }
+    /**
+     * Subscribe to multiple storage items using state_subscribeStorage
+     *
+     * @param keys - Array of storage keys to subscribe to
+     * @param callback - Function to call when storage values change
+     * @returns Promise resolving to an unsubscribe function
+     */
+    async subscribe(keys, callback) {
+        // Track the latest changes for each key
+        const lastChanges = {};
+        // Initialize all keys with undefined
+        keys.forEach(key => lastChanges[key] = undefined);
+        // Subscribe to storage changes
+        return this.client.rpc.state_subscribeStorage(keys, (changeSet) => {
+            // Update the latest changes
+            changeSet.changes.forEach(([key, value]) => {
+                if (lastChanges[key] !== value) {
+                    lastChanges[key] = value ?? undefined;
+                }
+            });
+            // Call the callback with the updated map
+            callback({ ...lastChanges });
+        });
+    }
+}
+exports.LegacyStorageQuery = LegacyStorageQuery;

package/cjs/storage/NewStorageQuery.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NewStorageQuery = void 0;
+const BaseStorageQuery_js_1 = require("./BaseStorageQuery.js");
+/**
+ * @name NewStorageQuery
+ * @description
+ * Implementation of BaseStorageQuery for the new JSON-RPC API (v2).
+ * This service handles storage queries using the chainHead_storage RPC method
+ * and chainHead events for subscriptions.
+ *
+ * It provides:
+ * - One-time queries using chainHead_storage
+ * - Subscriptions using chainHead 'bestBlock' events
+ * - Efficient change detection for subscriptions
+ */
+class NewStorageQuery extends BaseStorageQuery_js_1.BaseStorageQuery {
+    /**
+     * Query multiple storage items in a single call using chainHead_storage
+     *
+     * @param keys - Array of storage keys to query
+     * @param at - Optional block hash to query at (defaults to best block)
+     * @returns Promise resolving to a record mapping storage keys to their values
+     */
+    async query(keys, at) {
+        // Query storage using ChainHead API
+        const storageQueries = keys.map(key => ({ type: 'value', key }));
+        // Use the provided block hash or skip it in tests
+        const rawResults = at
+            ? await this.client.chainHead.storage(storageQueries, undefined, at)
+            : await this.client.chainHead.storage(storageQueries);
+        // Create a map of key -> value for easy lookup
+        const results = {};
+        // Initialize all keys with undefined
+        keys.forEach(key => results[key] = undefined);
+        // Update with actual values from the response
+        rawResults.forEach((result) => {
+            results[result.key] = result.value ?? undefined;
+        });
+        return results;
+    }
+    /**
+     * Subscribe to multiple storage items using chainHead 'bestBlock' events
+     *
+     * @param keys - Array of storage keys to subscribe to
+     * @param callback - Function to call when storage values change
+     * @returns Promise resolving to an unsubscribe function
+     */
+    async subscribe(keys, callback) {
+        // Get the best block
+        const best = await this.client.chainHead.bestBlock();
+        // Track the latest changes for each key
+        const latestChanges = {};
+        // Function to pull storage values and call the callback if there are changes
+        const pull = async ({ hash }) => {
+            // Query storage using ChainHead API
+            const storageQueries = keys.map(key => ({ type: 'value', key }));
+            const rawResults = await this.client.chainHead.storage(storageQueries, undefined, hash);
+            let changed = false;
+            // Create a map for easy lookup
+            const results = {};
+            rawResults.forEach((result) => {
+                results[result.key] = result.value ?? undefined;
+            });
+            keys.forEach((key) => {
+                const newValue = results[key];
+                if (Object.keys(latestChanges).length > 0 && latestChanges[key] === newValue)
+                    return;
+                changed = true;
+                latestChanges[key] = newValue;
+            });
+            if (!changed)
+                return;
+            callback({ ...latestChanges });
+        };
+        // Initial pull
+        await pull(best);
+        // Subscribe to best block events
+        const unsub = this.client.chainHead.on('bestBlock', pull);
+        return async () => {
+            unsub();
+        };
+    }
+}
+exports.NewStorageQuery = NewStorageQuery;

package/cjs/storage/index.js

@@ -15,3 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./QueryableStorage.js"), exports);
+__exportStar(require("./BaseStorageQuery.js"), exports);
+__exportStar(require("./LegacyStorageQuery.js"), exports);
+__exportStar(require("./NewStorageQuery.js"), exports);

package/client/BaseSubstrateClient.d.ts

@@ -1,7 +1,7 @@
 import { BlockHash, Hash, Metadata, PortableRegistry, RuntimeVersion } from '@dedot/codecs';
 import type { JsonRpcProvider } from '@dedot/providers';
 import { type IStorage } from '@dedot/storage';
-import { GenericSubstrateApi, InjectedSigner, RpcVersion, VersionedGenericSubstrateApi } from '@dedot/types';
+import { Callback, GenericStorageQuery, GenericSubstrateApi, InjectedSigner, Query, QueryFnResult, RpcVersion, Unsub, VersionedGenericSubstrateApi } from '@dedot/types';
 import { Deferred } from '@dedot/utils';
 import type { SubstrateApi } from '../chaintypes/index.js';
 import { JsonRpcClient } from '../json-rpc/index.js';
@@ -73,4 +73,35 @@ export declare abstract class BaseSubstrateClient<Rv extends RpcVersion, ChainAp
     get tx(): ChainApi[Rv]['tx'];
     at<ChainApiAt extends GenericSubstrateApi = ChainApi[Rv]>(hash: BlockHash): Promise<ISubstrateClientAt<ChainApiAt>>;
     setSigner(signer?: InjectedSigner): void;
+    /**
+     * Query multiple storage items in a single call
+     *
+     * This method allows you to query multiple storage items in a single call or set up a subscription
+     * to multiple storage items. It provides type safety for both the query functions and their results.
+     *
+     * @example
+     * // One-time query with type-safe results
+     * const [balance, blockNumber] = await client.queryMulti([
+     *   { fn: client.query.system.account, args: [ALICE] },
+     *   { fn: client.query.system.number, args: [] }
+     * ]);
+     * // balance will be typed as AccountInfo
+     * // blockNumber will be typed as number
+     *
+     *
+     * @template Fns Array of storage query functions
+     * @param queries - Array of query specifications, each with a function and optional arguments
+     * @param callback - Optional callback for subscription-based queries
+     * @returns For one-time queries: Array of decoded values with proper types; For subscriptions: Unsubscribe function
+     */
+    queryMulti<Fns extends GenericStorageQuery[]>(queries: {
+        [K in keyof Fns]: Query<Fns[K]>;
+    }): Promise<{
+        [K in keyof Fns]: QueryFnResult<Fns[K]>;
+    }>;
+    queryMulti<Fns extends GenericStorageQuery[]>(queries: {
+        [K in keyof Fns]: Query<Fns[K]>;
+    }, callback: Callback<{
+        [K in keyof Fns]: QueryFnResult<Fns[K]>;
+    }>): Promise<Unsub>;
 }

package/client/BaseSubstrateClient.js

@@ -4,6 +4,7 @@ import { calcRuntimeApiHash, deferred, ensurePresence as _ensurePresence, u8aToH
 import { ConstantExecutor, ErrorExecutor, EventExecutor } from '../executor/index.js';
 import { isJsonRpcProvider, JsonRpcClient } from '../json-rpc/index.js';
 import { newProxyChain } from '../proxychain.js';
+import { LegacyStorageQuery, NewStorageQuery, QueryableStorage } from '../storage/index.js';
 const SUPPORTED_METADATA_VERSIONS = [15, 14];
 const MetadataApiHash = calcRuntimeApiHash('Metadata'); // 0x37e397fc7c91f5e4
 const MESSAGE = 'Make sure to call `.connect()` method first before using the API interfaces.';
@@ -106,7 +107,7 @@ export class BaseSubstrateClient extends JsonRpcClient {
             try {
                 // Get all keys that start with RAW_META/
                 const allKeys = await this._localCache.keys();
-                const metadataKeys = allKeys.filter(k => k.startsWith('RAW_META/') && k !== key);
+                const metadataKeys = allKeys.filter((k) => k.startsWith('RAW_META/') && k !== key);
                 // Remove all other metadata entries
                 for (const metaKey of metadataKeys) {
                     await this._localCache.remove(metaKey);
@@ -304,4 +305,32 @@ export class BaseSubstrateClient extends JsonRpcClient {
     setSigner(signer) {
         this._options.signer = signer;
     }
+    async queryMulti(queries, callback) {
+        // Extract keys from queries
+        const keys = queries.map((q) => q.fn.rawKey(...(q.args || [])));
+        const decodeValue = (query, rawValue) => {
+            // Get the QueryableStorage instance from the query function
+            const entry = new QueryableStorage(this.registry, query.meta.pallet, query.meta.name);
+            // Decode the value
+            return entry.decodeValue(rawValue);
+        };
+        // Create service directly when needed
+        let service;
+        if (this.rpcVersion === 'v2') {
+            service = new NewStorageQuery(this);
+        }
+        else {
+            service = new LegacyStorageQuery(this);
+        }
+        // If a callback is provided, set up a subscription
+        if (callback) {
+            return service.subscribe(keys, (results) => {
+                callback(queries.map((q, i) => decodeValue(q.fn, results[keys[i]])));
+            });
+        }
+        else {
+            const results = await service.query(keys);
+            return queries.map((q, i) => decodeValue(q.fn, results[keys[i]]));
+        }
+    }
 }

package/client/DedotClient.js

@@ -1,7 +1,7 @@
 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 { 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';

package/executor/StorageQueryExecutor.d.ts

@@ -1,6 +1,6 @@
 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 type { AsyncMethod, Callback, GenericStorageQuery, GenericSubstrateApi, RpcVersion, Unsub } from '@dedot/types';
+import { type BaseStorageQuery, QueryableStorage } from '../storage/index.js';
 import { Executor } from './Executor.js';
 /**
  * @name StorageQueryExecutor
@@ -9,6 +9,7 @@ import { Executor } from './Executor.js';
 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 getStorageQuery(): BaseStorageQuery<RpcVersion>;
     protected queryStorage(keys: StorageKey[], hash?: BlockHash): Promise<Record<StorageKey, Option<StorageData>>>;
     protected subscribeStorage(keys: StorageKey[], callback: Callback<Array<StorageData | undefined>>): Promise<Unsub>;
 }

package/executor/StorageQueryExecutor.js

@@ -1,5 +1,5 @@
 import { assert, isFunction, isObject } from '@dedot/utils';
-import { QueryableStorage } from '../storage/QueryableStorage.js';
+import { LegacyStorageQuery, QueryableStorage } from '../storage/index.js';
 import { Executor } from './Executor.js';
 const DEFAULT_KEYS_PAGE_SIZE = 1000;
 const DEFAULT_ENTRIES_PAGE_SIZE = 250;
@@ -98,22 +98,15 @@ export class StorageQueryExecutor extends Executor {
         };
         return { pagedKeys, pagedEntries };
     }
+    getStorageQuery() {
+        return new LegacyStorageQuery(this.client);
+    }
     async queryStorage(keys, hash) {
-        const changeSets = await this.client.rpc.state_queryStorageAt(keys, hash);
-        return changeSets[0].changes.reduce((o, [key, value]) => {
-            o[key] = value ?? undefined;
-            return o;
-        }, {});
+        return this.getStorageQuery().query(keys, hash);
     }
     subscribeStorage(keys, callback) {
-        const lastChanges = {};
-        return this.client.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]));
+        return this.getStorageQuery().subscribe(keys, (results) => {
+            callback(keys.map((key) => results[key]));
         });
     }
 }