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

package/chaintypes/substrate/index.d.ts

@@ -1,4 +1,5 @@
-import type { GenericSubstrateApi, RpcLegacy, RpcV2, RpcVersion } from '@dedot/types';
+import type { MultiAddress } from '@dedot/codecs';
+import type { GenericChainKnownTypes, GenericSubstrateApi, RpcLegacy, RpcV2, RpcVersion } from '@dedot/types';
 import { ChainConsts } from './consts.js';
 import { ChainErrors } from './errors.js';
 import { ChainEvents } from './events.js';
@@ -6,8 +7,26 @@ import { ChainJsonRpcApis } from './json-rpc.js';
 import { ChainStorage } from './query.js';
 import { RuntimeApis } from './runtime.js';
 import { ChainTx } from './tx.js';
+import type { FrameMetadataHashExtensionCheckMetadataHash, FrameSystemExtensionsCheckGenesis, FrameSystemExtensionsCheckMortality, FrameSystemExtensionsCheckNonZeroSender, FrameSystemExtensionsCheckNonce, FrameSystemExtensionsCheckSpecVersion, FrameSystemExtensionsCheckTxVersion, FrameSystemExtensionsCheckWeight, FrameSystemExtensionsWeightReclaim, KitchensinkRuntimeRuntimeCall, PalletAssetConversionTxPaymentChargeAssetTxPayment, SpRuntimeMultiSignature } from './types.js';
 import { ChainViewFunctions } from './view-functions.js';
 export * from './types.js';
+interface ChainKnownTypes extends GenericChainKnownTypes {
+    Address: MultiAddress;
+    Signature: SpRuntimeMultiSignature;
+    RuntimeCall: KitchensinkRuntimeRuntimeCall;
+    Extra: [
+        FrameSystemExtensionsCheckNonZeroSender,
+        FrameSystemExtensionsCheckSpecVersion,
+        FrameSystemExtensionsCheckTxVersion,
+        FrameSystemExtensionsCheckGenesis,
+        FrameSystemExtensionsCheckMortality,
+        FrameSystemExtensionsCheckNonce,
+        FrameSystemExtensionsCheckWeight,
+        PalletAssetConversionTxPaymentChargeAssetTxPayment,
+        FrameMetadataHashExtensionCheckMetadataHash,
+        FrameSystemExtensionsWeightReclaim
+    ];
+}
 export interface VersionedSubstrateApi<Rv extends RpcVersion> extends GenericSubstrateApi<Rv> {
     rpc: ChainJsonRpcApis<Rv>;
     consts: ChainConsts<Rv>;
@@ -17,6 +36,7 @@ export interface VersionedSubstrateApi<Rv extends RpcVersion> extends GenericSub
     call: RuntimeApis<Rv>;
     view: ChainViewFunctions<Rv>;
     tx: ChainTx<Rv>;
+    types: ChainKnownTypes;
 }
 /**
  * @name: SubstrateApi

package/chaintypes/substrate/index.js

@@ -1,2 +1 @@
-// Generated by dedot cli
 export * from './types.js';

package/cjs/chaintypes/substrate/index.js

@@ -1,5 +1,4 @@
 "use strict";
-// Generated by dedot cli
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);

package/cjs/client/DedotClient.js

@@ -19,6 +19,7 @@ class DedotClient// prettier-end-here
  extends BaseSubstrateClient_js_1.BaseSubstrateClient {
     _chainHead;
     _chainSpec;
+    _archive;
     _txBroadcaster;
     #apiAtCache = {};
     /**
@@ -51,6 +52,11 @@ class DedotClient// prettier-end-here
     get chainHead() {
         return (0, BaseSubstrateClient_js_1.ensurePresence)(this._chainHead);
     }
+    async archive() {
+        (0, utils_1.assert)(this._archive, 'Archive instance is not initialized');
+        (0, utils_1.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
         (0, utils_1.assert)(this._txBroadcaster, 'JSON-RPC method to broadcast transactions is not supported by the server/node.');
@@ -71,6 +77,12 @@ class DedotClient// prettier-end-here
         const rpcMethods = (await this.rpc.rpc_methods()).methods;
         this._chainHead = new index_js_2.ChainHead(this, { rpcMethods });
         this._chainSpec = new index_js_2.ChainSpec(this, { rpcMethods });
+        // Always initialize Archive, but only set up fallback if supported
+        this._archive = new index_js_2.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([
@@ -133,6 +145,7 @@ class DedotClient// prettier-end-here
         super.cleanUp();
         this._chainHead = undefined;
         this._chainSpec = undefined;
+        this._archive = undefined;
         this._txBroadcaster = undefined;
         this.#apiAtCache = {};
     }
@@ -159,19 +172,39 @@ 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);
-        (0, utils_1.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(codecs_1.$RuntimeVersion.tryDecode(runtimeRaw));
+                }
+                catch (error) {
+                    throw new utils_1.DedotError(`Unable to fetch runtime version for block ${hash}: ${error}`);
+                }
+            }
+            else {
+                throw new utils_1.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/cjs/executor/Executor.js

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

package/cjs/executor/v2/StorageQueryExecutorV2.js

@@ -22,9 +22,7 @@ class StorageQueryExecutorV2 extends StorageQueryExecutor_js_1.StorageQueryExecu
         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/cjs/executor/v2/TxExecutorV2.js

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

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

@@ -0,0 +1,226 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Archive = void 0;
+const utils_1 = require("@dedot/utils");
+const JsonRpcGroup_js_1 = require("./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
+ */
+class Archive extends JsonRpcGroup_js_1.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 utils_1.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 utils_1.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();
+    }
+}
+exports.Archive = Archive;

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

