@acala-network/chopsticks-core 1.2.0 → 1.2.1

package/dist/cjs/rpc/rpc-spec/archive_v1.d.ts

@@ -0,0 +1,74 @@
+import type { HexString } from '@polkadot/util/types';
+import { type Handler } from '../shared.js';
+import type { StorageItemRequest } from './chainHead_v1.js';
+/**
+ * Retrieve the body of a specific block
+ *
+ * @param context
+ * @param params - [`hash`]
+ *
+ * @return An array of the SCALE-encoded transactions of a block, or `null` if the block is not found.
+ */
+export declare const archive_v1_body: Handler<[HexString], HexString[] | null>;
+export type CallResult = {
+    success: true;
+    value: HexString;
+} | {
+    success: false;
+    error: any;
+};
+export declare const archive_v1_call: Handler<[HexString, string, HexString], CallResult | null>;
+/**
+ * Retrieve the height of the finalized block.
+ *
+ * @param context
+ *
+ * @return The `number` of the height of the head (a.k.a. finalized) block.
+ */
+export declare const archive_v1_finalizedHeight: Handler<undefined, number>;
+/**
+ * Retrieve the genesis hash
+ *
+ * @param context
+ *
+ * @return An {@link HexString} with the hash of the genesis block.
+ */
+export declare const archive_v1_genesisHash: Handler<undefined, HexString>;
+/**
+ * Retrieve the hash of a specific height
+ *
+ * @param context
+ * @param params - [`height`]
+ *
+ * @return An array of {@link HexString} with the hashes of the blocks associated to the
+ * given height.
+ */
+export declare const archive_v1_hashByHeight: Handler<[number], HexString[]>;
+/**
+ * Retrieve the header for a specific block
+ *
+ * @param context
+ * @param params - [`hash`]
+ *
+ * @return SCALE-encoded header, or `null` if the block is not found.
+ */
+export declare const archive_v1_header: Handler<[HexString], HexString | null>;
+/**
+ * Query the storage for a given block
+ *
+ * @param context
+ * @param params - [`hash`, `items`, `childTrie`]
+ *
+ * @return the operationId to capture the notifications where to receive the result
+ *
+ * The query type `closestDescendantMerkleValue` is not up to spec.
+ * According to the spec, the result should be the Merkle value of the key or
+ * the closest descendant of the key.
+ * As chopsticks doesn't have direct access to the Merkle tree, it will return
+ * a string that will change every time that one of the descendant changes, but
+ * it won't be the actual Merkle value.
+ * This should be enough for applications that don't rely on the actual Merkle
+ * value, but just use it to detect for storage changes.
+ */
+export declare const archive_v1_storage: Handler<[HexString, StorageItemRequest[], HexString | null], string>;
+export declare const archive_v1_stopStorage: Handler<[string], null>;

