@acala-network/chopsticks-core 0.14.2-1 → 0.15.0

package/dist/cjs/rpc/index.js

@@ -19,11 +19,12 @@ _export(exports, {
         return _index.default;
     },
     substrate: function() {
-        return _index1.default;
+        return _index2.default;
     }
 });
 const _index = /*#__PURE__*/ _interop_require_default(require("./dev/index.js"));
-const _index1 = /*#__PURE__*/ _interop_require_default(require("./substrate/index.js"));
+const _index1 = /*#__PURE__*/ _interop_require_default(require("./rpc-spec/index.js"));
+const _index2 = /*#__PURE__*/ _interop_require_default(require("./substrate/index.js"));
 const _shared = require("./shared.js");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
@@ -31,6 +32,7 @@ function _interop_require_default(obj) {
     };
 }
 const allHandlers = {
+    ..._index2.default,
     ..._index1.default,
     ..._index.default,
     rpc_methods: async ()=>Promise.resolve({

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

@@ -0,0 +1,79 @@
+import { Handler } from '../shared.js';
+import { HexString } from '@polkadot/util/types';
+/**
+ * Start a chainHead follow subscription
+ *
+ * @param context
+ * @param params - [`withRuntime`]
+ * @param subscriptionManager
+ *
+ * @return subscription id
+ */
+export declare const chainHead_v1_follow: Handler<[boolean], string>;
+/**
+ * Stop a chainHead follow subscription
+ *
+ * @param context
+ * @param params - [`followSubscription`]
+ * @param subscriptionManager
+ */
+export declare const chainHead_v1_unfollow: Handler<[string], null>;
+/**
+ * Retrieve the header for a specific block
+ *
+ * @param context
+ * @param params - [`followSubscription`, `hash`]
+ *
+ * @return SCALE-encoded header, or null if the block is not found.
+ */
+export declare const chainHead_v1_header: Handler<[string, HexString], HexString | null>;
+type OperationStarted = {
+    result: 'started';
+    operationId: string;
+};
+/**
+ * Perform a runtime call for a block
+ *
+ * @param context
+ * @param params - [`followSubscription`, `hash`, `function`, `callParameters`]
+ *
+ * @return OperationStarted event with operationId to receive the result on the follow subscription
+ */
+export declare const chainHead_v1_call: Handler<[string, HexString, string, HexString], OperationStarted>;
+export type StorageStarted = OperationStarted & {
+    discardedItems: number;
+};
+export interface StorageItemRequest {
+    key: HexString;
+    type: 'value' | 'hash' | 'closestDescendantMerkleValue' | 'descendantsValues' | 'descendantsHashes';
+}
+/**
+ * Query the storage for a given block
+ *
+ * @param context
+ * @param params - [`followSubscription`, `hash`, `items`, `childTrie`]
+ *
+ * @return OperationStarted event with operationId to receive the result on the follow subscription
+ */
+export declare const chainHead_v1_storage: Handler<[
+    string,
+    HexString,
+    StorageItemRequest[],
+    HexString | null
+], StorageStarted>;
+export type LimitReached = {
+    result: 'limitReached';
+};
+/**
+ * Retrieve the body of a specific block
+ *
+ * @param context
+ * @param params - [`followSubscription`, `hash`]
+ *
+ * @return OperationStarted event with operationId to receive the result on the follow subscription
+ */
+export declare const chainHead_v1_body: Handler<[string, HexString], OperationStarted | LimitReached>;
+export declare const chainHead_v1_continue: Handler<[string, HexString], null>;
+export declare const chainHead_v1_stopOperation: Handler<[string, HexString], null>;
+export declare const chainHead_v1_unpin: Handler<[string, HexString | HexString[]], null>;
+export {};

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

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    chainHead_v1_body: function() {
+        return chainHead_v1_body;
+    },
+    chainHead_v1_call: function() {
+        return chainHead_v1_call;
+    },
+    chainHead_v1_continue: function() {
+        return chainHead_v1_continue;
+    },
+    chainHead_v1_follow: function() {
+        return chainHead_v1_follow;
+    },
+    chainHead_v1_header: function() {
+        return chainHead_v1_header;
+    },
+    chainHead_v1_stopOperation: function() {
+        return chainHead_v1_stopOperation;
+    },
+    chainHead_v1_storage: function() {
+        return chainHead_v1_storage;
+    },
+    chainHead_v1_unfollow: function() {
+        return chainHead_v1_unfollow;
+    },
+    chainHead_v1_unpin: function() {
+        return chainHead_v1_unpin;
+    }
+});
+const _shared = require("../shared.js");
+const _logger = require("../../logger.js");
+const logger = _logger.defaultLogger.child({
+    name: 'rpc-chainHead_v1'
+});
+const callbacks = 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({
+            hash: block.hash
+        }, 'chainHead_v1_follow');
+        const getNewRuntime = async ()=>{
+            const [runtime, previousRuntime] = await Promise.all([
+                block.runtimeVersion,
+                block.parentBlock.then((b)=>b?.runtimeVersion)
+            ]);
+            const hasNewRuntime = runtime.implVersion !== previousRuntime?.implVersion || runtime.specVersion !== previousRuntime.specVersion;
+            return hasNewRuntime ? runtime : null;
+        };
+        const newRuntime = withRuntime ? await getNewRuntime() : null;
+        callback({
+            event: 'newBlock',
+            blockHash: block.hash,
+            parentBlockHash: (await block.parentBlock)?.hash,
+            newRuntime
+        });
+        callback({
+            event: 'bestBlockChanged',
+            bestBlockHash: block.hash
+        });
+        callback({
+            event: 'finalized',
+            finalizedBlockHashes: [
+                block.hash
+            ],
+            prunedBlockHashes: []
+        });
+    };
+    const id = context.chain.headState.subscribeHead(update);
+    const cleanup = ()=>{
+        context.chain.headState.unsubscribeHead(id);
+        callbacks.delete(id);
+    };
+    const callback = subscribe('chainHead_v1_followEvent', id, cleanup);
+    callbacks.set(id, callback);
+    afterResponse(async ()=>{
+        callback({
+            event: 'initialized',
+            finalizedBlockHashes: [
+                context.chain.head.hash
+            ],
+            finalizedBlockRuntime: withRuntime ? await context.chain.head.runtimeVersion : null
+        });
+    });
+    return id;
+};
+const chainHead_v1_unfollow = async (_, [followSubscription], { unsubscribe })=>{
+    unsubscribe(followSubscription);
+    return null;
+};
+const chainHead_v1_header = async (context, [followSubscription, hash])=>{
+    if (!callbacks.has(followSubscription)) return null;
+    const block = await context.chain.getBlock(hash);
+    return block ? (await block.header).toHex() : null;
+};
+const operationStarted = (operationId)=>({
+        result: 'started',
+        operationId
+    });
+const randomId = ()=>Math.random().toString(36).substring(2);
+const chainHead_v1_call = async (context, [followSubscription, hash, method, callParameters])=>{
+    const operationId = randomId();
+    afterResponse(async ()=>{
+        const block = await context.chain.getBlock(hash);
+        if (!block) {
+            callbacks.get(followSubscription)?.({
+                event: 'operationError',
+                operationId,
+                error: `Block ${hash} not found`
+            });
+        } else {
+            try {
+                const resp = await block.call(method, [
+                    callParameters
+                ]);
+                callbacks.get(followSubscription)?.({
+                    event: 'operationCallDone',
+                    operationId,
+                    output: resp.result
+                });
+            } catch (ex) {
+                callbacks.get(followSubscription)?.({
+                    event: 'operationError',
+                    operationId,
+                    error: ex.message
+                });
+            }
+        }
+    });
+    return operationStarted(operationId);
+};
+const chainHead_v1_storage = async (context, [followSubscription, hash, items, _childTrie])=>{
+    const operationId = randomId();
+    afterResponse(async ()=>{
+        const block = await context.chain.getBlock(hash);
+        if (!block) {
+            callbacks.get(followSubscription)?.({
+                event: 'operationError',
+                operationId,
+                error: 'Block not found'
+            });
+            return;
+        }
+        const handleStorageItemRequest = async (sir)=>{
+            switch(sir.type){
+                case 'value':
+                    {
+                        const value = await block.get(sir.key);
+                        if (value) {
+                            callbacks.get(followSubscription)?.({
+                                event: 'operationStorageItems',
+                                operationId,
+                                items: [
+                                    {
+                                        key: sir.key,
+                                        value
+                                    }
+                                ]
+                            });
+                        }
+                        break;
+                    }
+                case 'descendantsValues':
+                    {
+                        // TODO expose pagination
+                        const pageSize = 100;
+                        let startKey = '0x';
+                        while(startKey){
+                            const keys = await block.getKeysPaged({
+                                prefix: sir.key,
+                                pageSize,
+                                startKey
+                            });
+                            startKey = keys[pageSize - 1] ?? null;
+                            const items = await Promise.all(keys.map((key)=>block.get(key).then((value)=>({
+                                        key,
+                                        value
+                                    }))));
+                            callbacks.get(followSubscription)?.({
+                                event: 'operationStorageItems',
+                                operationId,
+                                items
+                            });
+                            break;
+                        }
+                        break;
+                    }
+                default:
+                    // TODO
+                    console.warn(`Storage type not implemented ${sir.type}`);
+            }
+        };
+        await Promise.all(items.map(handleStorageItemRequest));
+        callbacks.get(followSubscription)?.({
+            event: 'operationStorageDone',
+            operationId
+        });
+    });
+    return {
+        ...operationStarted(operationId),
+        discardedItems: 0
+    };
+};
+const limitReached = {
+    result: 'limitReached'
+};
+const chainHead_v1_body = async (context, [followSubscription, hash])=>{
+    if (!callbacks.has(followSubscription)) return limitReached;
+    const block = await context.chain.getBlock(hash);
+    if (!block) {
+        throw new _shared.ResponseError(-32801, 'Block not found');
+    }
+    const operationId = randomId();
+    afterResponse(async ()=>{
+        const body = await block.extrinsics;
+        callbacks.get(followSubscription)?.({
+            event: 'operationBodyDone',
+            operationId,
+            value: body
+        });
+    });
+    return operationStarted(operationId);
+};
+const chainHead_v1_continue = async (_context, [_followSubscription, _operationId])=>{
+    return null;
+};
+const chainHead_v1_stopOperation = async (_context, [_followSubscription, _operationId])=>{
+    return null;
+};
+const chainHead_v1_unpin = async (_context, [_followSubscription, _hashOrHashes])=>{
+    return null;
+};

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