@@ -23,6 +23,17 @@ class ChainHead extends JsonRpcGroup_js_1.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 = {};
@@ -36,6 +47,18 @@ class ChainHead extends JsonRpcGroup_js_1.JsonRpcGroup {
         // This helps us to not accidentally putting too much stress on the JSON-RPC server, especially smoldot/light-client
         this.#operationQueue = new utils_1.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;
@@ -344,11 +367,39 @@ class ChainHead extends JsonRpcGroup_js_1.JsonRpcGroup {
                 return hash;
             }
             else {
-                throw new error_js_1.ChainHeadBlockNotPinnedError(`Block hash ${hash} is not pinned`);
+                throw new error_js_1.ChainHeadBlockNotPinnedError(`Block hash ${hash} is not pinned`, hash);
             }
         }
         return (0, utils_1.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 error_js_1.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)
@@ -478,21 +529,31 @@ class ChainHead extends JsonRpcGroup_js_1.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 error_js_1.ChainHeadOperationError(`Block ${hash} not found in Archive`);
+            }
+            return result;
+        };
+        try {
+            return await this.#tryWithArchive(operation, fallback);
         }
         catch (e) {
             if (e instanceof error_js_1.ChainHeadBlockPrunedError && shouldRetryOnPrunedBlock) {
@@ -507,21 +568,25 @@ class ChainHead extends JsonRpcGroup_js_1.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 error_js_1.ChainHeadBlockPrunedError && shouldRetryOnPrunedBlock) {
@@ -535,14 +600,18 @@ class ChainHead extends JsonRpcGroup_js_1.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);
@@ -553,35 +622,46 @@ class ChainHead extends JsonRpcGroup_js_1.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 error_js_1.ChainHeadBlockPrunedError && shouldRetryOnPrunedBlock) {
@@ -589,9 +669,6 @@ class ChainHead extends JsonRpcGroup_js_1.JsonRpcGroup {
             }
             throw e;
         }
-        finally {
-            this.#blockUsage.release(hash);
-        }
     }
     async #getStorage(items, childTrie, at) {
         const operation = () => this.#getStorageOperation(items, childTrie, this.#ensurePinnedHash(at));

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

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