@dedot/api 0.15.2 → 0.16.0

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

@@ -1,9 +1,11 @@
 import { $Header } from '@dedot/codecs';
-import { assert, AsyncQueue, deferred, ensurePresence, noop, ThrottleQueue, waitFor, } from '@dedot/utils';
+import { assert, AsyncQueue, deferred, ensurePresence, noop, ThrottleQueue, waitFor, LRUCache, } from '@dedot/utils';
 import { JsonRpcGroup } from '../JsonRpcGroup.js';
 import { BlockUsage } from './BlockUsage.js';
 import { ChainHeadBlockNotPinnedError, ChainHeadBlockPrunedError, ChainHeadError, ChainHeadLimitReachedError, ChainHeadOperationError, ChainHeadOperationInaccessibleError, ChainHeadStopError, RetryStrategy, } from './error.js';
 export const MIN_FINALIZED_QUEUE_SIZE = 10; // finalized queue size
+const CHAINHEAD_CACHE_CAPACITY = 256;
+const CHAINHEAD_CACHE_TTL = 30_000; // 30 seconds
 export class ChainHead extends JsonRpcGroup {
     #unsub;
     #subscriptionId;
@@ -20,6 +22,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 = {};
@@ -29,10 +42,22 @@ export class ChainHead extends JsonRpcGroup {
         this.#followResponseQueue = new AsyncQueue();
         this.#retryQueue = new AsyncQueue();
         this.#blockUsage = new BlockUsage();
-        this.#cache = new Map();
+        this.#cache = new LRUCache(CHAINHEAD_CACHE_CAPACITY, CHAINHEAD_CACHE_TTL);
         // 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;
@@ -219,8 +244,9 @@ export class ChainHead extends JsonRpcGroup {
                     if (!this.isPinned(hash))
                         return;
                     delete this.#pinnedBlocks[hash];
-                    // clear cache
-                    Array.from(this.#cache.keys())
+                    // Clear cache entries related to the pruned block
+                    // Filter and remove only cache entries for this specific block
+                    this.#cache.keys()
                         .filter((key) => key.startsWith(`${hash}::`))
                         .forEach((key) => this.#cache.delete(key));
                 });
@@ -341,11 +367,38 @@ 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;
+                return await fallback(this.#archive, errorHash);
+            }
+            throw error;
+        }
+    }
     #getOperationHandler(result) {
         const handler = this.#handlers[result.operationId];
         if (handler)
@@ -400,7 +453,7 @@ export class ChainHead extends JsonRpcGroup {
         this.#followResponseQueue.clear();
         this.#retryQueue.clear();
         this.#blockUsage.clear();
-        this.#cache.clear();
+        this.clearCache();
         this.#operationQueue.cancel();
     }
     async #ensureFollowed() {
@@ -475,21 +528,32 @@ 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 cached = this.#cache.get(cacheKey);
+            if (cached) {
+                return cached;
             }
-            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 +568,26 @@ 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 cached = this.#cache.get(cacheKey);
+            if (cached) {
+                return cached;
             }
-            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 +601,19 @@ 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`;
+            const cached = this.#cache.get(cacheKey);
+            if (cached) {
+                return cached;
+            }
+            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 +624,47 @@ 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}`;
+                const cached = this.#cache.get(cacheKey);
+                if (cached) {
+                    return cached;
+                }
+                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 +672,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));
@@ -633,4 +716,18 @@ export class ChainHead extends JsonRpcGroup {
         // @ts-ignore  a trick internally to check whether a provider is using smoldot connection
         return typeof this.client.provider['chain'] === 'function';
     }
+    /**
+     * Clears the internal cache used for storing query results (both chainHead & archive instances)
+     * This can be useful for memory management or when you want to force fresh data retrieval.
+     *
+     * @example
+     * ```typescript
+     * // Clear all cached results
+     * chainHead.clearCache();
+     * ```
+     */
+    clearCache() {
+        this.#cache.clear();
+        this.#archive?.clearCache();
+    }
 }

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.16.0",
   "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.16.0",
+    "@dedot/providers": "0.16.0",
+    "@dedot/runtime-specs": "0.16.0",
+    "@dedot/shape": "0.16.0",
+    "@dedot/storage": "0.16.0",
+    "@dedot/types": "0.16.0",
+    "@dedot/utils": "0.16.0"
   },
   "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": "3e78a8eebb8977de0c5fb956154e5b09c4448f31",
   "module": "./index.js",
   "types": "./index.d.ts"
 }

package/storage/BaseStorageQuery.d.ts

