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

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",
+  "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",
-    "@dedot/providers": "0.8.1",
-    "@dedot/runtime-specs": "0.8.1",
-    "@dedot/shape": "0.8.1",
-    "@dedot/storage": "0.8.1",
-    "@dedot/types": "0.8.1",
-    "@dedot/utils": "0.8.1"
+    "@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": "03ad1a7c81a90b78b39206b30fc96a65537faaee",
+  "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 });
+        });
+    }
+}

package/storage/NewStorageQuery.d.ts

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

package/storage/NewStorageQuery.js

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

package/storage/index.d.ts

@@ -1 +1,4 @@
 export * from './QueryableStorage.js';
+export * from './BaseStorageQuery.js';
+export * from './LegacyStorageQuery.js';
+export * from './NewStorageQuery.js';

package/storage/index.js

@@ -1 +1,4 @@
 export * from './QueryableStorage.js';
+export * from './BaseStorageQuery.js';
+export * from './LegacyStorageQuery.js';
+export * from './NewStorageQuery.js';