package/dist/cjs/rpc/rpc-spec/archive_v1.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get archive_v1_body () {
+        return archive_v1_body;
+    },
+    get archive_v1_call () {
+        return archive_v1_call;
+    },
+    get archive_v1_finalizedHeight () {
+        return archive_v1_finalizedHeight;
+    },
+    get archive_v1_genesisHash () {
+        return archive_v1_genesisHash;
+    },
+    get archive_v1_hashByHeight () {
+        return archive_v1_hashByHeight;
+    },
+    get archive_v1_header () {
+        return archive_v1_header;
+    },
+    get archive_v1_stopStorage () {
+        return archive_v1_stopStorage;
+    },
+    get archive_v1_storage () {
+        return archive_v1_storage;
+    }
+});
+const _utilcrypto = require("@polkadot/util-crypto");
+const _headstate = require("../../blockchain/head-state.js");
+const _shared = require("../shared.js");
+const _archive = require("../substrate/archive.js");
+const _storagecommon = require("./storage-common.js");
+const archive_v1_body = async (...args)=>(0, _archive.archive_unstable_body)(...args).catch(()=>null);
+/**
+ * Perform a runtime call for a block
+ *
+ * @param context
+ * @param params - [`hash`, `function`, `callParameters`]
+ *
+ * @return A {@link CallResult} with the result of the runtime call, or `null` if the block
+ * is not found.
+ */ function isBlockNotFound(error) {
+    return error instanceof _shared.ResponseError && error.code === 1;
+}
+const archive_v1_call = async (...args)=>_archive.archive_unstable_call.call(undefined, ...args).then(({ value })=>({
+            success: true,
+            value
+        }), (error)=>isBlockNotFound(error) ? null : {
+            success: false,
+            error
+        });
+const archive_v1_finalizedHeight = (context)=>{
+    return Promise.resolve(context.chain.head.number);
+};
+const archive_v1_genesisHash = async (context)=>{
+    const genesisBlock = await context.chain.getBlockAt(0);
+    return genesisBlock.hash;
+};
+const archive_v1_hashByHeight = async (context, [height])=>{
+    const block = await context.chain.getBlockAt(height);
+    return block ? [
+        block.hash
+    ] : [];
+};
+const archive_v1_header = async (context, [hash])=>{
+    const block = await context.chain.getBlock(hash);
+    return block ? (await block.header).toHex() : null;
+};
+/**
+ * Contains the storage operations.
+ */ const storageOperations = new Map();
+const archive_v1_storage = async (context, [hash, items, _childTrie], { subscribe })=>{
+    const operationId = (0, _headstate.randomId)();
+    const callback = subscribe('chainHead_v1_storageEvent', operationId, ()=>storageOperations.delete(operationId));
+    storageOperations.set(operationId, {
+        callback,
+        hash,
+        params: [],
+        storageDiffs: new Map()
+    });
+    (0, _storagecommon.afterResponse)(async ()=>{
+        const block = await context.chain.getBlock(hash);
+        if (!block) {
+            storageOperations.get(operationId)?.callback({
+                event: 'storageError',
+                operationId,
+                error: 'Block not found'
+            });
+            return;
+        }
+        const handleStorageItemRequest = async (sir)=>{
+            switch(sir.type){
+                case 'value':
+                    {
+                        const value = await block.get(sir.key);
+                        if (value) {
+                            storageOperations.get(operationId)?.callback({
+                                event: 'storage',
+                                key: sir.key,
+                                value
+                            });
+                        }
+                        return null;
+                    }
+                case 'hash':
+                    {
+                        const value = await block.get(sir.key);
+                        if (value) {
+                            storageOperations.get(operationId)?.callback({
+                                event: 'storage',
+                                key: sir.key,
+                                hash
+                            });
+                        }
+                        return null;
+                    }
+                case 'descendantsValues':
+                    {
+                        let items;
+                        let next = {
+                            prefix: sir.key,
+                            startKey: '0x'
+                        };
+                        do {
+                            ;
+                            ({ items, next } = await (0, _storagecommon.getDescendantValues)(block, next));
+                            for (const { key, value } of items){
+                                storageOperations.get(operationId)?.callback({
+                                    event: 'storage',
+                                    key,
+                                    value
+                                });
+                            }
+                        }while (next !== null)
+                        return null;
+                    }
+                case 'descendantsHashes':
+                    {
+                        let items;
+                        let next = {
+                            prefix: sir.key,
+                            startKey: '0x'
+                        };
+                        do {
+                            ;
+                            ({ items, next } = await (0, _storagecommon.getDescendantValues)(block, next));
+                            for (const { key, value } of items){
+                                if (value === undefined) {
+                                    continue;
+                                }
+                                storageOperations.get(operationId)?.callback({
+                                    event: 'storage',
+                                    key,
+                                    hash: (0, _utilcrypto.blake2AsHex)(value)
+                                });
+                            }
+                        }while (next !== null)
+                        return null;
+                    }
+                case 'closestDescendantMerkleValue':
+                    {
+                        const subscription = storageOperations.get(operationId);
+                        if (!subscription) return null;
+                        if (!subscription.storageDiffs.has(sir.key)) {
+                            // Set up a diff watch for this key
+                            subscription.storageDiffs.set(sir.key, 0);
+                        }
+                        subscription.callback({
+                            event: 'storage',
+                            operationId,
+                            items: [
+                                {
+                                    key: sir.key,
+                                    closestDescendantMerkleValue: String(subscription.storageDiffs.get(sir.key))
+                                }
+                            ]
+                        });
+                        return null;
+                    }
+            }
+        };
+        await Promise.all(items.map(handleStorageItemRequest));
+        storageOperations.get(operationId)?.callback({
+            event: 'storageDone'
+        });
+    });
+    return operationId;
+};
+const archive_v1_stopStorage = async (_, [operationId], { unsubscribe })=>{
+    unsubscribe(operationId);
+    return null;
+};

