@acala-network/chopsticks-core 0.8.3 → 0.8.4

package/lib/blockchain/block-builder.js

@@ -132,9 +132,6 @@ const buildBlock = (head, inherents, extrinsics, ump, callbacks, unsafeBlockHeig
     const registry = yield head.registry;
     const header = yield (0, exports.newHeader)(head, unsafeBlockHeight);
     const newBlockNumber = header.number.toNumber();
-    if (newBlockNumber < head.number) {
-        throw new Error('unsafeBlockHeight is not allowed to be less than current block number');
-    }
     logger.info({
         number: newBlockNumber,
         extrinsicsCount: extrinsics.length,

package/lib/blockchain/block.d.ts

@@ -4,7 +4,7 @@ import { TypeRegistry } from '@polkadot/types';
 import type { HexString } from '@polkadot/util/types';
 import { Blockchain } from '.';
 import { StorageLayer, StorageLayerProvider, StorageValue } from './storage-layer';
-import type { RuntimeVersion } from '../executor';
+import type { RuntimeVersion } from '../wasm-executor';
 export type TaskCallResponse = {
     result: HexString;
     storageDiff: [HexString, HexString | null][];

package/lib/blockchain/block.js

@@ -29,7 +29,7 @@ const util_2 = require("@polkadot/util");
 const storage_layer_1 = require("./storage-layer");
 const utils_1 = require("../utils");
 const logger_1 = require("../logger");
-const executor_1 = require("../executor");
+const wasm_executor_1 = require("../wasm-executor");
 /**
  * Block class.
  *
@@ -223,7 +223,7 @@ class Block {
     }
     get runtimeVersion() {
         if (!__classPrivateFieldGet(this, _Block_runtimeVersion, "f")) {
-            __classPrivateFieldSet(this, _Block_runtimeVersion, this.wasm.then(executor_1.getRuntimeVersion), "f");
+            __classPrivateFieldSet(this, _Block_runtimeVersion, this.wasm.then(wasm_executor_1.getRuntimeVersion), "f");
         }
         return __classPrivateFieldGet(this, _Block_runtimeVersion, "f");
     }
@@ -248,13 +248,13 @@ class Block {
     call(method, args) {
         return __awaiter(this, void 0, void 0, function* () {
             const wasm = yield this.wasm;
-            const response = yield (0, executor_1.runTask)({
+            const response = yield (0, wasm_executor_1.runTask)({
                 wasm,
                 calls: [[method, args]],
                 mockSignatureHost: __classPrivateFieldGet(this, _Block_chain, "f").mockSignatureHost,
                 allowUnresolvedImports: __classPrivateFieldGet(this, _Block_chain, "f").allowUnresolvedImports,
                 runtimeLogLevel: __classPrivateFieldGet(this, _Block_chain, "f").runtimeLogLevel,
-            }, (0, executor_1.taskHandler)(this));
+            }, (0, wasm_executor_1.taskHandler)(this));
             if (response.Call) {
                 for (const log of response.Call.runtimeLogs) {
                     logger_1.defaultLogger.info(`RuntimeLogs:\n${log}`);

package/lib/blockchain/index.d.ts

@@ -92,7 +92,7 @@ export declare class Blockchain {
     /**
      * Get block by number.
      */
-    getBlockAt(number?: number): Promise<Block | undefined>;
+    getBlockAt(number?: number | null): Promise<Block | undefined>;
     /**
      * Get block by hash.
      */
@@ -163,7 +163,7 @@ export declare class Blockchain {
      */
     getInherents(): Promise<HexString[]>;
     /**
-     * Close the db.
+     * Close the db and release worker.
      */
     close(): Promise<void>;
 }

package/lib/blockchain/index.js

@@ -32,6 +32,7 @@ const offchain_1 = require("../offchain");
 const utils_1 = require("../utils");
 const logger_1 = require("../logger");
 const block_builder_1 = require("./block-builder");
+const wasm_executor_1 = require("../wasm-executor");
 const logger = logger_1.defaultLogger.child({ name: 'blockchain' });
 /**
  * Local blockchain which provides access to blocks, txpool and methods
@@ -160,7 +161,7 @@ class Blockchain {
      */
     getBlockAt(number) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (number === undefined) {
+            if (number === null || number === undefined) {
                 return this.head;
             }
             if (number > __classPrivateFieldGet(this, _Blockchain_head, "f").number) {
@@ -445,11 +446,12 @@ class Blockchain {
         });
     }
     /**
-     * Close the db.
+     * Close the db and release worker.
      */
     close() {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
+            yield (0, wasm_executor_1.releaseWorker)();
             yield ((_a = this.db) === null || _a === void 0 ? void 0 : _a.destroy());
         });
     }

package/lib/blockchain/inherent/parachain/validation-data.js

@@ -19,7 +19,7 @@ const lodash_1 = __importDefault(require("lodash"));
 const proof_1 = require("../../../utils/proof");
 const util_crypto_1 = require("@polkadot/util-crypto");
 const utils_1 = require("../../../utils");
-const executor_1 = require("../../../executor");
+const wasm_executor_1 = require("../../../wasm-executor");
 const MOCK_VALIDATION_DATA = {
     validationData: {
         relayParentNumber: 1000,
@@ -78,7 +78,7 @@ class SetValidationData {
                 const hrmpIngressChannelIndexKey = (0, proof_1.hrmpIngressChannelIndex)(paraId);
                 const hrmpEgressChannelIndexKey = (0, proof_1.hrmpEgressChannelIndex)(paraId);
                 // TODO: refactor this to have a single decodeProof
-                const decoded = yield (0, executor_1.decodeProof)(extrinsic.validationData.relayParentStorageRoot, [...Object.values(proof_1.WELL_KNOWN_KEYS), dmqMqcHeadKey, hrmpIngressChannelIndexKey, hrmpEgressChannelIndexKey], extrinsic.relayChainState.trieNodes);
+                const decoded = yield (0, wasm_executor_1.decodeProof)(extrinsic.validationData.relayParentStorageRoot, [...Object.values(proof_1.WELL_KNOWN_KEYS), dmqMqcHeadKey, hrmpIngressChannelIndexKey, hrmpEgressChannelIndexKey], extrinsic.relayChainState.trieNodes);
                 for (const key of Object.values(proof_1.WELL_KNOWN_KEYS)) {
                     newEntries.push([key, decoded[key]]);
                 }
@@ -113,7 +113,7 @@ class SetValidationData {
                         receiver: paraId.toNumber(),
                     });
                     const hrmpChannelKey = (0, proof_1.hrmpChannels)(channelId);
-                    const decoded = yield (0, executor_1.decodeProof)(extrinsic.validationData.relayParentStorageRoot, [hrmpChannelKey], extrinsic.relayChainState.trieNodes);
+                    const decoded = yield (0, wasm_executor_1.decodeProof)(extrinsic.validationData.relayParentStorageRoot, [hrmpChannelKey], extrinsic.relayChainState.trieNodes);
                     const abridgedHrmpRaw = decoded[hrmpChannelKey];
                     if (!abridgedHrmpRaw)
                         throw new Error('Canoot find hrmp channels from validation data');
@@ -144,7 +144,7 @@ class SetValidationData {
                         receiver,
                     });
                     const hrmpChannelKey = (0, proof_1.hrmpChannels)(channelId);
-                    const decoded = yield (0, executor_1.decodeProof)(extrinsic.validationData.relayParentStorageRoot, [hrmpChannelKey], extrinsic.relayChainState.trieNodes);
+                    const decoded = yield (0, wasm_executor_1.decodeProof)(extrinsic.validationData.relayParentStorageRoot, [hrmpChannelKey], extrinsic.relayChainState.trieNodes);
                     newEntries.push([hrmpChannelKey, decoded[hrmpChannelKey]]);
                 }
                 const upgradeKey = (0, proof_1.upgradeGoAheadSignal)(paraId);
@@ -158,7 +158,7 @@ class SetValidationData {
                     // make sure previous goAhead is removed
                     newEntries.push([upgradeKey, null]);
                 }
-                const { trieRootHash, nodes } = yield (0, executor_1.createProof)(extrinsic.relayChainState.trieNodes, newEntries);
+                const { trieRootHash, nodes } = yield (0, wasm_executor_1.createProof)(extrinsic.relayChainState.trieNodes, newEntries);
                 newData = Object.assign(Object.assign({}, extrinsic), { downwardMessages,
                     horizontalMessages, validationData: Object.assign(Object.assign({}, extrinsic.validationData), { relayParentStorageRoot: trieRootHash, relayParentNumber: extrinsic.validationData.relayParentNumber + 2 }), relayChainState: {
                         trieNodes: nodes,

package/lib/chopsticks-provider.js

@@ -0,0 +1,249 @@
+"use strict";
+// import { EventEmitter } from 'eventemitter3'
+// import {
+//   ProviderInterface,
+//   ProviderInterfaceCallback,
+//   ProviderInterfaceEmitCb,
+//   ProviderInterfaceEmitted,
+//   ProviderStats,
+// } from '@polkadot/rpc-provider/types'
+// import { StorageValues } from './utils'
+// import { defaultLogger } from './logger'
+// const logger = defaultLogger.child({ name: '[Chopsticks provider]' })
+// interface SubscriptionHandler {
+//   callback: ProviderInterfaceCallback
+//   type: string
+// }
+// interface Subscription extends SubscriptionHandler {
+//   method: string
+//   params: unknown[]
+//   onCancel?: () => void
+//   result?: unknown
+// }
+// interface Handler {
+//   callback: ProviderInterfaceCallback
+//   method: string
+//   params: unknown[]
+//   start: number
+//   subscription?: SubscriptionHandler | undefined
+// }
+// export interface ChopsticksProviderProps {
+//   /** upstream endpoint */
+//   endpoint: string
+//   /** default to latest block */
+//   blockHash?: string
+//   dbPath?: string
+//   storageValues?: StorageValues
+// }
+// /**
+//  * A provider for ApiPromise.
+//  *
+//  * Currectly only support browser environment.
+//  */
+// export class ChopsticksProvider implements ProviderInterface {
+//   #isConnected = false
+//   #eventemitter: EventEmitter
+//   #isReadyPromise: Promise<void>
+//   #endpoint: string
+//   readonly stats?: ProviderStats
+//   #subscriptions: Record<string, Subscription> = {}
+//   #worker: Worker
+//   #blockHash: string | undefined
+//   #dbPath: string | undefined
+//   #storageValues: StorageValues | undefined
+//   #handlers: Record<string, Handler> = {}
+//   #idCounter = 0
+//   constructor({ endpoint, blockHash, dbPath, storageValues }: ChopsticksProviderProps) {
+//     if (!endpoint) {
+//       throw new Error('ChopsticksProvider requires the upstream endpoint')
+//     }
+//     this.#endpoint = endpoint
+//     this.#blockHash = blockHash
+//     this.#dbPath = dbPath
+//     this.#storageValues = storageValues
+//     this.#eventemitter = new EventEmitter()
+//     this.#isReadyPromise = new Promise((resolve, reject): void => {
+//       this.#eventemitter.once('connected', (): void => {
+//         logger.debug('isReadyPromise: connected.')
+//         resolve()
+//       })
+//       this.#eventemitter.once('error', reject)
+//     })
+//     const chopsticksWorker = new Worker(new URL('./chopsticks-worker', import.meta.url), { type: 'module' })
+//     this.#worker = chopsticksWorker
+//     this.connect()
+//   }
+//   get hasSubscriptions(): boolean {
+//     return true
+//   }
+//   get isClonable(): boolean {
+//     return true
+//   }
+//   get isConnected(): boolean {
+//     return this.#isConnected
+//   }
+//   get isReady(): Promise<void> {
+//     return this.#isReadyPromise
+//   }
+//   clone = (): ProviderInterface => {
+//     return new ChopsticksProvider({ endpoint: this.#endpoint })
+//   }
+//   connect = async (): Promise<void> => {
+//     if (this.#isConnected) {
+//       return
+//     }
+//     this.#worker!.onmessage = this.#onWorkerMessage
+//     this.#worker?.postMessage({
+//       type: 'connect',
+//       endpoint: this.#endpoint,
+//       blockHash: this.#blockHash,
+//       dbPath: this.#dbPath,
+//       storageValues: this.#storageValues,
+//     })
+//   }
+//   disconnect = async (): Promise<void> => {
+//     this.#worker?.postMessage({ type: 'disconnect' })
+//     this.#isConnected = false
+//     this.#eventemitter.emit('disconnected')
+//   }
+//   on = (type: ProviderInterfaceEmitted, sub: ProviderInterfaceEmitCb): (() => void) => {
+//     this.#eventemitter.on(type, sub)
+//     return (): void => {
+//       this.#eventemitter.removeListener(type, sub)
+//     }
+//   }
+//   send = async <T>(
+//     method: string,
+//     params: unknown[],
+//     _isCacheable?: boolean,
+//     subscription?: SubscriptionHandler,
+//   ): Promise<T> => {
+//     return new Promise<T>((resolve, reject): void => {
+//       try {
+//         if (!this.isConnected || this.#worker === undefined) {
+//           throw new Error('Api is not connected')
+//         }
+//         logger.debug('send', { method, params })
+//         const id = `${method}::${this.#idCounter++}`
+//         const callback = (error?: Error | null, result?: T): void => {
+//           if (subscription) {
+//             // if it's a subscription, we usually returns the subid
+//             const subid = result as string
+//             if (subid) {
+//               if (!this.#subscriptions[subid]) {
+//                 this.#subscriptions[subid] = {
+//                   callback: subscription.callback,
+//                   method,
+//                   params,
+//                   type: subscription.type,
+//                 }
+//               }
+//             }
+//           }
+//           error ? reject(error) : resolve(result as T)
+//         }
+//         this.#handlers[id] = {
+//           callback,
+//           method,
+//           params,
+//           start: Date.now(),
+//           subscription,
+//         }
+//         this.#worker?.postMessage({
+//           type: 'send',
+//           id,
+//           method,
+//           params,
+//         })
+//       } catch (error) {
+//         reject(error)
+//       }
+//     })
+//   }
+//   subscribe(
+//     type: string,
+//     method: string,
+//     params: unknown[],
+//     callback: ProviderInterfaceCallback,
+//   ): Promise<number | string> {
+//     return this.send<string | number>(method, params, false, { callback, type })
+//   }
+//   async unsubscribe(_type: string, method: string, id: number | string): Promise<boolean> {
+//     if (!this.#subscriptions[id]) {
+//       logger.error(`Unable to find active subscription=${id}`)
+//       return false
+//     }
+//     try {
+//       return this.isConnected ? this.send<boolean>(method, [id]) : true
+//     } catch {
+//       return false
+//     }
+//   }
+//   #onWorkerMessage = (e: any) => {
+//     switch (e.data.type) {
+//       case 'connection':
+//         logger.debug('connection.', e.data)
+//         if (e.data.connected) {
+//           this.#isConnected = true
+//           this.#eventemitter.emit('connected')
+//         } else {
+//           this.#isConnected = false
+//           this.#eventemitter.emit('error', new Error('Unable to connect to the chain'))
+//           logger.error(`Unable to connect to the chain: ${e.data.message}`)
+//         }
+//         break
+//       case 'subscribe-callback':
+//         {
+//           logger.debug('subscribe-callback', e.data)
+//           const sub = this.#subscriptions[e.data.subid]
+//           if (!sub) {
+//             // record it first, sometimes callback comes first
+//             this.#subscriptions[e.data.subid] = {
+//               callback: () => {},
+//               method: e.data.method,
+//               params: e.data.params,
+//               type: e.data.type,
+//               result: JSON.parse(e.data.result),
+//             }
+//             return
+//           }
+//           sub.callback(null, JSON.parse(e.data.result))
+//         }
+//         break
+//       case 'unsubscribe-callback':
+//         {
+//           logger.debug('unsubscribe-callback', e.data)
+//           const sub = this.#subscriptions[e.data.subid]
+//           if (!sub) {
+//             logger.error(`Unable to find active subscription=${e.data.subid}`)
+//             return
+//           }
+//           sub?.onCancel?.()
+//           delete this.#subscriptions[e.data.subid]
+//         }
+//         break
+//       case 'send-result':
+//         {
+//           const handler = this.#handlers[e.data.id]
+//           if (!handler) {
+//             logger.error(`Unable to find handler=${e.data.id}`)
+//             return
+//           }
+//           logger.debug('send-result', {
+//             method: e.data.method,
+//             result: JSON.parse(e.data.result || '{}'),
+//             data: e.data,
+//           })
+//           try {
+//             handler.callback(null, e.data.result ? JSON.parse(e.data.result) : undefined)
+//           } catch (error) {
+//             handler.callback(error as Error, undefined)
+//           }
+//           delete this.#handlers[e.data.id]
+//         }
+//         break
+//       default:
+//         break
+//     }
+//   }
+// }

package/lib/chopsticks-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/chopsticks-worker.js

@@ -0,0 +1,101 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const rpc_1 = require("./rpc");
+const logger_1 = require("./logger");
+const utils_1 = require("./utils");
+const setup_1 = require("./setup");
+let chain;
+const logger = logger_1.defaultLogger.child({ name: '[Chopsticks worker]' });
+const subscriptions = {};
+const providerHandlers = Object.assign(Object.assign({}, rpc_1.allHandlers), { new_block: (context, _params, _subscriptionManager) => __awaiter(void 0, void 0, void 0, function* () {
+        const { chain } = context;
+        const block = yield chain.newBlock();
+        return block;
+    }) });
+const subscriptionManager = {
+    subscribe: (method, subid, onCancel = () => { }) => {
+        subscriptions[subid] = onCancel;
+        return (data) => {
+            postMessage({
+                type: 'subscribe-callback',
+                method,
+                subid,
+                result: JSON.stringify(data),
+            });
+        };
+    },
+    unsubscribe: (subid) => {
+        if (subscriptions[subid]) {
+            subscriptions[subid](subid); // call onCancel
+            postMessage({
+                type: 'unsubscribe-callback',
+                subid,
+            });
+        }
+    },
+};
+onmessage = (e) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    switch (e.data.type) {
+        case 'connect':
+            try {
+                logger.debug('onMessage: connect. Initializing...');
+                chain = yield (0, setup_1.setup)({
+                    endpoint: e.data.endpoint,
+                    mockSignatureHost: true,
+                    db: e.data.dbPath,
+                    block: e.data.blockHash,
+                });
+                logger.debug('onMessage: connect. Chain setup done.');
+                yield (0, utils_1.setStorage)(chain, e.data.storageValues);
+                logger.debug('onMessage: connect. Set storage done.');
+                postMessage({
+                    type: 'connection',
+                    connected: true,
+                });
+            }
+            catch (e) {
+                logger.error('onMessage: connect error.', e);
+                postMessage({
+                    type: 'connection',
+                    connected: false,
+                    message: e,
+                });
+            }
+            break;
+        case 'disconnect':
+            if (chain) {
+                yield ((_a = chain === null || chain === void 0 ? void 0 : chain.api) === null || _a === void 0 ? void 0 : _a.disconnect());
+                yield (chain === null || chain === void 0 ? void 0 : chain.close());
+            }
+            break;
+        case 'send':
+            {
+                const { method, params } = e.data;
+                const handler = providerHandlers[method];
+                if (!handler) {
+                    logger.error(`Unable to find rpc handler=${method}`);
+                    return Promise.reject(new Error(`Unable to find handler=${method}`));
+                }
+                const result = yield handler({ chain: chain }, params, subscriptionManager);
+                postMessage({
+                    type: 'send-result',
+                    id: e.data.id,
+                    method: method,
+                    result: JSON.stringify(result),
+                });
+            }
+            break;
+        default:
+            break;
+    }
+});

package/lib/genesis-provider.d.ts

@@ -1,7 +1,7 @@
 import { HexString } from '@polkadot/util/types';
 import { ProviderInterface, ProviderInterfaceCallback, ProviderInterfaceEmitCb, ProviderInterfaceEmitted, ProviderStats } from '@polkadot/rpc-provider/types';
 import { Genesis } from './schema';
-import { JsCallback } from './executor';
+import { JsCallback } from './wasm-executor';
 export declare class GenesisProvider implements ProviderInterface {
     #private;
     readonly stats?: ProviderStats;

package/lib/genesis-provider.js

@@ -51,7 +51,7 @@ exports.GenesisProvider = void 0;
 const eventemitter3_1 = require("eventemitter3");
 const axios_1 = __importDefault(require("axios"));
 const schema_1 = require("./schema");
-const executor_1 = require("./executor");
+const wasm_executor_1 = require("./wasm-executor");
 const utils_1 = require("./utils");
 class GenesisProvider {
     constructor(genesis) {
@@ -127,7 +127,7 @@ class GenesisProvider {
             throw Error('unimplemented');
         });
         __classPrivateFieldSet(this, _GenesisProvider_genesis, genesis, "f");
-        __classPrivateFieldSet(this, _GenesisProvider_stateRoot, (0, executor_1.calculateStateRoot)(Object.entries(__classPrivateFieldGet(this, _GenesisProvider_genesis, "f").genesis.raw.top).reduce((accu, item) => {
+        __classPrivateFieldSet(this, _GenesisProvider_stateRoot, (0, wasm_executor_1.calculateStateRoot)(Object.entries(__classPrivateFieldGet(this, _GenesisProvider_genesis, "f").genesis.raw.top).reduce((accu, item) => {
             accu.push(item);
             return accu;
         }, []), 1), "f");
@@ -157,7 +157,7 @@ class GenesisProvider {
     }
     get _jsCallback() {
         const storage = __classPrivateFieldGet(this, _GenesisProvider_genesis, "f").genesis.raw.top;
-        return Object.assign(Object.assign({}, executor_1.emptyTaskHandler), { getStorage: function (key) {
+        return Object.assign(Object.assign({}, wasm_executor_1.emptyTaskHandler), { getStorage: function (key) {
                 return __awaiter(this, void 0, void 0, function* () {
                     return storage[key];
                 });

package/lib/index.d.ts

@@ -15,10 +15,11 @@ export * from './blockchain/txpool';
 export * from './blockchain/storage-layer';
 export * from './blockchain/head-state';
 export * from './utils';
-export * from './executor';
+export * from './wasm-executor';
 export * from './schema';
 export * from './xcm';
 export * from './setup';
 export * from './blockchain/inherent';
 export * from './logger';
 export * from './offchain';
+export * from './rpc';

package/lib/index.js

@@ -31,10 +31,12 @@ __exportStar(require("./blockchain/txpool"), exports);
 __exportStar(require("./blockchain/storage-layer"), exports);
 __exportStar(require("./blockchain/head-state"), exports);
 __exportStar(require("./utils"), exports);
-__exportStar(require("./executor"), exports);
+__exportStar(require("./wasm-executor"), exports);
 __exportStar(require("./schema"), exports);
 __exportStar(require("./xcm"), exports);
 __exportStar(require("./setup"), exports);
 __exportStar(require("./blockchain/inherent"), exports);
 __exportStar(require("./logger"), exports);
 __exportStar(require("./offchain"), exports);
+// export * from './chopsticks-provider'
+__exportStar(require("./rpc"), exports);

package/lib/rpc/index.d.ts

@@ -0,0 +1,5 @@
+import { Handlers } from './shared';
+export declare const allHandlers: Handlers;
+export { default as substrate } from './substrate';
+export { ResponseError } from './shared';
+export type { Context, SubscriptionManager, Handler, Handlers } from './shared';

package/lib/rpc/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseError = exports.substrate = exports.allHandlers = void 0;
+const substrate_1 = __importDefault(require("./substrate"));
+exports.allHandlers = Object.assign(Object.assign({}, substrate_1.default), { rpc_methods: () => __awaiter(void 0, void 0, void 0, function* () {
+        return Promise.resolve({
+            version: 1,
+            methods: [...Object.keys(exports.allHandlers)],
+        });
+    }) });
+var substrate_2 = require("./substrate");
+Object.defineProperty(exports, "substrate", { enumerable: true, get: function () { return __importDefault(substrate_2).default; } });
+var shared_1 = require("./shared");
+Object.defineProperty(exports, "ResponseError", { enumerable: true, get: function () { return shared_1.ResponseError; } });

package/lib/rpc/shared.d.ts

@@ -0,0 +1,27 @@
+import { Blockchain } from '@acala-network/chopsticks-core';
+export declare const logger: import("pino").default.Logger<{
+    level: string;
+    transport: {
+        target: string;
+    };
+}>;
+export declare class ResponseError extends Error {
+    code: number;
+    constructor(code: number, message: string);
+    toJSON(): {
+        code: number;
+        message: string;
+    };
+}
+export interface Context {
+    /**
+     * The blockchain instance
+     */
+    chain: Blockchain;
+}
+export interface SubscriptionManager {
+    subscribe: (method: string, subid: string, onCancel?: () => void) => (data: any) => void;
+    unsubscribe: (subid: string) => void;
+}
+export type Handler<TParams = any, TReturn = any> = (context: Context, params: TParams, subscriptionManager: SubscriptionManager) => Promise<TReturn>;
+export type Handlers = Record<string, Handler>;

package/lib/rpc/shared.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseError = exports.logger = void 0;
+const logger_1 = require("../logger");
+exports.logger = logger_1.defaultLogger.child({ name: 'rpc' });
+class ResponseError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.name = 'ResponseError';
+        this.code = code;
+    }
+    toJSON() {
+        return {
+            code: this.code,
+            message: this.message,
+        };
+    }
+}
+exports.ResponseError = ResponseError;