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

package/cjs/json-rpc/group/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./JsonRpcGroup.js"), exports);
+__exportStar(require("./Archive.js"), exports);
 __exportStar(require("./ChainSpec.js"), exports);
 __exportStar(require("./Transaction.js"), exports);
 __exportStar(require("./TransactionWatch.js"), exports);

package/cjs/json-rpc/subscriptionsInfo.js

@@ -17,4 +17,8 @@ exports.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/cjs/storage/LegacyStorageQuery.js

@@ -15,6 +15,11 @@ const BaseStorageQuery_js_1 = require("./BaseStorageQuery.js");
  * - Efficient change tracking for subscriptions
  */
 class LegacyStorageQuery extends BaseStorageQuery_js_1.BaseStorageQuery {
+    client;
+    constructor(client) {
+        super(client);
+        this.client = client;
+    }
     /**
      * Query multiple storage items in a single call using state_queryStorageAt
      *

package/cjs/storage/NewStorageQuery.js

@@ -16,6 +16,11 @@ const BaseStorageQuery_js_1 = require("./BaseStorageQuery.js");
  * - Efficient change detection for subscriptions
  */
 class NewStorageQuery extends BaseStorageQuery_js_1.BaseStorageQuery {
+    client;
+    constructor(client) {
+        super(client);
+        this.client = client;
+    }
     /**
      * Query multiple storage items in a single call using chainHead_storage
      *

package/client/BaseSubstrateClient.d.ts

@@ -15,7 +15,7 @@ export declare function ensurePresence<T>(value: T): NonNullable<T>;
 export declare abstract class BaseSubstrateClient<Rv extends RpcVersion, ChainApi extends VersionedGenericSubstrateApi = SubstrateApi, Events extends string = ApiEvent> extends JsonRpcClient<ChainApi, Events> implements ISubstrateClient<ChainApi[Rv], Events> {
     rpcVersion: RpcVersion;
     protected _options: ApiOptions;
-    protected _registry?: PortableRegistry;
+    protected _registry?: PortableRegistry<ChainApi[Rv]>;
     protected _metadata?: Metadata;
     protected _genesisHash?: Hash;
     protected _runtimeVersion?: SubstrateRuntimeVersion;
@@ -61,7 +61,7 @@ export declare abstract class BaseSubstrateClient<Rv extends RpcVersion, ChainAp
     disconnect(): Promise<void>;
     get options(): ApiOptions;
     get metadata(): Metadata;
-    get registry(): PortableRegistry;
+    get registry(): PortableRegistry<ChainApi[Rv]>;
     get genesisHash(): Hash;
     get runtimeVersion(): SubstrateRuntimeVersion;
     getRuntimeVersion(): Promise<SubstrateRuntimeVersion>;
@@ -106,5 +106,5 @@ export declare abstract class BaseSubstrateClient<Rv extends RpcVersion, ChainAp
     }, callback: Callback<{
         [K in keyof Fns]: QueryFnResult<Fns[K]>;
     }>): Promise<Unsub>;
-    protected getStorageQuery(): BaseStorageQuery<RpcVersion>;
+    protected getStorageQuery(): BaseStorageQuery;
 }

package/client/DedotClient.d.ts

@@ -1,8 +1,8 @@
 import { BlockHash } from '@dedot/codecs';
 import type { JsonRpcProvider } from '@dedot/providers';
-import { GenericSubstrateApi, RpcV2, RpcVersion, VersionedGenericSubstrateApi } from '@dedot/types';
+import { GenericSubstrateApi, RpcV2, VersionedGenericSubstrateApi } from '@dedot/types';
 import type { SubstrateApi } from '../chaintypes/index.js';
-import { ChainHead, ChainSpec, PinnedBlock } from '../json-rpc/index.js';
+import { Archive, ChainHead, ChainSpec, PinnedBlock } from '../json-rpc/index.js';
 import { BaseStorageQuery } from '../storage/index.js';
 import type { ApiOptions, DedotClientEvent, ISubstrateClientAt, TxBroadcaster } from '../types.js';
 import { BaseSubstrateClient } from './BaseSubstrateClient.js';
@@ -17,6 +17,7 @@ export declare class DedotClient<ChainApi extends VersionedGenericSubstrateApi =
     #private;
     protected _chainHead?: ChainHead;
     protected _chainSpec?: ChainSpec;
+    protected _archive?: Archive;
     protected _txBroadcaster?: TxBroadcaster;
     /**
      * Use factory methods (`create`, `new`) to create `DedotClient` instances.
@@ -38,6 +39,7 @@ export declare class DedotClient<ChainApi extends VersionedGenericSubstrateApi =
     static new<ChainApi extends VersionedGenericSubstrateApi = SubstrateApi>(options: ApiOptions | JsonRpcProvider): Promise<DedotClient<ChainApi>>;
     get chainSpec(): ChainSpec;
     get chainHead(): ChainHead;
+    archive(): Promise<Archive>;
     get txBroadcaster(): TxBroadcaster;
     /**
      * Initialize APIs before usage
@@ -55,10 +57,10 @@ export declare class DedotClient<ChainApi extends VersionedGenericSubstrateApi =
     get tx(): ChainApi[RpcV2]['tx'];
     /**
      * Get a new API instance at a specific block hash
-     * For now, this only supports pinned block hashes from the chain head
+     * Supports both pinned blocks (via ChainHead) and historical blocks (via Archive fallback)
      *
      * @param hash
      */
     at<ChainApiAt extends GenericSubstrateApi = ChainApi[RpcV2]>(hash: BlockHash): Promise<ISubstrateClientAt<ChainApiAt>>;
-    protected getStorageQuery(): BaseStorageQuery<RpcVersion>;
+    protected getStorageQuery(): BaseStorageQuery;
 }

package/client/DedotClient.js

@@ -1,8 +1,8 @@
-import { $H256, PortableRegistry } from '@dedot/codecs';
+import { $H256, $RuntimeVersion, PortableRegistry } from '@dedot/codecs';
 import { u32 } from '@dedot/shape';
-import { assert, concatU8a, noop, twox64Concat, u8aToHex, xxhashAsU8a } from '@dedot/utils';
+import { assert, concatU8a, noop, twox64Concat, u8aToHex, xxhashAsU8a, DedotError } from '@dedot/utils';
 import { ConstantExecutor, ErrorExecutor, EventExecutor, RuntimeApiExecutorV2, StorageQueryExecutorV2, ViewFunctionExecutorV2, TxExecutorV2, } from '../executor/index.js';
-import { ChainHead, ChainSpec, Transaction, TransactionWatch } from '../json-rpc/index.js';
+import { Archive, ChainHead, ChainSpec, Transaction, TransactionWatch } from '../json-rpc/index.js';
 import { newProxyChain } from '../proxychain.js';
 import { NewStorageQuery } from '../storage/index.js';
 import { BaseSubstrateClient, ensurePresence } from './BaseSubstrateClient.js';
@@ -16,6 +16,7 @@ export class DedotClient// prettier-end-here
  extends BaseSubstrateClient {
     _chainHead;
     _chainSpec;
+    _archive;
     _txBroadcaster;
     #apiAtCache = {};
     /**
@@ -48,6 +49,11 @@ export class DedotClient// prettier-end-here
     get chainHead() {
         return ensurePresence(this._chainHead);
     }
+    async archive() {
+        assert(this._archive, 'Archive instance is not initialized');
+        assert(await this._archive.supported(), 'Archive JSON-RPC is not supported by the connected server');
+        return this._archive;
+    }
     get txBroadcaster() {
         this.chainHead; // Ensure chain head is initialized
         assert(this._txBroadcaster, 'JSON-RPC method to broadcast transactions is not supported by the server/node.');
@@ -68,6 +74,12 @@ export class DedotClient// prettier-end-here
         const rpcMethods = (await this.rpc.rpc_methods()).methods;
         this._chainHead = new ChainHead(this, { rpcMethods });
         this._chainSpec = new ChainSpec(this, { rpcMethods });
+        // Always initialize Archive, but only set up fallback if supported
+        this._archive = new Archive(this, { rpcMethods });
+        // Set up ChainHead with Archive fallback only if Archive is supported
+        if (await this._archive.supported()) {
+            this._chainHead.withArchive(this._archive);
+        }
         this._txBroadcaster = await this.#initializeTxBroadcaster(rpcMethods);
         // Fetching node information
         let [_, genesisHash] = await Promise.all([
@@ -130,6 +142,7 @@ export class DedotClient// prettier-end-here
         super.cleanUp();
         this._chainHead = undefined;
         this._chainSpec = undefined;
+        this._archive = undefined;
         this._txBroadcaster = undefined;
         this.#apiAtCache = {};
     }
@@ -156,19 +169,39 @@ export class DedotClient// prettier-end-here
     }
     /**
      * Get a new API instance at a specific block hash
-     * For now, this only supports pinned block hashes from the chain head
+     * Supports both pinned blocks (via ChainHead) and historical blocks (via Archive fallback)
      *
      * @param hash
      */
     async at(hash) {
         if (this.#apiAtCache[hash])
             return this.#apiAtCache[hash];
+        let targetVersion;
+        // Try to get block info from ChainHead first (for pinned blocks)
         const targetBlock = this.chainHead.findBlock(hash);
-        assert(targetBlock, 'Block is not pinned!');
-        let targetVersion = targetBlock.runtime;
-        if (!targetVersion) {
-            // fallback to fetching on-chain runtime if we can't find it in the block
-            targetVersion = this.toSubstrateRuntimeVersion(await this.callAt(hash).core.version());
+        if (targetBlock) {
+            targetVersion = targetBlock.runtime;
+            if (!targetVersion) {
+                // fallback to fetching on-chain runtime if we can't find it in the block
+                targetVersion = this.toSubstrateRuntimeVersion(await this.callAt(hash).core.version());
+            }
+        }
+        else {
+            // Block not pinned, try via Archive fallback if supported
+            if (this._archive && (await this._archive.supported())) {
+                console.warn(`Block ${hash} is not pinned, using Archive for historical access`);
+                try {
+                    // Fetch runtime version via Archive
+                    const runtimeRaw = await this._archive.call('Core_version', '0x', hash);
+                    targetVersion = this.toSubstrateRuntimeVersion($RuntimeVersion.tryDecode(runtimeRaw));
+                }
+                catch (error) {
+                    throw new DedotError(`Unable to fetch runtime version for block ${hash}: ${error}`);
+                }
+            }
+            else {
+                throw new DedotError('Block is not pinned and Archive JSON-RPC is not supported by the server/node!');
+            }
         }
         let metadata = this.metadata;
         let registry = this.registry;

package/client/LegacyClient.d.ts

@@ -1,6 +1,6 @@
 import { BlockHash } from '@dedot/codecs';
 import type { JsonRpcProvider } from '@dedot/providers';
-import { GenericSubstrateApi, RpcLegacy, RpcVersion, VersionedGenericSubstrateApi } from '@dedot/types';
+import { GenericSubstrateApi, RpcLegacy, VersionedGenericSubstrateApi } from '@dedot/types';
 import type { SubstrateApi } from '../chaintypes/index.js';
 import { BaseStorageQuery } from '../storage/index.js';
 import type { ApiOptions, ISubstrateClientAt } from '../types.js';
@@ -131,5 +131,5 @@ export declare class LegacyClient<ChainApi extends VersionedGenericSubstrateApi
      * @param hash
      */
     at<ChainApiAt extends GenericSubstrateApi = ChainApi[RpcLegacy]>(hash: BlockHash): Promise<ISubstrateClientAt<ChainApiAt>>;
-    protected getStorageQuery(): BaseStorageQuery<RpcVersion>;
+    protected getStorageQuery(): BaseStorageQuery;
 }

package/executor/Executor.d.ts

@@ -1,7 +1,7 @@
 import type { BlockHash, PalletDefLatest } from '@dedot/codecs';
 import type { GenericSubstrateApi } from '@dedot/types';
 import { HexString } from '@dedot/utils';
-import { ISubstrateClientAt } from '../types.js';
+import { ISubstrateClient, ISubstrateClientAt } from '../types.js';
 export interface StateCallParams {
     func: string;
     params: HexString;
@@ -13,10 +13,10 @@ export interface StateCallParams {
  */
 export declare abstract class Executor<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> {
     #private;
-    readonly client: ISubstrateClientAt<ChainApi>;
-    constructor(client: ISubstrateClientAt<ChainApi>, atBlockHash?: BlockHash);
-    get atBlockHash(): `0x${string}` | undefined;
-    get registry(): import("@dedot/codecs").PortableRegistry;
+    readonly client: ISubstrateClientAt<ChainApi> | ISubstrateClient<ChainApi, any>;
+    constructor(client: ISubstrateClientAt<ChainApi> | ISubstrateClient<ChainApi, any>, atBlockHash?: BlockHash);
+    get atBlockHash(): any;
+    get registry(): import("@dedot/codecs").PortableRegistry<ChainApi>;
     get metadata(): {
         types: {
             id: number;

package/executor/Executor.js

@@ -11,6 +11,7 @@ export class Executor {
         this.#atBlockHash = atBlockHash;
     }
     get atBlockHash() {
+        // @ts-ignore
         return this.#atBlockHash || this.client.atBlockHash;
     }
     get registry() {

package/executor/StorageQueryExecutor.d.ts

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

package/executor/v2/RuntimeApiExecutorV2.d.ts

@@ -2,7 +2,7 @@ import type { BlockHash } from '@dedot/codecs';
 import type { GenericSubstrateApi } from '@dedot/types';
 import { HexString } from '@dedot/utils';
 import { ChainHead } from '../../json-rpc/index.js';
-import { ISubstrateClientAt } from '../../types.js';
+import { ISubstrateClient, ISubstrateClientAt } from '../../types.js';
 import { StateCallParams } from '../Executor.js';
 import { RuntimeApiExecutor } from '../RuntimeApiExecutor.js';
 /**
@@ -10,6 +10,6 @@ import { RuntimeApiExecutor } from '../RuntimeApiExecutor.js';
  */
 export declare class RuntimeApiExecutorV2<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> extends RuntimeApiExecutor<ChainApi> {
     chainHead: ChainHead;
-    constructor(client: ISubstrateClientAt<ChainApi>, chainHead: ChainHead, atBlockHash?: BlockHash);
+    constructor(client: ISubstrateClientAt<ChainApi> | ISubstrateClient<ChainApi, any>, chainHead: ChainHead, atBlockHash?: BlockHash);
     protected stateCall(callParams: StateCallParams): Promise<HexString>;
 }

package/executor/v2/StorageQueryExecutorV2.d.ts

@@ -1,15 +1,15 @@
 import { BlockHash } from '@dedot/codecs';
-import type { AsyncMethod, GenericSubstrateApi, RpcVersion } from '@dedot/types';
+import type { AsyncMethod, GenericSubstrateApi } from '@dedot/types';
 import { ChainHead } from '../../json-rpc/index.js';
 import { type BaseStorageQuery, QueryableStorage } from '../../storage/index.js';
-import { ISubstrateClientAt } from '../../types.js';
+import { ISubstrateClient, ISubstrateClientAt } from '../../types.js';
 import { StorageQueryExecutor } from '../StorageQueryExecutor.js';
 /**
  * @name StorageQueryExecutorV2
  */
 export declare class StorageQueryExecutorV2<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> extends StorageQueryExecutor<ChainApi> {
     chainHead: ChainHead;
-    constructor(client: ISubstrateClientAt<ChainApi>, chainHead: ChainHead, atBlockHash?: BlockHash);
+    constructor(client: ISubstrateClientAt<ChainApi> | ISubstrateClient<ChainApi, any>, chainHead: ChainHead, atBlockHash?: BlockHash);
     protected exposeStorageMapMethods(entry: QueryableStorage): Record<string, AsyncMethod>;
-    protected getStorageQuery(): BaseStorageQuery<RpcVersion>;
+    protected getStorageQuery(): BaseStorageQuery;
 }

package/executor/v2/StorageQueryExecutorV2.js

@@ -19,9 +19,7 @@ export class StorageQueryExecutorV2 extends StorageQueryExecutor {
         const entries = async (...args) => {
             const withArgs = !!args && args.length > 0;
             const key = withArgs ? entry.encodeKey(args, true) : entry.prefixKey;
-            const results = await this.chainHead.storage([
-                { type: 'descendantsValues', key },
-            ]);
+            const results = await this.chainHead.storage([{ type: 'descendantsValues', key }]);
             return results.map(({ key, value }) => [
                 entry.decodeKey(key),
                 entry.decodeValue(value),

package/executor/v2/TxExecutorV2.d.ts

@@ -6,6 +6,7 @@ import { TxExecutor } from '../TxExecutor.js';
  * @description Execute a transaction instruction, returns a submittable extrinsic
  */
 export declare class TxExecutorV2<ChainApi extends VersionedGenericSubstrateApi = VersionedGenericSubstrateApi> extends TxExecutor<ChainApi[RpcVersion]> {
-    constructor(api: DedotClient<ChainApi>);
+    readonly client: DedotClient<ChainApi>;
+    constructor(client: DedotClient<ChainApi>);
     protected createExtrinsic(call: IRuntimeTxCall): any;
 }

package/executor/v2/TxExecutorV2.js

@@ -6,9 +6,11 @@ import { TxExecutor } from '../TxExecutor.js';
  * @description Execute a transaction instruction, returns a submittable extrinsic
  */
 export class TxExecutorV2 extends TxExecutor {
-    constructor(api) {
-        assert(api.rpcVersion === 'v2', 'Only supports JSON-RPC v2');
-        super(api);
+    client;
+    constructor(client) {
+        assert(client.rpcVersion === 'v2', 'Only supports JSON-RPC v2');
+        super(client);
+        this.client = client;
     }
     createExtrinsic(call) {
         return new SubmittableExtrinsicV2(this.client, call);

package/executor/v2/ViewFunctionExecutorV2.d.ts

@@ -1,7 +1,7 @@
 import type { GenericSubstrateApi } from '@dedot/types';
 import { HexString } from '@dedot/utils';
 import { ChainHead } from '../../json-rpc/index.js';
-import { ISubstrateClientAt } from '../../types.js';
+import { ISubstrateClient, ISubstrateClientAt } from '../../types.js';
 import { StateCallParams } from '../Executor.js';
 import { ViewFunctionExecutor } from '../ViewFunctionExecutor.js';
 /**
@@ -9,6 +9,6 @@ import { ViewFunctionExecutor } from '../ViewFunctionExecutor.js';
  */
 export declare class ViewFunctionExecutorV2<ChainApi extends GenericSubstrateApi = GenericSubstrateApi> extends ViewFunctionExecutor<ChainApi> {
     chainHead: ChainHead;
-    constructor(client: ISubstrateClientAt<ChainApi>, chainHead: ChainHead);
+    constructor(client: ISubstrateClientAt<ChainApi> | ISubstrateClient<ChainApi, any>, chainHead: ChainHead);
     protected stateCall(callParams: StateCallParams): Promise<HexString>;
 }

package/extrinsic/extensions/SignedExtension.d.ts

@@ -19,17 +19,17 @@ interface SignedExtensionOptions {
     payloadOptions?: Partial<PayloadOptions>;
 }
 export declare abstract class SignedExtension<Data extends any = {}, AdditionalSigned extends any = []> implements ISignedExtension {
-    readonly client: ISubstrateClient;
+    readonly client: ISubstrateClient<any, any>;
     readonly options?: SignedExtensionOptions | undefined;
     data: Data;
     additionalSigned: AdditionalSigned;
-    constructor(client: ISubstrateClient, options?: SignedExtensionOptions | undefined);
+    constructor(client: ISubstrateClient<any, any>, options?: SignedExtensionOptions | undefined);
     init(): Promise<void>;
     fromPayload(payload: SignerPayloadJSON): Promise<void>;
     get identifier(): string;
     get $Data(): $.AnyShape;
     get $AdditionalSigned(): $.AnyShape;
-    get registry(): PortableRegistry;
+    get registry(): PortableRegistry<any>;
     get signedExtensionDef(): {
         ident: string;
         typeId: number;

package/extrinsic/submittable/BaseSubmittableExtrinsic.d.ts

@@ -9,8 +9,8 @@ interface TxHooks {
 }
 export declare abstract class BaseSubmittableExtrinsic extends Extrinsic implements ISubmittableExtrinsic {
     #private;
-    readonly client: ISubstrateClient;
-    constructor(client: ISubstrateClient, call: IRuntimeTxCall);
+    readonly client: ISubstrateClient<any>;
+    constructor(client: ISubstrateClient<any>, call: IRuntimeTxCall);
     withHooks(hooks: TxHooks): void;
     protected transformTxResult<R extends ISubmittableResult = ISubmittableResult>(result: ISubmittableResult): R;
     paymentInfo(account: AddressOrPair, options?: Partial<PayloadOptions>): Promise<TxPaymentInfo>;

package/extrinsic/submittable/SubmittableExtrinsicV2.d.ts

@@ -7,8 +7,8 @@ import { BaseSubmittableExtrinsic } from './BaseSubmittableExtrinsic.js';
  */
 export declare class SubmittableExtrinsicV2 extends BaseSubmittableExtrinsic {
     #private;
-    client: DedotClient;
-    constructor(client: DedotClient, call: IRuntimeTxCall);
+    client: DedotClient<any>;
+    constructor(client: DedotClient<any>, call: IRuntimeTxCall);
     send(): TxHash;
     send(callback: Callback): TxUnsub;
 }

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

@@ -0,0 +1,134 @@
+import { BlockHash, Option } from '@dedot/codecs';
+import { ArchiveStorageResult, PaginatedStorageQuery } from '@dedot/types/json-rpc';
+import { HexString } from '@dedot/utils';
+import { IJsonRpcClient } from '../../types.js';
+import { JsonRpcGroup, JsonRpcGroupOptions } 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 declare class Archive extends JsonRpcGroup {
+    #private;
+    constructor(client: IJsonRpcClient, options?: Partial<JsonRpcGroupOptions>);
+    /**
+     * 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...');
+     * ```
+     */
+    body(hash?: BlockHash): Promise<Option<Array<HexString>>>;
+    /**
+     * 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
+     */
+    genesisHash(): Promise<HexString>;
+    /**
+     * 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...');
+     * ```
+     */
+    header(hash?: BlockHash): Promise<Option<HexString>>;
+    /**
+     * 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
+     */
+    finalizedHeight(): Promise<number>;
+    /**
+     * 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
+     */
+    finalizedHash(): Promise<HexString>;
+    /**
+     * 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
+     */
+    hashByHeight(height: number): Promise<Array<HexString>>;
+    /**
+     * 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...');
+     * ```
+     */
+    call(func: string, params: HexString, hash?: BlockHash): Promise<HexString>;
+    /**
+     * 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...');
+     * ```
+     */
+    storage(items: Array<PaginatedStorageQuery>, childTrie?: HexString | null, hash?: BlockHash): Promise<ArchiveStorageResult>;
+    /**
+     * 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(): void;
+}