package/dist/cjs/rpc/rpc-spec/chainHead_v1.js

@@ -40,14 +40,11 @@ _export(exports, {
 const _utilcrypto = require("@polkadot/util-crypto");
 const _logger = require("../../logger.js");
 const _shared = require("../shared.js");
+const _storagecommon = require("./storage-common.js");
 const logger = _logger.defaultLogger.child({
     name: 'rpc-chainHead_v1'
 });
 const following = new Map();
-async function afterResponse(fn) {
-    await new Promise((resolve)=>setTimeout(resolve, 0));
-    fn();
-}
 const chainHead_v1_follow = async (context, [withRuntime], { subscribe })=>{
     const update = async (block)=>{
         logger.trace({
@@ -101,7 +98,7 @@ const chainHead_v1_follow = async (context, [withRuntime], { subscribe })=>{
         pendingDescendantValues: new Map(),
         storageDiffs: new Map()
     });
-    afterResponse(async ()=>{
+    (0, _storagecommon.afterResponse)(async ()=>{
         callback({
             event: 'initialized',
             finalizedBlockHashes: [
@@ -128,7 +125,7 @@ const operationStarted = (operationId)=>({
 const randomId = ()=>Math.random().toString(36).substring(2);
 const chainHead_v1_call = async (context, [followSubscription, hash, method, callParameters])=>{
     const operationId = randomId();
-    afterResponse(async ()=>{
+    (0, _storagecommon.afterResponse)(async ()=>{
         const block = await context.chain.getBlock(hash);
         if (!block) {
             following.get(followSubscription)?.callback({
@@ -157,33 +154,9 @@ const chainHead_v1_call = async (context, [followSubscription, hash, method, cal
     });
     return operationStarted(operationId);
 };
-const PAGE_SIZE = 1000;
-async function getDescendantValues(block, params) {
-    const keys = await block.getKeysPaged({
-        ...params,
-        pageSize: PAGE_SIZE
-    });
-    const items = await Promise.all(keys.map((key)=>block.get(key).then((value)=>({
-                key,
-                value
-            }))));
-    if (keys.length < PAGE_SIZE) {
-        return {
-            items,
-            next: null
-        };
-    }
-    return {
-        items,
-        next: {
-            ...params,
-            startKey: keys[PAGE_SIZE - 1]
-        }
-    };
-}
 const chainHead_v1_storage = async (context, [followSubscription, hash, items, _childTrie])=>{
     const operationId = randomId();
-    afterResponse(async ()=>{
+    (0, _storagecommon.afterResponse)(async ()=>{
         const block = await context.chain.getBlock(hash);
         if (!block) {
             following.get(followSubscription)?.callback({
@@ -231,7 +204,7 @@ const chainHead_v1_storage = async (context, [followSubscription, hash, items, _
                     }
                 case 'descendantsValues':
                     {
-                        const { items, next } = await getDescendantValues(block, {
+                        const { items, next } = await (0, _storagecommon.getDescendantValues)(block, {
                             prefix: sir.key,
                             startKey: '0x'
                         });
@@ -244,7 +217,7 @@ const chainHead_v1_storage = async (context, [followSubscription, hash, items, _
                     }
                 case 'descendantsHashes':
                     {
-                        const { items, next } = await getDescendantValues(block, {
+                        const { items, next } = await (0, _storagecommon.getDescendantValues)(block, {
                             prefix: sir.key,
                             startKey: '0x'
                         });
@@ -319,7 +292,7 @@ const chainHead_v1_body = async (context, [followSubscription, hash])=>{
         throw new _shared.ResponseError(-32801, 'Block not found');
     }
     const operationId = randomId();
-    afterResponse(async ()=>{
+    (0, _storagecommon.afterResponse)(async ()=>{
         const body = await block.extrinsics;
         following.get(followSubscription)?.callback({
             event: 'operationBodyDone',
@@ -339,9 +312,9 @@ const chainHead_v1_continue = async (context, [followSubscription, operationId])
     if (!block) {
         throw new _shared.ResponseError(-32801, 'Block not found');
     }
-    afterResponse(async ()=>{
+    (0, _storagecommon.afterResponse)(async ()=>{
         const handlePendingOperation = async (params)=>{
-            const { items, next } = await getDescendantValues(block, params);
+            const { items, next } = await (0, _storagecommon.getDescendantValues)(block, params);
             follower.callback({
                 event: 'operationStorageItems',
                 operationId,

package/dist/cjs/rpc/rpc-spec/index.d.ts

@@ -1,3 +1,4 @@
+import * as ArchiveV1RPC from './archive_v1.js';
 import * as ChainHeadV1RPC from './chainHead_v1.js';
 import * as ChainSpecV1RPC from './chainSpec_v1.js';
 import * as TransactionV1RPC from './transaction_v1.js';
@@ -23,5 +24,13 @@ declare const handlers: {
     chainHead_v1_continue: import("../shared.js").Handler<[string, import("@polkadot/util/types").HexString], null>;
     chainHead_v1_stopOperation: import("../shared.js").Handler<[string, import("@polkadot/util/types").HexString], null>;
     chainHead_v1_unpin: import("../shared.js").Handler<[string, import("@polkadot/util/types").HexString | import("@polkadot/util/types").HexString[]], null>;
+    archive_v1_body: import("../shared.js").Handler<[import("@polkadot/util/types").HexString], import("@polkadot/util/types").HexString[] | null>;
+    archive_v1_call: import("../shared.js").Handler<[import("@polkadot/util/types").HexString, string, import("@polkadot/util/types").HexString], ArchiveV1RPC.CallResult | null>;
+    archive_v1_finalizedHeight: import("../shared.js").Handler<undefined, number>;
+    archive_v1_genesisHash: import("../shared.js").Handler<undefined, import("@polkadot/util/types").HexString>;
+    archive_v1_hashByHeight: import("../shared.js").Handler<[number], import("@polkadot/util/types").HexString[]>;
+    archive_v1_header: import("../shared.js").Handler<[import("@polkadot/util/types").HexString], import("@polkadot/util/types").HexString | null>;
+    archive_v1_storage: import("../shared.js").Handler<[import("@polkadot/util/types").HexString, ChainHeadV1RPC.StorageItemRequest[], import("@polkadot/util/types").HexString | null], string>;
+    archive_v1_stopStorage: import("../shared.js").Handler<[string], null>;
 };
 export default handlers;

package/dist/cjs/rpc/rpc-spec/index.js

@@ -22,6 +22,7 @@ _export(exports, {
         return _default;
     }
 });
+const _archive_v1 = /*#__PURE__*/ _interop_require_wildcard(require("./archive_v1.js"));
 const _chainHead_v1 = /*#__PURE__*/ _interop_require_wildcard(require("./chainHead_v1.js"));
 const _chainSpec_v1 = /*#__PURE__*/ _interop_require_wildcard(require("./chainSpec_v1.js"));
 const _transaction_v1 = /*#__PURE__*/ _interop_require_wildcard(require("./transaction_v1.js"));
@@ -67,6 +68,7 @@ function _interop_require_wildcard(obj, nodeInterop) {
     return newObj;
 }
 const handlers = {
+    ..._archive_v1,
     ..._chainHead_v1,
     ..._transaction_v1,
     ..._chainSpec_v1

package/dist/cjs/rpc/rpc-spec/storage-common.d.ts

@@ -0,0 +1,16 @@
+import type { HexString } from '@polkadot/util/types';
+import type { Block } from '../../blockchain/block.js';
+export declare function getDescendantValues(block: Block, params: DescendantValuesParams): Promise<{
+    items: Array<{
+        key: string;
+        value?: HexString;
+    }>;
+    next: DescendantValuesParams | null;
+}>;
+export declare const PAGE_SIZE = 1000;
+export type DescendantValuesParams = {
+    prefix: string;
+    startKey: string;
+    isDescendantHashes?: boolean;
+};
+export declare function afterResponse(fn: () => void): Promise<void>;

package/dist/cjs/rpc/rpc-spec/storage-common.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get PAGE_SIZE () {
+        return PAGE_SIZE;
+    },
+    get afterResponse () {
+        return afterResponse;
+    },
+    get getDescendantValues () {
+        return getDescendantValues;
+    }
+});
+async function getDescendantValues(block, params) {
+    const keys = await block.getKeysPaged({
+        ...params,
+        pageSize: PAGE_SIZE
+    });
+    const items = await Promise.all(keys.map((key)=>block.get(key).then((value)=>({
+                key,
+                value
+            }))));
+    if (keys.length < PAGE_SIZE) {
+        return {
+            items,
+            next: null
+        };
+    }
+    return {
+        items,
+        next: {
+            ...params,
+            startKey: keys[PAGE_SIZE - 1]
+        }
+    };
+}
+const PAGE_SIZE = 1000;
+async function afterResponse(fn) {
+    await new Promise((resolve)=>setTimeout(resolve, 0));
+    fn();
+}

package/dist/esm/rpc/rpc-spec/archive_v1.d.ts

@@ -0,0 +1,74 @@
+import type { HexString } from '@polkadot/util/types';
+import { type Handler } from '../shared.js';
+import type { StorageItemRequest } from './chainHead_v1.js';
+/**
+ * Retrieve the body of a specific block
+ *
+ * @param context
+ * @param params - [`hash`]
+ *
+ * @return An array of the SCALE-encoded transactions of a block, or `null` if the block is not found.
+ */
+export declare const archive_v1_body: Handler<[HexString], HexString[] | null>;
+export type CallResult = {
+    success: true;
+    value: HexString;
+} | {
+    success: false;
+    error: any;
+};
+export declare const archive_v1_call: Handler<[HexString, string, HexString], CallResult | null>;
+/**
+ * Retrieve the height of the finalized block.
+ *
+ * @param context
+ *
+ * @return The `number` of the height of the head (a.k.a. finalized) block.
+ */
+export declare const archive_v1_finalizedHeight: Handler<undefined, number>;
+/**
+ * Retrieve the genesis hash
+ *
+ * @param context
+ *
+ * @return An {@link HexString} with the hash of the genesis block.
+ */
+export declare const archive_v1_genesisHash: Handler<undefined, HexString>;
+/**
+ * Retrieve the hash of a specific height
+ *
+ * @param context
+ * @param params - [`height`]
+ *
+ * @return An array of {@link HexString} with the hashes of the blocks associated to the
+ * given height.
+ */
+export declare const archive_v1_hashByHeight: Handler<[number], HexString[]>;
+/**
+ * Retrieve the header for a specific block
+ *
+ * @param context
+ * @param params - [`hash`]
+ *
+ * @return SCALE-encoded header, or `null` if the block is not found.
+ */
+export declare const archive_v1_header: Handler<[HexString], HexString | null>;
+/**
+ * Query the storage for a given block
+ *
+ * @param context
+ * @param params - [`hash`, `items`, `childTrie`]
+ *
+ * @return the operationId to capture the notifications where to receive the result
+ *
+ * The query type `closestDescendantMerkleValue` is not up to spec.
+ * According to the spec, the result should be the Merkle value of the key or
+ * the closest descendant of the key.
+ * As chopsticks doesn't have direct access to the Merkle tree, it will return
+ * a string that will change every time that one of the descendant changes, but
+ * it won't be the actual Merkle value.
+ * This should be enough for applications that don't rely on the actual Merkle
+ * value, but just use it to detect for storage changes.
+ */
+export declare const archive_v1_storage: Handler<[HexString, StorageItemRequest[], HexString | null], string>;
+export declare const archive_v1_stopStorage: Handler<[string], null>;

package/dist/esm/rpc/rpc-spec/archive_v1.js

@@ -0,0 +1,215 @@
+import { blake2AsHex } from '@polkadot/util-crypto';
+import { randomId } from '../../blockchain/head-state.js';
+import { ResponseError } from '../shared.js';
+import { archive_unstable_body, archive_unstable_call } from '../substrate/archive.js';
+import { afterResponse, getDescendantValues } from './storage-common.js';
+/**
+ * Retrieve the body of a specific block
+ *
+ * @param context
+ * @param params - [`hash`]
+ *
+ * @return An array of the SCALE-encoded transactions of a block, or `null` if the block is not found.
+ */ export const archive_v1_body = async (...args)=>archive_unstable_body(...args).catch(()=>null);
+/**
+ * Perform a runtime call for a block
+ *
+ * @param context
+ * @param params - [`hash`, `function`, `callParameters`]
+ *
+ * @return A {@link CallResult} with the result of the runtime call, or `null` if the block
+ * is not found.
+ */ function isBlockNotFound(error) {
+    return error instanceof ResponseError && error.code === 1;
+}
+export const archive_v1_call = async (...args)=>archive_unstable_call.call(undefined, ...args).then(({ value })=>({
+            success: true,
+            value
+        }), (error)=>isBlockNotFound(error) ? null : {
+            success: false,
+            error
+        });
+/**
+ * Retrieve the height of the finalized block.
+ *
+ * @param context
+ *
+ * @return The `number` of the height of the head (a.k.a. finalized) block.
+ */ export const archive_v1_finalizedHeight = (context)=>{
+    return Promise.resolve(context.chain.head.number);
+};
+/**
+ * Retrieve the genesis hash
+ *
+ * @param context
+ *
+ * @return An {@link HexString} with the hash of the genesis block.
+ */ export const archive_v1_genesisHash = async (context)=>{
+    const genesisBlock = await context.chain.getBlockAt(0);
+    return genesisBlock.hash;
+};
+/**
+ * Retrieve the hash of a specific height
+ *
+ * @param context
+ * @param params - [`height`]
+ *
+ * @return An array of {@link HexString} with the hashes of the blocks associated to the
+ * given height.
+ */ export const archive_v1_hashByHeight = async (context, [height])=>{
+    const block = await context.chain.getBlockAt(height);
+    return block ? [
+        block.hash
+    ] : [];
+};
+/**
+ * Retrieve the header for a specific block
+ *
+ * @param context
+ * @param params - [`hash`]
+ *
+ * @return SCALE-encoded header, or `null` if the block is not found.
+ */ export const archive_v1_header = async (context, [hash])=>{
+    const block = await context.chain.getBlock(hash);
+    return block ? (await block.header).toHex() : null;
+};
+/**
+ * Contains the storage operations.
+ */ const storageOperations = new Map();
+/**
+ * Query the storage for a given block
+ *
+ * @param context
+ * @param params - [`hash`, `items`, `childTrie`]
+ *
+ * @return the operationId to capture the notifications where to receive the result
+ *
+ * The query type `closestDescendantMerkleValue` is not up to spec.
+ * According to the spec, the result should be the Merkle value of the key or
+ * the closest descendant of the key.
+ * As chopsticks doesn't have direct access to the Merkle tree, it will return
+ * a string that will change every time that one of the descendant changes, but
+ * it won't be the actual Merkle value.
+ * This should be enough for applications that don't rely on the actual Merkle
+ * value, but just use it to detect for storage changes.
+ */ export const archive_v1_storage = async (context, [hash, items, _childTrie], { subscribe })=>{
+    const operationId = randomId();
+    const callback = subscribe('chainHead_v1_storageEvent', operationId, ()=>storageOperations.delete(operationId));
+    storageOperations.set(operationId, {
+        callback,
+        hash,
+        params: [],
+        storageDiffs: new Map()
+    });
+    afterResponse(async ()=>{
+        const block = await context.chain.getBlock(hash);
+        if (!block) {
+            storageOperations.get(operationId)?.callback({
+                event: 'storageError',
+                operationId,
+                error: 'Block not found'
+            });
+            return;
+        }
+        const handleStorageItemRequest = async (sir)=>{
+            switch(sir.type){
+                case 'value':
+                    {
+                        const value = await block.get(sir.key);
+                        if (value) {
+                            storageOperations.get(operationId)?.callback({
+                                event: 'storage',
+                                key: sir.key,
+                                value
+                            });
+                        }
+                        return null;
+                    }
+                case 'hash':
+                    {
+                        const value = await block.get(sir.key);
+                        if (value) {
+                            storageOperations.get(operationId)?.callback({
+                                event: 'storage',
+                                key: sir.key,
+                                hash
+                            });
+                        }
+                        return null;
+                    }
+                case 'descendantsValues':
+                    {
+                        let items;
+                        let next = {
+                            prefix: sir.key,
+                            startKey: '0x'
+                        };
+                        do {
+                            ;
+                            ({ items, next } = await getDescendantValues(block, next));
+                            for (const { key, value } of items){
+                                storageOperations.get(operationId)?.callback({
+                                    event: 'storage',
+                                    key,
+                                    value
+                                });
+                            }
+                        }while (next !== null)
+                        return null;
+                    }
+                case 'descendantsHashes':
+                    {
+                        let items;
+                        let next = {
+                            prefix: sir.key,
+                            startKey: '0x'
+                        };
+                        do {
+                            ;
+                            ({ items, next } = await getDescendantValues(block, next));
+                            for (const { key, value } of items){
+                                if (value === undefined) {
+                                    continue;
+                                }
+                                storageOperations.get(operationId)?.callback({
+                                    event: 'storage',
+                                    key,
+                                    hash: blake2AsHex(value)
+                                });
+                            }
+                        }while (next !== null)
+                        return null;
+                    }
+                case 'closestDescendantMerkleValue':
+                    {
+                        const subscription = storageOperations.get(operationId);
+                        if (!subscription) return null;
+                        if (!subscription.storageDiffs.has(sir.key)) {
+                            // Set up a diff watch for this key
+                            subscription.storageDiffs.set(sir.key, 0);
+                        }
+                        subscription.callback({
+                            event: 'storage',
+                            operationId,
+                            items: [
+                                {
+                                    key: sir.key,
+                                    closestDescendantMerkleValue: String(subscription.storageDiffs.get(sir.key))
+                                }
+                            ]
+                        });
+                        return null;
+                    }
+            }
+        };
+        await Promise.all(items.map(handleStorageItemRequest));
+        storageOperations.get(operationId)?.callback({
+            event: 'storageDone'
+        });
+    });
+    return operationId;
+};
+export const archive_v1_stopStorage = async (_, [operationId], { unsubscribe })=>{
+    unsubscribe(operationId);
+    return null;
+};

package/dist/esm/rpc/rpc-spec/chainHead_v1.js

@@ -1,14 +1,11 @@
 import { blake2AsHex } from '@polkadot/util-crypto';
 import { defaultLogger } from '../../logger.js';
 import { ResponseError } from '../shared.js';
+import { afterResponse, getDescendantValues } from './storage-common.js';
 const logger = defaultLogger.child({
     name: 'rpc-chainHead_v1'
 });
 const following = new Map();
-async function afterResponse(fn) {
-    await new Promise((resolve)=>setTimeout(resolve, 0));
-    fn();
-}
 /**
  * Start a chainHead follow subscription
  *
@@ -146,30 +143,6 @@ const randomId = ()=>Math.random().toString(36).substring(2);
     });
     return operationStarted(operationId);
 };
-const PAGE_SIZE = 1000;
-async function getDescendantValues(block, params) {
-    const keys = await block.getKeysPaged({
-        ...params,
-        pageSize: PAGE_SIZE
-    });
-    const items = await Promise.all(keys.map((key)=>block.get(key).then((value)=>({
-                key,
-                value
-            }))));
-    if (keys.length < PAGE_SIZE) {
-        return {
-            items,
-            next: null
-        };
-    }
-    return {
-        items,
-        next: {
-            ...params,
-            startKey: keys[PAGE_SIZE - 1]
-        }
-    };
-}
 /**
  * Query the storage for a given block
  *

package/dist/esm/rpc/rpc-spec/index.d.ts

@@ -1,3 +1,4 @@
+import * as ArchiveV1RPC from './archive_v1.js';
 import * as ChainHeadV1RPC from './chainHead_v1.js';
 import * as ChainSpecV1RPC from './chainSpec_v1.js';
 import * as TransactionV1RPC from './transaction_v1.js';
@@ -23,5 +24,13 @@ declare const handlers: {
     chainHead_v1_continue: import("../shared.js").Handler<[string, import("@polkadot/util/types").HexString], null>;
     chainHead_v1_stopOperation: import("../shared.js").Handler<[string, import("@polkadot/util/types").HexString], null>;
     chainHead_v1_unpin: import("../shared.js").Handler<[string, import("@polkadot/util/types").HexString | import("@polkadot/util/types").HexString[]], null>;
+    archive_v1_body: import("../shared.js").Handler<[import("@polkadot/util/types").HexString], import("@polkadot/util/types").HexString[] | null>;
+    archive_v1_call: import("../shared.js").Handler<[import("@polkadot/util/types").HexString, string, import("@polkadot/util/types").HexString], ArchiveV1RPC.CallResult | null>;
+    archive_v1_finalizedHeight: import("../shared.js").Handler<undefined, number>;
+    archive_v1_genesisHash: import("../shared.js").Handler<undefined, import("@polkadot/util/types").HexString>;
+    archive_v1_hashByHeight: import("../shared.js").Handler<[number], import("@polkadot/util/types").HexString[]>;
+    archive_v1_header: import("../shared.js").Handler<[import("@polkadot/util/types").HexString], import("@polkadot/util/types").HexString | null>;
+    archive_v1_storage: import("../shared.js").Handler<[import("@polkadot/util/types").HexString, ChainHeadV1RPC.StorageItemRequest[], import("@polkadot/util/types").HexString | null], string>;
+    archive_v1_stopStorage: import("../shared.js").Handler<[string], null>;
 };
 export default handlers;

package/dist/esm/rpc/rpc-spec/index.js

@@ -1,8 +1,10 @@
+import * as ArchiveV1RPC from './archive_v1.js';
 import * as ChainHeadV1RPC from './chainHead_v1.js';
 import * as ChainSpecV1RPC from './chainSpec_v1.js';
 import * as TransactionV1RPC from './transaction_v1.js';
 export { ChainHeadV1RPC, TransactionV1RPC, ChainSpecV1RPC };
 const handlers = {
+    ...ArchiveV1RPC,
     ...ChainHeadV1RPC,
     ...TransactionV1RPC,
     ...ChainSpecV1RPC

package/dist/esm/rpc/rpc-spec/storage-common.d.ts

@@ -0,0 +1,16 @@
+import type { HexString } from '@polkadot/util/types';
+import type { Block } from '../../blockchain/block.js';
+export declare function getDescendantValues(block: Block, params: DescendantValuesParams): Promise<{
+    items: Array<{
+        key: string;
+        value?: HexString;
+    }>;
+    next: DescendantValuesParams | null;
+}>;
+export declare const PAGE_SIZE = 1000;
+export type DescendantValuesParams = {
+    prefix: string;
+    startKey: string;
+    isDescendantHashes?: boolean;
+};
+export declare function afterResponse(fn: () => void): Promise<void>;

package/dist/esm/rpc/rpc-spec/storage-common.js

@@ -0,0 +1,28 @@
+export async function getDescendantValues(block, params) {
+    const keys = await block.getKeysPaged({
+        ...params,
+        pageSize: PAGE_SIZE
+    });
+    const items = await Promise.all(keys.map((key)=>block.get(key).then((value)=>({
+                key,
+                value
+            }))));
+    if (keys.length < PAGE_SIZE) {
+        return {
+            items,
+            next: null
+        };
+    }
+    return {
+        items,
+        next: {
+            ...params,
+            startKey: keys[PAGE_SIZE - 1]
+        }
+    };
+}
+export const PAGE_SIZE = 1000;
+export async function afterResponse(fn) {
+    await new Promise((resolve)=>setTimeout(resolve, 0));
+    fn();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acala-network/chopsticks-core",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "author": "Acala Developers <hello@acala.network>",
   "license": "Apache-2.0",
   "type": "module",
@@ -14,7 +14,7 @@
     "depcheck": "npx depcheck"
   },
   "dependencies": {
-    "@acala-network/chopsticks-executor": "1.2.0",
+    "@acala-network/chopsticks-executor": "1.2.1",
     "@polkadot/rpc-provider": "^16.4.1",
     "@polkadot/types": "^16.4.1",
     "@polkadot/types-codec": "^16.4.1",
@@ -32,7 +32,7 @@
   },
   "devDependencies": {
     "@swc/cli": "0.7.8",
-    "@swc/core": "^1.12.11",
+    "@swc/core": "^1.12.14",
     "@types/lodash": "^4.17.20",
     "typescript": "^5.8.3",
     "vitest": "^3.2.4"