@dedot/api 0.15.2 → 0.15.3-next.65898ecf.10

package/json-rpc/group/Archive.js

@@ -0,0 +1,222 @@
+import { DedotError } from '@dedot/utils';
+import { JsonRpcGroup } from './JsonRpcGroup.js';
+/**
+ * @name Archive
+ * Archive JSON-RPC methods for accessing historical blockchain data.
+ * Functions with the `archive` prefix allow obtaining the state of the chain
+ * at any point in the present or in the past.
+ *
+ * JSON-RPC V2: https://paritytech.github.io/json-rpc-interface-spec/api/archive.html
+ */
+export class Archive extends JsonRpcGroup {
+    #genesisHash;
+    #cache;
+    constructor(client, options) {
+        super(client, { prefix: 'archive', supportedVersions: ['unstable', 'v1'], ...options });
+        this.#cache = new Map();
+    }
+    /**
+     * Retrieves the body (list of transactions) of a given block.
+     * Returns an array of strings containing the hexadecimal-encoded SCALE-codec-encoded
+     * transactions in that block. If no block with that hash is found, null.
+     *
+     * @param hash - The block hash (optional, defaults to current finalized block)
+     * @returns Array of transaction hashes or null if block not found
+     *
+     * @example
+     * ```typescript
+     * // Get transactions from current finalized block
+     * const transactions = await archive.body();
+     *
+     * // Get transactions from specific block
+     * const transactions = await archive.body('0x1234...');
+     * ```
+     */
+    async body(hash) {
+        const blockHash = hash || (await this.finalizedHash());
+        const cacheKey = `${blockHash}::body`;
+        if (this.#cache.has(cacheKey)) {
+            return this.#cache.get(cacheKey);
+        }
+        const result = await this.send('body', blockHash);
+        this.#cache.set(cacheKey, result);
+        return result;
+    }
+    /**
+     * Get the chain's genesis hash.
+     * Returns a string containing the hexadecimal-encoded hash of the genesis block of the chain.
+     * This value is cached after the first call.
+     *
+     * @returns The genesis block hash
+     */
+    async genesisHash() {
+        if (!this.#genesisHash) {
+            this.#genesisHash = await this.send('genesisHash');
+        }
+        return this.#genesisHash;
+    }
+    /**
+     * Get the block's header.
+     * Returns a string containing the hexadecimal-encoded SCALE-codec encoding header of the block.
+     *
+     * @param hash - The block hash (optional, defaults to current finalized block)
+     * @returns The encoded block header or null if block not found
+     *
+     * @example
+     * ```typescript
+     * // Get header of current finalized block
+     * const header = await archive.header();
+     *
+     * // Get header of specific block
+     * const header = await archive.header('0x1234...');
+     * ```
+     */
+    async header(hash) {
+        const blockHash = hash || (await this.finalizedHash());
+        const cacheKey = `${blockHash}::header`;
+        if (this.#cache.has(cacheKey)) {
+            return this.#cache.get(cacheKey);
+        }
+        const result = await this.send('header', blockHash);
+        this.#cache.set(cacheKey, result);
+        return result;
+    }
+    /**
+     * Get the height of the current finalized block.
+     * Returns an integer height of the current finalized block of the chain.
+     *
+     * @returns The height of the finalized block
+     */
+    async finalizedHeight() {
+        return this.send('finalizedHeight');
+    }
+    /**
+     * Get the hash of the current finalized block.
+     * Returns a string containing the hexadecimal-encoded hash of the current finalized block.
+     * This is a convenience method that combines finalizedHeight() and hashByHeight().
+     *
+     * @returns The hash of the current finalized block
+     */
+    async finalizedHash() {
+        const height = await this.finalizedHeight();
+        const hashes = await this.hashByHeight(height);
+        if (hashes.length === 0) {
+            throw new Error(`No block found at finalized height ${height}`);
+        }
+        return hashes[0];
+    }
+    /**
+     * Get the hashes of blocks from the given height.
+     * Returns an array (possibly empty) of strings containing hexadecimal-encoded hashes of block headers.
+     *
+     * Note: For heights <= finalized height, there is guaranteed to be one block.
+     * For heights > finalized height, there may be zero, one or multiple blocks depending on forks.
+     *
+     * @param height - The block height
+     * @returns Array of block hashes at the given height
+     */
+    async hashByHeight(height) {
+        return this.send('hashByHeight', height);
+    }
+    /**
+     * Call into the Runtime API at a specified block's state.
+     *
+     * @param func - The runtime API function to call
+     * @param params - The parameters for the function call (SCALE-encoded)
+     * @param hash - The block hash (optional, defaults to current finalized block)
+     * @returns The result of the runtime call
+     *
+     * @example
+     * ```typescript
+     * // Call Core_version on current finalized block
+     * const version = await archive.call('Core_version', '0x');
+     *
+     * // Call Core_version on specific block
+     * const version = await archive.call('Core_version', '0x', '0x1234...');
+     * ```
+     */
+    async call(func, params, hash) {
+        const blockHash = hash || (await this.finalizedHash());
+        const cacheKey = `${blockHash}::call::${func}::${params}`;
+        if (this.#cache.has(cacheKey)) {
+            return this.#cache.get(cacheKey);
+        }
+        const result = await this.send('call', blockHash, func, params);
+        if (!result.success) {
+            throw new DedotError(result.error);
+        }
+        this.#cache.set(cacheKey, result.value);
+        return result.value;
+    }
+    /**
+     * Returns storage entries at a specific block's state via subscription.
+     *
+     * @param items - Array of storage queries with optional pagination
+     * @param childTrie - Optional child trie key
+     * @param callback - Callback to receive storage events
+     * @param hash - The block hash (optional, defaults to current finalized block)
+     * @returns Unsubscribe function
+     */
+    async #storageSubscription(items, childTrie, callback, hash) {
+        const blockHash = hash || (await this.finalizedHash());
+        return this.send('storage', blockHash, items, childTrie, callback);
+    }
+    /**
+     * Returns storage entries at a specific block's state.
+     * This method collects all storage events and returns them as a single result.
+     *
+     * @param items - Array of storage queries with optional pagination
+     * @param childTrie - Optional child trie key
+     * @param hash - The block hash (optional, defaults to current finalized block)
+     * @returns Storage results array
+     *
+     * @example
+     * ```typescript
+     * // Query storage from current finalized block
+     * const results = await archive.storage([{ key: '0x1234', type: 'value' }]);
+     *
+     * // Query storage from specific block
+     * const results = await archive.storage([{ key: '0x1234', type: 'value' }], null, '0xabcd...');
+     * ```
+     */
+    async storage(items, childTrie, hash) {
+        return new Promise(async (resolve, reject) => {
+            const results = [];
+            const blockHash = hash || (await this.finalizedHash());
+            // Generate cache key
+            const cacheKey = `${blockHash}::storage::${JSON.stringify(items)}::${childTrie ?? null}`;
+            // Check cache
+            if (this.#cache.has(cacheKey)) {
+                return resolve(this.#cache.get(cacheKey));
+            }
+            this.#storageSubscription(items, childTrie || null, (event) => {
+                switch (event.event) {
+                    case 'storage':
+                        results.push(event);
+                        break;
+                    case 'storageDone':
+                        // Set cache after successful completion
+                        this.#cache.set(cacheKey, results);
+                        resolve(results);
+                        break;
+                    case 'storageError':
+                        reject(new DedotError(event.error));
+                        break;
+                }
+            }, blockHash).catch(reject);
+        });
+    }
+    /**
+     * Clears the internal cache used for storing archive query results.
+     * This can be useful for memory management or when you want to force fresh data retrieval.
+     *
+     * @example
+     * ```typescript
+     * // Clear all cached results
+     * archive.clearCache();
+     * ```
+     */
+    clearCache() {
+        this.#cache.clear();
+    }
+}

