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

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.';
@@ -83,13 +84,44 @@ export class BaseSubstrateClient extends JsonRpcClient {
             }
         }
         if (shouldUpdateCache && this._localCache) {
-            await this._localCache.set(metadataKey, u8aToHex($Metadata.tryEncode(metadata)));
+            const encodedMetadata = u8aToHex($Metadata.tryEncode(metadata));
+            await this.safeSetMetadataToCache(metadataKey, encodedMetadata);
         }
         if (!metadata) {
             throw new Error('Cannot load metadata');
         }
         this.setMetadata(metadata);
     }
+    /**
+     * Safely set metadata to cache with fallback cleanup if storage limit is exceeded
+     */
+    async safeSetMetadataToCache(key, value) {
+        if (!this._localCache)
+            return;
+        try {
+            // First attempt to set the metadata
+            await this._localCache.set(key, value);
+        }
+        catch (error) {
+            console.warn('Failed to store metadata in cache, attempting to clean up old entries:', error);
+            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);
+                // Remove all other metadata entries
+                for (const metaKey of metadataKeys) {
+                    await this._localCache.remove(metaKey);
+                }
+                console.info(`Cleaned up ${metadataKeys.length} old metadata entries, trying again`);
+                // Try again after cleanup
+                await this._localCache.set(key, value);
+            }
+            catch (cleanupError) {
+                // If it still fails after cleanup, log the error but continue
+                console.error('Failed to store metadata even after cleanup:', cleanupError);
+            }
+        }
+    }
     setMetadata(metadata) {
         this._metadata = metadata;
         this._registry = new PortableRegistry(metadata.latest, this.options.hasher);
@@ -273,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]));
         });
     }
 }

package/executor/v2/StorageQueryExecutorV2.d.ts

@@ -1,8 +1,7 @@
-import { BlockHash, Option, StorageData, StorageKey } from '@dedot/codecs';
-import type { AsyncMethod, Callback, GenericSubstrateApi } from '@dedot/types';
-import { HexString } from '@dedot/utils';
+import { BlockHash } from '@dedot/codecs';
+import type { AsyncMethod, GenericSubstrateApi, RpcVersion } from '@dedot/types';
 import { ChainHead } from '../../json-rpc/index.js';
-import { QueryableStorage } from '../../storage/QueryableStorage.js';
+import { type BaseStorageQuery, QueryableStorage } from '../../storage/index.js';
 import { ISubstrateClientAt } from '../../types.js';
 import { StorageQueryExecutor } from '../StorageQueryExecutor.js';
 /**
@@ -12,6 +11,5 @@ export declare class StorageQueryExecutorV2<ChainApi extends GenericSubstrateApi
     chainHead: ChainHead;
     constructor(client: ISubstrateClientAt<ChainApi>, chainHead: ChainHead, atBlockHash?: BlockHash);
     protected exposeStorageMapMethods(entry: QueryableStorage): Record<string, AsyncMethod>;
-    protected queryStorage(keys: StorageKey[], at?: BlockHash): Promise<Record<StorageKey, Option<StorageData>>>;
-    protected subscribeStorage(keys: HexString[], callback: Callback<Array<StorageData | undefined>>): Promise<() => Promise<void>>;
+    protected getStorageQuery(): BaseStorageQuery<RpcVersion>;
 }

package/executor/v2/StorageQueryExecutorV2.js

@@ -1,4 +1,5 @@
 import { assert } from '@dedot/utils';
+import { NewStorageQuery } from '../../storage/index.js';
 import { StorageQueryExecutor } from '../StorageQueryExecutor.js';
 /**
  * @name StorageQueryExecutorV2
@@ -28,38 +29,11 @@ export class StorageQueryExecutorV2 extends StorageQueryExecutor {
         };
         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 NewStorageQuery(this.client);
     }
 }

package/extrinsic/extensions/ExtraSignedExtension.d.ts

@@ -9,6 +9,12 @@ export declare class ExtraSignedExtension extends SignedExtension<any[], any[]>
     get $Data(): $.AnyShape;
     get $AdditionalSigned(): $.AnyShape;
     get $Payload(): $.AnyShape;
+    /**
+     * 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
+     */
+    private isRequireNoExternalInputs;
     toPayload(call?: HexString): SignerPayloadJSON;
     toRawPayload(call?: HexString): SignerPayloadRaw;
 }

package/extrinsic/extensions/ExtraSignedExtension.js

@@ -1,6 +1,7 @@
 import * as $ from '@dedot/shape';
-import { assert, ensurePresence, u8aToHex } from '@dedot/utils';
+import { ensurePresence, u8aToHex } from '@dedot/utils';
 import { SignedExtension } from './SignedExtension.js';