@@ -0,0 +1,6 @@
+import { ChainProperties } from '../../index.js';
+import { Handler } from '../shared.js';
+import { HexString } from '@polkadot/util/types';
+export declare const chainSpec_v1_chainName: Handler<[], string>;
+export declare const chainSpec_v1_genesisHash: Handler<[], HexString>;
+export declare const chainSpec_v1_properties: Handler<[], ChainProperties>;

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    chainSpec_v1_chainName: function() {
+        return chainSpec_v1_chainName;
+    },
+    chainSpec_v1_genesisHash: function() {
+        return chainSpec_v1_genesisHash;
+    },
+    chainSpec_v1_properties: function() {
+        return chainSpec_v1_properties;
+    }
+});
+const _shared = require("../shared.js");
+const chainSpec_v1_chainName = async (context)=>{
+    return context.chain.api.getSystemChain();
+};
+const chainSpec_v1_genesisHash = async (context)=>{
+    const genesisHash = await context.chain.api.getBlockHash(0);
+    if (genesisHash === null) {
+        throw new _shared.ResponseError(1, 'Unexpected null genesis hash');
+    }
+    return genesisHash;
+};
+const chainSpec_v1_properties = async (context)=>{
+    return context.chain.api.getSystemProperties();
+};

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

@@ -0,0 +1,27 @@
+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 };
+declare const handlers: {
+    chainSpec_v1_chainName: import("../shared.js").Handler<[], string>;
+    chainSpec_v1_genesisHash: import("../shared.js").Handler<[], import("@polkadot/util/types").HexString>;
+    chainSpec_v1_properties: import("../shared.js").Handler<[], import("../../index.js").ChainProperties>;
+    transaction_v1_broadcast: import("../shared.js").Handler<[import("@polkadot/util/types").HexString], string | null>;
+    transaction_v1_stop: import("../shared.js").Handler<[string], null>;
+    chainHead_v1_follow: import("../shared.js").Handler<[boolean], string>;
+    chainHead_v1_unfollow: import("../shared.js").Handler<[string], null>;
+    chainHead_v1_header: import("../shared.js").Handler<[string, import("@polkadot/util/types").HexString], import("@polkadot/util/types").HexString | null>;
+    chainHead_v1_call: import("../shared.js").Handler<[string, import("@polkadot/util/types").HexString, string, import("@polkadot/util/types").HexString], {
+        result: "started";
+        operationId: string;
+    }>;
+    chainHead_v1_storage: import("../shared.js").Handler<[string, import("@polkadot/util/types").HexString, ChainHeadV1RPC.StorageItemRequest[], import("@polkadot/util/types").HexString | null], ChainHeadV1RPC.StorageStarted>;
+    chainHead_v1_body: import("../shared.js").Handler<[string, import("@polkadot/util/types").HexString], {
+        result: "started";
+        operationId: string;
+    } | ChainHeadV1RPC.LimitReached>;
+    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>;
+};
+export default handlers;

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ChainHeadV1RPC: function() {
+        return _chainHead_v1;
+    },
+    ChainSpecV1RPC: function() {
+        return _chainSpec_v1;
+    },
+    TransactionV1RPC: function() {
+        return _transaction_v1;
+    },
+    default: function() {
+        return _default;
+    }
+});
+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"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const handlers = {
+    ..._chainHead_v1,
+    ..._transaction_v1,
+    ..._chainSpec_v1
+};
+const _default = handlers;

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