@@ -1,7 +1,6 @@
 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';
+import { ISubstrateClient, ISubstrateClientAt } from '../types.js';
 /**
  * @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,6 +1,5 @@
 import { BlockHash, StorageData, StorageKey } from '@dedot/codecs';
-import type { Callback, RpcV2, Unsub, VersionedGenericSubstrateApi } from '@dedot/types';
-import type { SubstrateApi } from '../chaintypes/index.js';
+import type { Callback, Unsub } from '@dedot/types';
 import { DedotClient } from '../client/DedotClient.js';
 import { BaseStorageQuery } from './BaseStorageQuery.js';
 /**
@@ -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
      *

package/storage/NewStorageQuery.js

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

package/storage/QueryableStorage.d.ts

@@ -5,12 +5,12 @@ import { PortableRegistry, PalletDefLatest, StorageDataLike, StorageEntryLatest,
  */
 export declare class QueryableStorage {
     #private;
-    readonly registry: PortableRegistry;
+    readonly registry: PortableRegistry<any>;
     readonly palletName: string;
     readonly storageItem: string;
     readonly pallet: PalletDefLatest;
     readonly storageEntry: StorageEntryLatest;
-    constructor(registry: PortableRegistry, palletName: string, storageItem: string);
+    constructor(registry: PortableRegistry<any>, palletName: string, storageItem: string);
     get prefixKey(): PrefixedStorageKey;
     get prefixKeyAsU8a(): Uint8Array;
     /**

package/types.d.ts

@@ -1,4 +1,3 @@
-import { ChainHeadEvent } from '@dedot/api/json-rpc';
 import { BlockHash, Hash, Metadata, PortableRegistry } from '@dedot/codecs';
 import type { ConnectionStatus, JsonRpcProvider, ProviderEvent } from '@dedot/providers';
 import type { AnyShape } from '@dedot/shape';
@@ -6,6 +5,7 @@ import type { IStorage } from '@dedot/storage';
 import type { Callback, GenericStorageQuery, GenericSubstrateApi, InjectedSigner, Query, QueryFnResult, RpcVersion, RuntimeApiName, RuntimeApiSpec, Unsub } from '@dedot/types';
 import type { HashFn, HexString, IEventEmitter } from '@dedot/utils';
 import type { AnySignedExtension } from './extrinsic/index.js';
+import type { ChainHeadEvent } from './json-rpc/index.js';
 export type MetadataKey = `RAW_META/${string}`;
 export type SubscribeMethod = string;
 export type UnsubscribeMethod = string;
@@ -83,16 +83,15 @@ export interface IJsonRpcClient<ChainApi extends GenericSubstrateApi = GenericSu
     rpc: ChainApi['rpc'];
 }
 /**
- * A generic interface for Substrate clients at a specific block
+ * @internal
  */
-export interface ISubstrateClientAt<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> {
-    atBlockHash?: BlockHash;
+export interface IGenericSubstrateClient<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> {
     rpcVersion: RpcVersion;
     options: ApiOptions;
     genesisHash: Hash;
     runtimeVersion: SubstrateRuntimeVersion;
     metadata: Metadata;
-    registry: PortableRegistry;
+    registry: PortableRegistry<ChainApi>;
     rpc: ChainApi['rpc'];
     consts: ChainApi['consts'];
     query: ChainApi['query'];
@@ -101,10 +100,16 @@ export interface ISubstrateClientAt<ChainApi extends GenericSubstrateApi = Gener
     errors: ChainApi['errors'];
     view: ChainApi['view'];
 }
+/**
+ * A generic interface for Substrate clients at a specific block
+ */
+export interface ISubstrateClientAt<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> extends IGenericSubstrateClient<ChainApi> {
+    atBlockHash: BlockHash;
+}
 /**
  * A generic interface for Substrate clients
  */
-export interface ISubstrateClient<ChainApi extends GenericSubstrateApi = GenericSubstrateApi, Events extends string = ApiEvent> extends IJsonRpcClient<ChainApi, Events>, ISubstrateClientAt<ChainApi> {
+export interface ISubstrateClient<ChainApi extends GenericSubstrateApi = GenericSubstrateApi, Events extends string = ApiEvent> extends IJsonRpcClient<ChainApi, Events>, IGenericSubstrateClient<ChainApi> {
     options: ApiOptions;
     tx: ChainApi['tx'];
     at<ChainApiAt extends GenericSubstrateApi = ChainApi>(hash: BlockHash): Promise<ISubstrateClientAt<ChainApiAt>>;