+import { FallbackSignedExtension, isEmptyStructOrTuple } from './FallbackSignedExtension.js';
 import { knownSignedExtensions } from './known/index.js';
 export class ExtraSignedExtension extends SignedExtension {
     #signedExtensions;
@@ -34,13 +35,31 @@ export class ExtraSignedExtension extends SignedExtension {
             const { signedExtensions: userSignedExtensions = {} } = this.client.options;
             const Extension = userSignedExtensions[extDef.ident] ||
                 knownSignedExtensions[extDef.ident];
-            assert(Extension, `SignedExtension for ${extDef.ident} not found`);
-            return new Extension(this.client, {
-                ...ensurePresence(this.options),
-                def: extDef,
-            });
+            if (Extension) {
+                return new Extension(this.client, {
+                    ...ensurePresence(this.options),
+                    def: extDef,
+                });
+            }
+            else if (this.isRequireNoExternalInputs(extDef)) {
+                return new FallbackSignedExtension(this.client, {
+                    ...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 (isEmptyStructOrTuple(this.registry, extDef.typeId) &&
+            isEmptyStructOrTuple(this.registry, extDef.additionalSigned));
+    }
     toPayload(call = '0x') {
         const signedExtensions = this.#signedExtensions.map((se) => se.identifier);
         const { version } = this.registry.metadata.extrinsic;

package/extrinsic/extensions/FallbackSignedExtension.d.ts

@@ -0,0 +1,33 @@
+import { PortableRegistry } from '@dedot/codecs';
+import { SignerPayloadJSON } from '@dedot/types';
+import { SignedExtension } from './SignedExtension.js';
+import { ISubstrateClient } from '../../types.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.
+ */
+export declare class FallbackSignedExtension extends SignedExtension {
+    private readonly extensionIdent;
+    constructor(client: ISubstrateClient, options: any, extensionIdent: string);
+    get identifier(): string;
+    init(): Promise<void>;
+    toPayload(): Partial<SignerPayloadJSON>;
+}
+/**
+ * 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
+ */
+export declare function isEmptyStructOrTuple(registry: PortableRegistry, typeId: number): boolean;

package/extrinsic/extensions/FallbackSignedExtension.js

@@ -0,0 +1,58 @@
+import { SignedExtension } from './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.
+ */
+export class FallbackSignedExtension extends 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
+    }
+}
+/**
+ * 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
+ */
+export 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;
+}

package/extrinsic/extensions/index.d.ts

@@ -1,3 +1,4 @@
 export * from './SignedExtension.js';
 export * from './known/index.js';
 export * from './ExtraSignedExtension.js';
+export * from './FallbackSignedExtension.js';

package/extrinsic/extensions/index.js

@@ -1,3 +1,4 @@
 export * from './SignedExtension.js';
 export * from './known/index.js';
 export * from './ExtraSignedExtension.js';
+export * from './FallbackSignedExtension.js';

package/extrinsic/extensions/known/index.d.ts

@@ -1,3 +1,14 @@
+/**
+ * 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.
+ */
 import { ISignedExtension } from '../SignedExtension.js';
 export type AnySignedExtension = new (...args: any[]) => ISignedExtension;
 export declare const knownSignedExtensions: Record<string, AnySignedExtension>;

package/extrinsic/extensions/known/index.js

@@ -1,26 +1,29 @@
+/**
+ * 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.
+ */
 import { ChargeAssetTxPayment } from './ChargeAssetTxPayment.js';
 import { ChargeTransactionPayment } from './ChargeTransactionPayment.js';
 import { CheckGenesis } from './CheckGenesis.js';
 import { CheckMetadataHash } from './CheckMetadataHash.js';
 import { CheckMortality } from './CheckMortality.js';
-import { CheckNonZeroSender } from './CheckNonZeroSender.js';
 import { CheckNonce } from './CheckNonce.js';
 import { CheckSpecVersion } from './CheckSpecVersion.js';
 import { CheckTxVersion } from './CheckTxVersion.js';
-import { CheckWeight } from './CheckWeight.js';
-import { PrevalidateAttests } from './PrevalidateAttests.js';
-import { StorageWeightReclaim } from './StorageWeightReclaim.js';
 export const knownSignedExtensions = {
-    CheckNonZeroSender,
     CheckSpecVersion,
     CheckTxVersion,
     CheckGenesis,
     CheckMortality,
     CheckNonce,
-    CheckWeight,
     ChargeTransactionPayment,
-    PrevalidateAttests,
     ChargeAssetTxPayment,
     CheckMetadataHash,
-    StorageWeightReclaim,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/api",
-  "version": "0.8.1-next.c741884a.1+c741884",
+  "version": "0.8.2-next.6cfafabd.24+6cfafab",
   "description": "A delightful JavaScript/TypeScript client for Polkadot & Substrate",
   "author": "Thang X. Vu <thang@coongcrafts.io>",
   "homepage": "https://github.com/dedotdev/dedot/tree/main/packages/api",
@@ -13,18 +13,18 @@
   "type": "module",
   "sideEffects": false,
   "dependencies": {
-    "@dedot/codecs": "0.8.1-next.c741884a.1+c741884",
-    "@dedot/providers": "0.8.1-next.c741884a.1+c741884",
-    "@dedot/runtime-specs": "0.8.1-next.c741884a.1+c741884",
-    "@dedot/shape": "0.8.1-next.c741884a.1+c741884",
-    "@dedot/storage": "0.8.1-next.c741884a.1+c741884",
-    "@dedot/types": "0.8.1-next.c741884a.1+c741884",
-    "@dedot/utils": "0.8.1-next.c741884a.1+c741884"
+    "@dedot/codecs": "0.8.2-next.6cfafabd.24+6cfafab",
+    "@dedot/providers": "0.8.2-next.6cfafabd.24+6cfafab",
+    "@dedot/runtime-specs": "0.8.2-next.6cfafabd.24+6cfafab",
+    "@dedot/shape": "0.8.2-next.6cfafabd.24+6cfafab",
+    "@dedot/storage": "0.8.2-next.6cfafabd.24+6cfafab",
+    "@dedot/types": "0.8.2-next.6cfafabd.24+6cfafab",
+    "@dedot/utils": "0.8.2-next.6cfafabd.24+6cfafab"
   },
   "scripts": {
     "build": "tsc --project tsconfig.build.json && tsc --project tsconfig.build.cjs.json",
     "clean": "rm -rf ./dist && rm -rf ./tsconfig.tsbuildinfo ./tsconfig.build.tsbuildinfo",
-    "test": "vitest --watch=false"
+    "test": "npx vitest --watch=false"
   },
   "exports": {
     ".": {
@@ -48,7 +48,7 @@
     "node": ">=18"
   },
   "license": "Apache-2.0",
-  "gitHead": "c741884a785ecee8cdac90f46cd0404e3b09b458",
+  "gitHead": "6cfafabd52dbc7e5bd3ded135e9617fc412bba2b",
   "module": "./index.js",
   "types": "./index.d.ts"
 }

package/storage/BaseStorageQuery.d.ts

@@ -0,0 +1,41 @@
+import { BlockHash, StorageData, StorageKey } from '@dedot/codecs';
+import type { Callback, RpcVersion, Unsub, VersionedGenericSubstrateApi } from '@dedot/types';
+import type { SubstrateApi } from '../chaintypes/index.js';
+import { BaseSubstrateClient } from '../client/BaseSubstrateClient.js';
+/**
+ * @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.
+ */
+export declare abstract class BaseStorageQuery<Rv extends RpcVersion, ChainApi extends VersionedGenericSubstrateApi = SubstrateApi, T extends BaseSubstrateClient<Rv, ChainApi> = BaseSubstrateClient<Rv, ChainApi>> {
+    protected client: T;
+    /**
+     * @param client - The substrate client instance
+     */
+    constructor(client: T);
+    /**
+     * Query multiple storage items in a single call
+     *
+     * @param keys - Array of storage keys to query
+     * @param at - Optional block hash to query at
+     * @returns Promise resolving to a record mapping storage keys to their values
+     */
+    abstract query(keys: StorageKey[], at?: BlockHash): Promise<Record<StorageKey, StorageData | undefined>>;
+    /**
+     * Subscribe to multiple storage items
+     *
+     * @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
+     */
+    abstract subscribe(keys: StorageKey[], callback: Callback<Record<StorageKey, StorageData | undefined>>): Promise<Unsub>;
+}

package/storage/BaseStorageQuery.js

@@ -0,0 +1,23 @@
+/**
+ * @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.
+ */
+export class BaseStorageQuery {
+    client;
+    /**
+     * @param client - The substrate client instance
+     */
+    constructor(client) {
+        this.client = client;
+    }
+}

package/storage/LegacyStorageQuery.d.ts

@@ -0,0 +1,35 @@
+import { BlockHash, StorageData, StorageKey } from '@dedot/codecs';
+import type { Callback, RpcLegacy, Unsub, VersionedGenericSubstrateApi } from '@dedot/types';
+import type { SubstrateApi } from '../chaintypes/index.js';
+import { LegacyClient } from '../client/LegacyClient.js';
+import { BaseStorageQuery } from './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
+ */
+export declare class LegacyStorageQuery<ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends BaseStorageQuery<RpcLegacy, ChainApi, LegacyClient<ChainApi>> {
+    /**
+     * 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
+     */
+    query(keys: StorageKey[], at?: BlockHash): Promise<Record<StorageKey, StorageData | undefined>>;
+    /**
+     * 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
+     */
+    subscribe(keys: StorageKey[], callback: Callback<Record<StorageKey, StorageData | undefined>>): Promise<Unsub>;
+}

package/storage/LegacyStorageQuery.js

@@ -0,0 +1,63 @@
+import { BaseStorageQuery } from './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
+ */
+export class LegacyStorageQuery extends 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 });
+        });
+    }
+}