@@ -0,0 +1,16 @@
+import { Handler } from '../shared.js';
+import { HexString } from '@polkadot/util/types';
+/**
+ * Submit the extrinsic to the transaction pool
+ *
+ * @param context
+ * @param params - [`extrinsic`]
+ *
+ * @return operation id
+ */
+export declare const transaction_v1_broadcast: Handler<[HexString], string | null>;
+/**
+ * Stop broadcasting the transaction to other nodes.
+ *
+ */
+export declare const transaction_v1_stop: Handler<[string], null>;

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    transaction_v1_broadcast: function() {
+        return transaction_v1_broadcast;
+    },
+    transaction_v1_stop: function() {
+        return transaction_v1_stop;
+    }
+});
+const _logger = require("../../logger.js");
+const logger = _logger.defaultLogger.child({
+    name: 'rpc-transaction_v1'
+});
+const randomId = ()=>Math.random().toString(36).substring(2);
+const transaction_v1_broadcast = async (context, [extrinsic])=>{
+    await context.chain.submitExtrinsic(extrinsic).catch((err)=>{
+        // As per the spec, the invalid transaction errors should be ignored.
+        logger.warn('Submit extrinsic failed', err);
+    });
+    return randomId();
+};
+const transaction_v1_stop = async (_context, [_operationId])=>{
+    // Chopsticks doesn't have any process to broadcast the transaction through P2P
+    // so stopping doesn't have any effect.
+    return null;
+};