package/json-rpc/group/ChainHead/ChainHead.d.ts

@@ -2,6 +2,7 @@ import { BlockHash, Option } from '@dedot/codecs';
 import type { ChainHeadRuntimeVersion, OperationId, StorageQuery, StorageResult } from '@dedot/types/json-rpc';
 import { Deferred, HexString } from '@dedot/utils';
 import type { IJsonRpcClient } from '../../../types.js';
+import { Archive } from '../Archive.js';
 import { JsonRpcGroup, type JsonRpcGroupOptions } from '../JsonRpcGroup.js';
 export type OperationHandler<T = any> = {
     operationId: OperationId;
@@ -20,6 +21,15 @@ export declare const MIN_FINALIZED_QUEUE_SIZE = 10;
 export declare class ChainHead extends JsonRpcGroup<ChainHeadEvent> {
     #private;
     constructor(client: IJsonRpcClient, options?: Partial<JsonRpcGroupOptions>);
+    /**
+     * Attach an Archive instance as fallback for operations that fail due to unpinned blocks.
+     * When a ChainHeadBlockNotPinnedError occurs, the operation will automatically fallback
+     * to the Archive API to attempt to retrieve the data from historical blocks.
+     *
+     * @param archive - Archive instance to use as fallback
+     * @returns this ChainHead instance for method chaining
+     */
+    withArchive(archive: Archive): this;
     runtimeVersion(): Promise<ChainHeadRuntimeVersion>;
     bestRuntimeVersion(): Promise<ChainHeadRuntimeVersion>;
     finalizedHash(): Promise<BlockHash>;

package/json-rpc/group/ChainHead/ChainHead.js

@@ -20,6 +20,17 @@ export class ChainHead extends JsonRpcGroup {
     #blockUsage;
     #cache;
     #operationQueue;
+    /**
+     * Archive instance used as fallback when ChainHead blocks are not pinned.
+     *
+     * When ChainHead operations fail with ChainHeadBlockNotPinnedError, the system
+     * automatically attempts the same operation using the Archive API. This provides
+     * seamless access to historical blockchain data even when blocks are no longer
+     * maintained in the ChainHead's pinned block set.
+     *
+     * @private
+     */
+    #archive;
     constructor(client, options) {
         super(client, { prefix: 'chainHead', supportedVersions: ['unstable', 'v1'], ...options });
         this.#handlers = {};
@@ -33,6 +44,18 @@ export class ChainHead extends JsonRpcGroup {
         // This helps us to not accidentally putting too much stress on the JSON-RPC server, especially smoldot/light-client
         this.#operationQueue = new ThrottleQueue(this.#__unsafe__isSmoldot() ? 25 : 250);
     }
+    /**
+     * Attach an Archive instance as fallback for operations that fail due to unpinned blocks.
+     * When a ChainHeadBlockNotPinnedError occurs, the operation will automatically fallback
+     * to the Archive API to attempt to retrieve the data from historical blocks.
+     *
+     * @param archive - Archive instance to use as fallback
+     * @returns this ChainHead instance for method chaining
+     */
+    withArchive(archive) {
+        this.#archive = archive;
+        return this;
+    }
     async runtimeVersion() {
         await this.#ensureFollowed();
         return this.#finalizedRuntime;
@@ -341,11 +364,39 @@ export class ChainHead extends JsonRpcGroup {
                 return hash;
             }
             else {
-                throw new ChainHeadBlockNotPinnedError(`Block hash ${hash} is not pinned`);
+                throw new ChainHeadBlockNotPinnedError(`Block hash ${hash} is not pinned`, hash);
             }
         }
         return ensurePresence(this.#bestHash || this.#finalizedHash);
     }
+    /**
+     * Executes a ChainHead operation with automatic Archive fallback.
+     *
+     * This method first attempts the primary ChainHead operation. If it fails with
+     * ChainHeadBlockNotPinnedError (indicating the block is no longer pinned), and
+     * an Archive instance is available, it automatically retries the operation using
+     * the Archive API.
+     *
+     * @param operation - Primary ChainHead operation to attempt
+     * @param fallback - Archive operation to fallback to
+     * @param hash - Block hash being accessed (for logging)
+     * @returns Result from either ChainHead or Archive operation
+     * @throws Original error if not a pinning error or no Archive available
+     * @private
+     */
+    async #tryWithArchive(operation, fallback) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            if (error instanceof ChainHeadBlockNotPinnedError && this.#archive) {
+                const errorHash = error.hash;
+                console.warn(`Block ${errorHash} not pinned in ChainHead, falling back to Archive`);
+                return await fallback(this.#archive, errorHash);
+            }
+            throw error;
+        }
+    }
     #getOperationHandler(result) {
         const handler = this.#handlers[result.operationId];
         if (handler)
@@ -475,21 +526,31 @@ export class ChainHead extends JsonRpcGroup {
     async body(at) {
         await this.#ensureFollowed();
         const shouldRetryOnPrunedBlock = !at;
-        try {
+        const operation = async () => {
             const atHash = this.#ensurePinnedHash(at);
             const cacheKey = `${atHash}::body`;
             if (this.#cache.has(cacheKey)) {
                 return this.#cache.get(cacheKey);
             }
-            const operation = async () => {
+            const bodyOperation = async () => {
                 await this.#ensureFollowed();
                 const hash = this.#ensurePinnedHash(atHash);
                 const resp = await this.send('body', this.#subscriptionId, hash);
                 return this.#awaitOperation(resp, hash);
             };
-            const resp = await this.#operationQueue.add(() => this.#performOperationWithRetry(operation, atHash));
+            const resp = await this.#operationQueue.add(() => this.#performOperationWithRetry(bodyOperation, atHash));
             this.#cache.set(cacheKey, resp);
             return resp;
+        };
+        const fallback = async (archive, hash) => {
+            const result = await archive.body(hash);
+            if (result === undefined) {
+                throw new ChainHeadOperationError(`Block ${hash} not found in Archive`);
+            }
+            return result;
+        };
+        try {
+            return await this.#tryWithArchive(operation, fallback);
         }
         catch (e) {
             if (e instanceof ChainHeadBlockPrunedError && shouldRetryOnPrunedBlock) {
@@ -504,21 +565,25 @@ export class ChainHead extends JsonRpcGroup {
     async call(func, params = '0x', at) {
         await this.#ensureFollowed();
         const shouldRetryOnPrunedBlock = !at;
-        try {
+        const operation = async () => {
             const atHash = this.#ensurePinnedHash(at);
             const cacheKey = `${atHash}::call::${func}::${params}`;
             if (this.#cache.has(cacheKey)) {
                 return this.#cache.get(cacheKey);
             }
-            const operation = async () => {
+            const callOperation = async () => {
                 await this.#ensureFollowed();
                 const hash = this.#ensurePinnedHash(atHash);
                 const resp = await this.send('call', this.#subscriptionId, hash, func, params);
                 return this.#awaitOperation(resp, hash);
             };
-            const resp = await this.#operationQueue.add(() => this.#performOperationWithRetry(operation, atHash));
+            const resp = await this.#operationQueue.add(() => this.#performOperationWithRetry(callOperation, atHash));
             this.#cache.set(cacheKey, resp);
             return resp;
+        };
+        const fallback = (archive, hash) => archive.call(func, params, hash);
+        try {
+            return await this.#tryWithArchive(operation, fallback);
         }
         catch (e) {
             if (e instanceof ChainHeadBlockPrunedError && shouldRetryOnPrunedBlock) {
@@ -532,14 +597,18 @@ export class ChainHead extends JsonRpcGroup {
      */
     async header(at) {
         await this.#ensureFollowed();
-        const hash = this.#ensurePinnedHash(at);
-        const cacheKey = `${hash}::header`;
-        if (this.#cache.has(cacheKey)) {
-            return this.#cache.get(cacheKey);
-        }
-        const resp = await this.#getHeader(hash);
-        this.#cache.set(cacheKey, resp);
-        return resp;
+        const operation = async () => {
+            const hash = this.#ensurePinnedHash(at);
+            const cacheKey = `${hash}::header`;
+            if (this.#cache.has(cacheKey)) {
+                return this.#cache.get(cacheKey);
+            }
+            const resp = await this.#getHeader(hash);
+            this.#cache.set(cacheKey, resp);
+            return resp;
+        };
+        const fallback = (archive, errorHash) => archive.header(errorHash);
+        return await this.#tryWithArchive(operation, fallback);
     }
     async #getHeader(at) {
         return await this.send('header', this.#subscriptionId, at);
@@ -550,35 +619,46 @@ export class ChainHead extends JsonRpcGroup {
     async storage(items, childTrie, at) {
         await this.#ensureFollowed();
         const shouldRetryOnPrunedBlock = !at;
-        const hash = this.#ensurePinnedHash(at);
-        try {
-            // JSON.stringify(items) might get big, we probably should do a twox hashing in such case
-            const cacheKey = `${hash}::storage::${JSON.stringify(items)}::${childTrie ?? null}`;
-            if (this.#cache.has(cacheKey)) {
-                return this.#cache.get(cacheKey);
-            }
-            this.#blockUsage.use(hash);
-            let results = [];
-            if (this.#__unsafe__isSmoldot()) {
-                const fetchItem = async (item) => {
-                    const [batch, newDiscardedItems] = await this.#getStorage([item], childTrie ?? null, hash);
-                    if (newDiscardedItems.length > 0) {
-                        return fetchItem(item);
+        const operation = async () => {
+            const hash = this.#ensurePinnedHash(at);
+            try {
+                // JSON.stringify(items) might get big, we probably should do a twox hashing in such case
+                const cacheKey = `${hash}::storage::${JSON.stringify(items)}::${childTrie ?? null}`;
+                if (this.#cache.has(cacheKey)) {
+                    return this.#cache.get(cacheKey);
+                }
+                this.#blockUsage.use(hash);
+                let results = [];
+                if (this.#__unsafe__isSmoldot()) {
+                    const fetchItem = async (item) => {
+                        const [batch, newDiscardedItems] = await this.#getStorage([item], childTrie ?? null, hash);
+                        if (newDiscardedItems.length > 0) {
+                            return fetchItem(item);
+                        }
+                        return batch;
+                    };
+                    results = (await Promise.all(items.map((one) => fetchItem(one)))).flat();
+                }
+                else {
+                    let queryItems = items;
+                    while (queryItems.length > 0) {
+                        const [newBatch, newDiscardedItems] = await this.#getStorage(queryItems, childTrie ?? null, hash);
+                        results.push(...newBatch);
+                        queryItems = newDiscardedItems;
                     }
-                    return batch;
-                };
-                results = (await Promise.all(items.map((one) => fetchItem(one)))).flat();
-            }
-            else {
-                let queryItems = items;
-                while (queryItems.length > 0) {
-                    const [newBatch, newDiscardedItems] = await this.#getStorage(queryItems, childTrie ?? null, hash);
-                    results.push(...newBatch);
-                    queryItems = newDiscardedItems;
                 }
+                this.#cache.set(cacheKey, results);
+                return results;
+            }
+            finally {
+                this.#blockUsage.release(hash);
             }
-            this.#cache.set(cacheKey, results);
-            return results;
+        };
+        const fallback = (archive, hash) => {
+            return archive.storage(items, childTrie, hash);
+        };
+        try {
+            return await this.#tryWithArchive(operation, fallback);
         }
         catch (e) {
             if (e instanceof ChainHeadBlockPrunedError && shouldRetryOnPrunedBlock) {
@@ -586,9 +666,6 @@ export class ChainHead extends JsonRpcGroup {
             }
             throw e;
         }
-        finally {
-            this.#blockUsage.release(hash);
-        }
     }
     async #getStorage(items, childTrie, at) {
         const operation = () => this.#getStorageOperation(items, childTrie, this.#ensurePinnedHash(at));

package/json-rpc/group/ChainHead/error.d.ts

@@ -1,3 +1,4 @@
+import { BlockHash } from '@dedot/codecs';
 import { DedotError } from '@dedot/utils';
 export declare enum RetryStrategy {
     NOW = "NOW",// Retry immediately
@@ -49,6 +50,8 @@ export declare class ChainHeadInvalidRuntimeError extends ChainHeadError {
 }
 export declare class ChainHeadBlockNotPinnedError extends ChainHeadError {
     name: string;
+    hash: BlockHash;
+    constructor(message: string, hash: BlockHash | string);
 }
 export declare class ChainHeadBlockPrunedError extends ChainHeadError {
     name: string;

package/json-rpc/group/ChainHead/error.js

@@ -50,6 +50,11 @@ export class ChainHeadInvalidRuntimeError extends ChainHeadError {
 }
 export class ChainHeadBlockNotPinnedError extends ChainHeadError {
     name = 'ChainHeadBlockNotPinnedError';
+    hash;
+    constructor(message, hash) {
+        super(message);
+        this.hash = hash;
+    }
 }
 export class ChainHeadBlockPrunedError extends ChainHeadError {
     name = 'ChainHeadBlockPrunedError';

package/json-rpc/group/index.d.ts

@@ -1,4 +1,5 @@
 export * from './JsonRpcGroup.js';
+export * from './Archive.js';
 export * from './ChainSpec.js';
 export * from './Transaction.js';
 export * from './TransactionWatch.js';

package/json-rpc/group/index.js

@@ -1,4 +1,5 @@
 export * from './JsonRpcGroup.js';
+export * from './Archive.js';
 export * from './ChainSpec.js';
 export * from './Transaction.js';
 export * from './TransactionWatch.js';

package/json-rpc/subscriptionsInfo.js

@@ -14,4 +14,8 @@ export const subscriptionsInfo = {
         'transactionWatch_unstable_unwatch',
     ],
     transactionWatch_v1_submitAndWatch: ['transactionWatch_v1_watchEvent', 'transactionWatch_v1_unwatch'],
+    archive_v1_storage: ['archive_v1_storageEvent', 'archive_v1_stopStorage'],
+    archive_v1_storageDiff: ['archive_v1_storageDiffEvent', 'archive_v1_stopStorageDiff'],
+    archive_unstable_storage: ['archive_unstable_storageEvent', 'archive_unstable_stopStorage'],
+    archive_unstable_storageDiff: ['archive_unstable_storageDiffEvent', 'archive_unstable_stopStorageDiff'],
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/api",
-  "version": "0.15.2",
+  "version": "0.15.3-next.65898ecf.10+65898ecf",
   "description": "A delightful JavaScript/TypeScript client for Polkadot & Substrate",
   "author": "Thang X. Vu <thang@dedot.dev>",
   "homepage": "https://dedot.dev",
@@ -13,13 +13,13 @@
   "type": "module",
   "sideEffects": false,
   "dependencies": {
-    "@dedot/codecs": "0.15.2",
-    "@dedot/providers": "0.15.2",
-    "@dedot/runtime-specs": "0.15.2",
-    "@dedot/shape": "0.15.2",
-    "@dedot/storage": "0.15.2",
-    "@dedot/types": "0.15.2",
-    "@dedot/utils": "0.15.2"
+    "@dedot/codecs": "0.15.3-next.65898ecf.10+65898ecf",
+    "@dedot/providers": "0.15.3-next.65898ecf.10+65898ecf",
+    "@dedot/runtime-specs": "0.15.3-next.65898ecf.10+65898ecf",
+    "@dedot/shape": "0.15.3-next.65898ecf.10+65898ecf",
+    "@dedot/storage": "0.15.3-next.65898ecf.10+65898ecf",
+    "@dedot/types": "0.15.3-next.65898ecf.10+65898ecf",
+    "@dedot/utils": "0.15.3-next.65898ecf.10+65898ecf"
   },
   "scripts": {
     "build": "tsc --project tsconfig.build.json && tsc --project tsconfig.build.cjs.json",
@@ -48,7 +48,7 @@
     "node": ">=18"
   },
   "license": "Apache-2.0",
-  "gitHead": "75231d6888303dcf598cfd31592df13230707cb4",
+  "gitHead": "65898ecf2226162fc6632d3f4f64ad5fe1179643",
   "module": "./index.js",
   "types": "./index.d.ts"
 }

package/storage/BaseStorageQuery.d.ts

@@ -1,7 +1,6 @@
+import { ISubstrateClient, ISubstrateClientAt } from '@dedot/api/types';
 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';
+import type { Callback, Unsub } from '@dedot/types';
 /**
  * @name BaseStorageQuery
  * @description
@@ -16,12 +15,12 @@ import { BaseSubstrateClient } from '../client/BaseSubstrateClient.js';
  * 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;
+export declare abstract class BaseStorageQuery {
+    protected client: ISubstrateClientAt<any> | ISubstrateClient<any, any>;
     /**
      * @param client - The substrate client instance
      */
-    constructor(client: T);
+    protected constructor(client: ISubstrateClientAt<any> | ISubstrateClient<any, any>);
     /**
      * Query multiple storage items in a single call
      *

package/storage/LegacyStorageQuery.d.ts

@@ -1,6 +1,5 @@
 import { BlockHash, StorageData, StorageKey } from '@dedot/codecs';
-import type { Callback, RpcLegacy, Unsub, VersionedGenericSubstrateApi } from '@dedot/types';
-import type { SubstrateApi } from '../chaintypes/index.js';
+import type { Callback, Unsub } from '@dedot/types';
 import { LegacyClient } from '../client/LegacyClient.js';
 import { BaseStorageQuery } from './BaseStorageQuery.js';
 /**
@@ -15,7 +14,9 @@ import { BaseStorageQuery } from './BaseStorageQuery.js';
  * - Subscriptions using state_subscribeStorage
  * - Efficient change tracking for subscriptions
  */
-export declare class LegacyStorageQuery<ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends BaseStorageQuery<RpcLegacy, ChainApi, LegacyClient<ChainApi>> {
+export declare class LegacyStorageQuery extends BaseStorageQuery {
+    protected client: LegacyClient<any>;
+    constructor(client: LegacyClient<any>);
     /**
      * Query multiple storage items in a single call using state_queryStorageAt
      *

package/storage/LegacyStorageQuery.js

@@ -12,6 +12,11 @@ import { BaseStorageQuery } from './BaseStorageQuery.js';
  * - Efficient change tracking for subscriptions
  */
 export class LegacyStorageQuery extends BaseStorageQuery {
+    client;
+    constructor(client) {
+        super(client);
+        this.client = client;
+    }
     /**
      * Query multiple storage items in a single call using state_queryStorageAt
      *

package/storage/NewStorageQuery.d.ts

@@ -1,7 +1,6 @@
+import { DedotClient } from '@dedot/api/client';
 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 type { Callback, Unsub } from '@dedot/types';
 import { BaseStorageQuery } from './BaseStorageQuery.js';
 /**
  * @name NewStorageQuery
@@ -15,7 +14,9 @@ import { BaseStorageQuery } from './BaseStorageQuery.js';
  * - Subscriptions using chainHead 'bestBlock' events
  * - Efficient change detection for subscriptions
  */
-export declare class NewStorageQuery<ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends BaseStorageQuery<RpcV2, ChainApi, DedotClient<ChainApi>> {
+export declare class NewStorageQuery extends BaseStorageQuery {
+    protected client: DedotClient<any>;
+    constructor(client: DedotClient<any>);
     /**
      * Query multiple storage items in a single call using chainHead_storage
      *