package/dist/esm/rpc/index.js

@@ -1,7 +1,9 @@
 import dev from './dev/index.js';
+import rpcSpec from './rpc-spec/index.js';
 import substrate from './substrate/index.js';
 export const allHandlers = {
     ...substrate,
+    ...rpcSpec,
     ...dev,
     rpc_methods: async ()=>Promise.resolve({
             version: 1,

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

@@ -0,0 +1,79 @@
+import { Handler } from '../shared.js';
+import { HexString } from '@polkadot/util/types';
+/**
+ * Start a chainHead follow subscription
+ *
+ * @param context
+ * @param params - [`withRuntime`]
+ * @param subscriptionManager
+ *
+ * @return subscription id
+ */
+export declare const chainHead_v1_follow: Handler<[boolean], string>;
+/**
+ * Stop a chainHead follow subscription
+ *
+ * @param context
+ * @param params - [`followSubscription`]
+ * @param subscriptionManager
+ */
+export declare const chainHead_v1_unfollow: Handler<[string], null>;
+/**
+ * Retrieve the header for a specific block
+ *
+ * @param context
+ * @param params - [`followSubscription`, `hash`]
+ *
+ * @return SCALE-encoded header, or null if the block is not found.
+ */
+export declare const chainHead_v1_header: Handler<[string, HexString], HexString | null>;
+type OperationStarted = {
+    result: 'started';
+    operationId: string;
+};
+/**
+ * Perform a runtime call for a block
+ *
+ * @param context
+ * @param params - [`followSubscription`, `hash`, `function`, `callParameters`]
+ *
+ * @return OperationStarted event with operationId to receive the result on the follow subscription
+ */
+export declare const chainHead_v1_call: Handler<[string, HexString, string, HexString], OperationStarted>;
+export type StorageStarted = OperationStarted & {
+    discardedItems: number;
+};
+export interface StorageItemRequest {
+    key: HexString;
+    type: 'value' | 'hash' | 'closestDescendantMerkleValue' | 'descendantsValues' | 'descendantsHashes';
+}
+/**
+ * Query the storage for a given block
+ *
+ * @param context
+ * @param params - [`followSubscription`, `hash`, `items`, `childTrie`]
+ *
+ * @return OperationStarted event with operationId to receive the result on the follow subscription
+ */
+export declare const chainHead_v1_storage: Handler<[
+    string,
+    HexString,
+    StorageItemRequest[],
+    HexString | null
+], StorageStarted>;
+export type LimitReached = {
+    result: 'limitReached';
+};
+/**
+ * Retrieve the body of a specific block
+ *
+ * @param context
+ * @param params - [`followSubscription`, `hash`]
+ *
+ * @return OperationStarted event with operationId to receive the result on the follow subscription
+ */
+export declare const chainHead_v1_body: Handler<[string, HexString], OperationStarted | LimitReached>;
+export declare const chainHead_v1_continue: Handler<[string, HexString], null>;
+export declare const chainHead_v1_stopOperation: Handler<[string, HexString], null>;
+export declare const chainHead_v1_unpin: Handler<[string, HexString | HexString[]], null>;
+export {};

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

@@ -0,0 +1,250 @@
+import { ResponseError } from '../shared.js';
+import { defaultLogger } from '../../logger.js';
+const logger = defaultLogger.child({
+    name: 'rpc-chainHead_v1'
+});
+const callbacks = new Map();
+async function afterResponse(fn) {
+    await new Promise((resolve)=>setTimeout(resolve, 0));
+    fn();
+}
+/**
+ * Start a chainHead follow subscription
+ *
+ * @param context
+ * @param params - [`withRuntime`]
+ * @param subscriptionManager
+ *
+ * @return subscription id
+ */ export const chainHead_v1_follow = async (context, [withRuntime], { subscribe })=>{
+    const update = async (block)=>{
+        logger.trace({
+            hash: block.hash
+        }, 'chainHead_v1_follow');
+        const getNewRuntime = async ()=>{
+            const [runtime, previousRuntime] = await Promise.all([
+                block.runtimeVersion,
+                block.parentBlock.then((b)=>b?.runtimeVersion)
+            ]);
+            const hasNewRuntime = runtime.implVersion !== previousRuntime?.implVersion || runtime.specVersion !== previousRuntime.specVersion;
+            return hasNewRuntime ? runtime : null;
+        };
+        const newRuntime = withRuntime ? await getNewRuntime() : null;
+        callback({
+            event: 'newBlock',
+            blockHash: block.hash,
+            parentBlockHash: (await block.parentBlock)?.hash,
+            newRuntime
+        });
+        callback({
+            event: 'bestBlockChanged',
+            bestBlockHash: block.hash
+        });
+        callback({
+            event: 'finalized',
+            finalizedBlockHashes: [
+                block.hash
+            ],
+            prunedBlockHashes: []
+        });
+    };
+    const id = context.chain.headState.subscribeHead(update);
+    const cleanup = ()=>{
+        context.chain.headState.unsubscribeHead(id);
+        callbacks.delete(id);
+    };
+    const callback = subscribe('chainHead_v1_followEvent', id, cleanup);
+    callbacks.set(id, callback);
+    afterResponse(async ()=>{
+        callback({
+            event: 'initialized',
+            finalizedBlockHashes: [
+                context.chain.head.hash
+            ],
+            finalizedBlockRuntime: withRuntime ? await context.chain.head.runtimeVersion : null
+        });
+    });
+    return id;
+};
+/**
+ * Stop a chainHead follow subscription
+ *
+ * @param context
+ * @param params - [`followSubscription`]
+ * @param subscriptionManager
+ */ export const chainHead_v1_unfollow = async (_, [followSubscription], { unsubscribe })=>{
+    unsubscribe(followSubscription);
+    return null;
+};
+/**
+ * Retrieve the header for a specific block
+ *
+ * @param context
+ * @param params - [`followSubscription`, `hash`]
+ *
+ * @return SCALE-encoded header, or null if the block is not found.
+ */ export const chainHead_v1_header = async (context, [followSubscription, hash])=>{
+    if (!callbacks.has(followSubscription)) return null;
+    const block = await context.chain.getBlock(hash);
+    return block ? (await block.header).toHex() : null;
+};
+const operationStarted = (operationId)=>({
+        result: 'started',
+        operationId
+    });
+const randomId = ()=>Math.random().toString(36).substring(2);
+/**
+ * Perform a runtime call for a block
+ *
+ * @param context
+ * @param params - [`followSubscription`, `hash`, `function`, `callParameters`]
+ *
+ * @return OperationStarted event with operationId to receive the result on the follow subscription
+ */ export const chainHead_v1_call = async (context, [followSubscription, hash, method, callParameters])=>{
+    const operationId = randomId();
+    afterResponse(async ()=>{
+        const block = await context.chain.getBlock(hash);
+        if (!block) {
+            callbacks.get(followSubscription)?.({
+                event: 'operationError',
+                operationId,
+                error: `Block ${hash} not found`
+            });
+        } else {
+            try {
+                const resp = await block.call(method, [
+                    callParameters
+                ]);
+                callbacks.get(followSubscription)?.({
+                    event: 'operationCallDone',
+                    operationId,
+                    output: resp.result
+                });
+            } catch (ex) {
+                callbacks.get(followSubscription)?.({
+                    event: 'operationError',
+                    operationId,
+                    error: ex.message
+                });
+            }
+        }
+    });
+    return operationStarted(operationId);
+};
+/**
+ * Query the storage for a given block
+ *
+ * @param context
+ * @param params - [`followSubscription`, `hash`, `items`, `childTrie`]
+ *
+ * @return OperationStarted event with operationId to receive the result on the follow subscription
+ */ export const chainHead_v1_storage = async (context, [followSubscription, hash, items, _childTrie])=>{
+    const operationId = randomId();
+    afterResponse(async ()=>{
+        const block = await context.chain.getBlock(hash);
+        if (!block) {
+            callbacks.get(followSubscription)?.({
+                event: 'operationError',
+                operationId,
+                error: 'Block not found'
+            });
+            return;
+        }
+        const handleStorageItemRequest = async (sir)=>{
+            switch(sir.type){
+                case 'value':
+                    {
+                        const value = await block.get(sir.key);
+                        if (value) {
+                            callbacks.get(followSubscription)?.({
+                                event: 'operationStorageItems',
+                                operationId,
+                                items: [
+                                    {
+                                        key: sir.key,
+                                        value
+                                    }
+                                ]
+                            });
+                        }
+                        break;
+                    }
+                case 'descendantsValues':
+                    {
+                        // TODO expose pagination
+                        const pageSize = 100;
+                        let startKey = '0x';
+                        while(startKey){
+                            const keys = await block.getKeysPaged({
+                                prefix: sir.key,
+                                pageSize,
+                                startKey
+                            });
+                            startKey = keys[pageSize - 1] ?? null;
+                            const items = await Promise.all(keys.map((key)=>block.get(key).then((value)=>({
+                                        key,
+                                        value
+                                    }))));
+                            callbacks.get(followSubscription)?.({
+                                event: 'operationStorageItems',
+                                operationId,
+                                items
+                            });
+                            break;
+                        }
+                        break;
+                    }
+                default:
+                    // TODO
+                    console.warn(`Storage type not implemented ${sir.type}`);
+            }
+        };
+        await Promise.all(items.map(handleStorageItemRequest));
+        callbacks.get(followSubscription)?.({
+            event: 'operationStorageDone',
+            operationId
+        });
+    });
+    return {
+        ...operationStarted(operationId),
+        discardedItems: 0
+    };
+};
+const limitReached = {
+    result: 'limitReached'
+};
+/**
+ * Retrieve the body of a specific block
+ *
+ * @param context
+ * @param params - [`followSubscription`, `hash`]
+ *
+ * @return OperationStarted event with operationId to receive the result on the follow subscription
+ */ export const chainHead_v1_body = async (context, [followSubscription, hash])=>{
+    if (!callbacks.has(followSubscription)) return limitReached;
+    const block = await context.chain.getBlock(hash);
+    if (!block) {
+        throw new ResponseError(-32801, 'Block not found');
+    }
+    const operationId = randomId();
+    afterResponse(async ()=>{
+        const body = await block.extrinsics;
+        callbacks.get(followSubscription)?.({
+            event: 'operationBodyDone',
+            operationId,
+            value: body
+        });
+    });
+    return operationStarted(operationId);
+};
+// Currently no-ops, will come into play when pagination is implemented
+export const chainHead_v1_continue = async (_context, [_followSubscription, _operationId])=>{
+    return null;
+};
+export const chainHead_v1_stopOperation = async (_context, [_followSubscription, _operationId])=>{
+    return null;
+};
+// no-op, since there's no concept of unpinning in chopsticks
+export const chainHead_v1_unpin = async (_context, [_followSubscription, _hashOrHashes])=>{
+    return null;
+};

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

@@ -0,0 +1,6 @@
+import { ChainProperties } from '../../index.js';
+import { Handler } from '../shared.js';
+import { HexString } from '@polkadot/util/types';
+export declare const chainSpec_v1_chainName: Handler<[], string>;
+export declare const chainSpec_v1_genesisHash: Handler<[], HexString>;
+export declare const chainSpec_v1_properties: Handler<[], ChainProperties>;

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

@@ -0,0 +1,14 @@
+import { ResponseError } from '../shared.js';
+export const chainSpec_v1_chainName = async (context)=>{
+    return context.chain.api.getSystemChain();
+};
+export const chainSpec_v1_genesisHash = async (context)=>{
+    const genesisHash = await context.chain.api.getBlockHash(0);
+    if (genesisHash === null) {
+        throw new ResponseError(1, 'Unexpected null genesis hash');
+    }
+    return genesisHash;
+};
+export const chainSpec_v1_properties = async (context)=>{
+    return context.chain.api.getSystemProperties();
+};

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

@@ -0,0 +1,27 @@
+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 };
+declare const handlers: {
+    chainSpec_v1_chainName: import("../shared.js").Handler<[], string>;
+    chainSpec_v1_genesisHash: import("../shared.js").Handler<[], import("@polkadot/util/types").HexString>;
+    chainSpec_v1_properties: import("../shared.js").Handler<[], import("../../index.js").ChainProperties>;
+    transaction_v1_broadcast: import("../shared.js").Handler<[import("@polkadot/util/types").HexString], string | null>;
+    transaction_v1_stop: import("../shared.js").Handler<[string], null>;
+    chainHead_v1_follow: import("../shared.js").Handler<[boolean], string>;
+    chainHead_v1_unfollow: import("../shared.js").Handler<[string], null>;
+    chainHead_v1_header: import("../shared.js").Handler<[string, import("@polkadot/util/types").HexString], import("@polkadot/util/types").HexString | null>;
+    chainHead_v1_call: import("../shared.js").Handler<[string, import("@polkadot/util/types").HexString, string, import("@polkadot/util/types").HexString], {
+        result: "started";
+        operationId: string;
+    }>;
+    chainHead_v1_storage: import("../shared.js").Handler<[string, import("@polkadot/util/types").HexString, ChainHeadV1RPC.StorageItemRequest[], import("@polkadot/util/types").HexString | null], ChainHeadV1RPC.StorageStarted>;
+    chainHead_v1_body: import("../shared.js").Handler<[string, import("@polkadot/util/types").HexString], {
+        result: "started";
+        operationId: string;
+    } | ChainHeadV1RPC.LimitReached>;
+    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>;
+};
+export default handlers;

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

@@ -0,0 +1,10 @@
+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 = {
+    ...ChainHeadV1RPC,
+    ...TransactionV1RPC,
+    ...ChainSpecV1RPC
+};
+export default handlers;

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

@@ -0,0 +1,16 @@
+import { Handler } from '../shared.js';
+import { HexString } from '@polkadot/util/types';
+/**
+ * Submit the extrinsic to the transaction pool
+ *
+ * @param context
+ * @param params - [`extrinsic`]
+ *
+ * @return operation id
+ */
+export declare const transaction_v1_broadcast: Handler<[HexString], string | null>;
+/**
+ * Stop broadcasting the transaction to other nodes.
+ *
+ */
+export declare const transaction_v1_stop: Handler<[string], null>;

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

@@ -0,0 +1,27 @@
+import { defaultLogger } from '../../logger.js';
+const logger = defaultLogger.child({
+    name: 'rpc-transaction_v1'
+});
+const randomId = ()=>Math.random().toString(36).substring(2);
+/**
+ * Submit the extrinsic to the transaction pool
+ *
+ * @param context
+ * @param params - [`extrinsic`]
+ *
+ * @return operation id
+ */ export const transaction_v1_broadcast = async (context, [extrinsic])=>{
+    await context.chain.submitExtrinsic(extrinsic).catch((err)=>{
+        // As per the spec, the invalid transaction errors should be ignored.
+        logger.warn('Submit extrinsic failed', err);
+    });
+    return randomId();
+};
+/**
+ * Stop broadcasting the transaction to other nodes.
+ *
+ */ export const transaction_v1_stop = async (_context, [_operationId])=>{
+    // Chopsticks doesn't have any process to broadcast the transaction through P2P
+    // so stopping doesn't have any effect.
+    return null;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acala-network/chopsticks-core",
-  "version": "0.14.2-1",
+  "version": "0.15.0",
   "author": "Acala Developers <hello@acala.network>",
   "license": "Apache-2.0",
   "type": "module",
@@ -11,7 +11,7 @@
     "depcheck": "npx depcheck"
   },
   "dependencies": {
-    "@acala-network/chopsticks-executor": "0.14.2-1",
+    "@acala-network/chopsticks-executor": "0.15.0",
     "@polkadot/rpc-provider": "^12.3.1",
     "@polkadot/types": "^12.3.1",
     "@polkadot/types-codec": "^12.3.1",