@acala-network/chopsticks-core 0.8.3 → 0.8.5-0

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/head-state.d.ts

@@ -1,5 +1,5 @@
 import { Block } from './block';
-type Callback = (block: Block, pairs: [string, string][]) => void | Promise<void>;
+type Callback = (block: Block, pairs: [string, string | null][]) => void | Promise<void>;
 export declare const randomId: () => string;
 export declare class HeadState {
     #private;

package/lib/blockchain/head-state.js

@@ -48,7 +48,7 @@ class HeadState {
             const id = (0, exports.randomId)();
             __classPrivateFieldGet(this, _HeadState_storageListeners, "f")[id] = [keys, cb];
             for (const key of keys) {
-                __classPrivateFieldGet(this, _HeadState_oldValues, "f")[key] = yield __classPrivateFieldGet(this, _HeadState_head, "f").get(key);
+                __classPrivateFieldGet(this, _HeadState_oldValues, "f")[key] = yield __classPrivateFieldGet(this, _HeadState_head, "f").get(key).then((val) => val || null);
             }
             return id;
         });
@@ -61,7 +61,7 @@ class HeadState {
             const id = (0, exports.randomId)();
             const codeKey = (0, util_1.stringToHex)(':code');
             __classPrivateFieldGet(this, _HeadState_storageListeners, "f")[id] = [[codeKey], cb];
-            __classPrivateFieldGet(this, _HeadState_oldValues, "f")[codeKey] = yield __classPrivateFieldGet(this, _HeadState_head, "f").get(codeKey);
+            __classPrivateFieldGet(this, _HeadState_oldValues, "f")[codeKey] = yield __classPrivateFieldGet(this, _HeadState_head, "f").get(codeKey).then((val) => val || null);
             return id;
         });
     }

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,13 @@ 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 this.api.disconnect();
             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.d.ts

@@ -0,0 +1,31 @@
+import { ProviderInterface, ProviderInterfaceCallback, ProviderInterfaceEmitCb, ProviderInterfaceEmitted } from '@polkadot/rpc-provider/types';
+import { Blockchain } from './blockchain';
+interface SubscriptionHandler {
+    callback: ProviderInterfaceCallback;
+    type: string;
+}
+/**
+ * Provider for local chopsticks chain
+ */
+export declare class ChopsticksProvider implements ProviderInterface {
+    #private;
+    readonly chain: Blockchain;
+    constructor(chain: Blockchain);
+    static fromEndpoint: (endpoint: string, block?: number | string | null, cache?: string) => Promise<ChopsticksProvider>;
+    get hasSubscriptions(): boolean;
+    get isClonable(): boolean;
+    get isConnected(): boolean;
+    get isReady(): Promise<void>;
+    clone: () => ChopsticksProvider;
+    connect: () => Promise<void>;
+    disconnect: () => Promise<void>;
+    on: (type: ProviderInterfaceEmitted, sub: ProviderInterfaceEmitCb) => (() => void);
+    subscriptionManager: {
+        subscribe: (method: string, subid: string, onCancel?: () => void) => (data: any) => void;
+        unsubscribe: (subid: string) => void;
+    };
+    send: <T>(method: string, params: unknown[], _isCacheable?: boolean, subscription?: SubscriptionHandler) => Promise<T>;
+    subscribe(type: string, method: string, params: unknown[], callback: ProviderInterfaceCallback): Promise<number | string>;
+    unsubscribe(_type: string, method: string, id: number | string): Promise<boolean>;
+}
+export {};

package/lib/chopsticks-provider.js

@@ -0,0 +1,169 @@
+"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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _a, _ChopsticksProvider_isConnected, _ChopsticksProvider_eventemitter, _ChopsticksProvider_isReadyPromise, _ChopsticksProvider_subscriptions;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChopsticksProvider = void 0;
+const eventemitter3_1 = require("eventemitter3");
+const rpc_1 = require("./rpc");
+const logger_1 = require("./logger");
+const setup_1 = require("./setup");
+const providerHandlers = Object.assign(Object.assign({}, rpc_1.allHandlers), { dev_newBlock: (context, _params, _subscriptionManager) => __awaiter(void 0, void 0, void 0, function* () {
+        const block = yield context.chain.newBlock();
+        return block.hash;
+    }) });
+const logger = logger_1.defaultLogger.child({ name: '[Chopsticks provider]' });
+/**
+ * Provider for local chopsticks chain
+ */
+class ChopsticksProvider {
+    constructor(chain) {
+        this.chain = chain;
+        _ChopsticksProvider_isConnected.set(this, false);
+        _ChopsticksProvider_eventemitter.set(this, void 0);
+        _ChopsticksProvider_isReadyPromise.set(this, void 0);
+        _ChopsticksProvider_subscriptions.set(this, {});
+        this.clone = () => {
+            return new ChopsticksProvider(this.chain);
+        };
+        this.connect = () => __awaiter(this, void 0, void 0, function* () {
+            __classPrivateFieldSet(this, _ChopsticksProvider_isConnected, true, "f");
+            __classPrivateFieldGet(this, _ChopsticksProvider_eventemitter, "f").emit('connected');
+        });
+        this.disconnect = () => __awaiter(this, void 0, void 0, function* () {
+            __classPrivateFieldSet(this, _ChopsticksProvider_isConnected, false, "f");
+            __classPrivateFieldGet(this, _ChopsticksProvider_eventemitter, "f").emit('disconnected');
+        });
+        this.on = (type, sub) => {
+            __classPrivateFieldGet(this, _ChopsticksProvider_eventemitter, "f").on(type, sub);
+            return () => {
+                __classPrivateFieldGet(this, _ChopsticksProvider_eventemitter, "f").removeListener(type, sub);
+            };
+        };
+        this.subscriptionManager = {
+            subscribe: (method, subid, onCancel = () => { }) => {
+                const sub = __classPrivateFieldGet(this, _ChopsticksProvider_subscriptions, "f")[subid];
+                if (sub) {
+                    sub.onCancel = onCancel;
+                }
+                return (data) => {
+                    logger.debug('subscribe-callback', method, subid, data);
+                    const sub = __classPrivateFieldGet(this, _ChopsticksProvider_subscriptions, "f")[subid];
+                    if (sub) {
+                        sub.callback(null, data);
+                    }
+                    else {
+                        logger.trace(`Unable to find active subscription=${subid}`);
+                    }
+                };
+            },
+            unsubscribe: (subid) => {
+                var _b;
+                logger.debug('unsubscribe-callback', subid);
+                const sub = __classPrivateFieldGet(this, _ChopsticksProvider_subscriptions, "f")[subid];
+                if (sub) {
+                    (_b = sub.onCancel) === null || _b === void 0 ? void 0 : _b.call(sub);
+                    delete __classPrivateFieldGet(this, _ChopsticksProvider_subscriptions, "f")[subid];
+                }
+                else {
+                    logger.trace(`Unable to find active subscription=${subid}`);
+                }
+            },
+        };
+        this.send = (method, params, _isCacheable, subscription) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                logger.debug('send', { method, params });
+                const rpcHandler = providerHandlers[method];
+                if (!rpcHandler) {
+                    logger.error(`Unable to find rpc handler=${method}`);
+                    throw new Error(`Unable to find rpc handler=${method}`);
+                }
+                if (subscription) {
+                    logger.debug('subscribe', { method, params });
+                    const subid = yield rpcHandler({ chain: this.chain }, params, this.subscriptionManager);
+                    if (!subid) {
+                        throw new Error(`Unable to subscribe=${method}`);
+                    }
+                    __classPrivateFieldGet(this, _ChopsticksProvider_subscriptions, "f")[subid] = {
+                        callback: subscription.callback,
+                        method,
+                        params,
+                        type: subscription.type,
+                    };
+                    return subid;
+                }
+                else {
+                    logger.debug('call', { method, params });
+                    return rpcHandler({ chain: this.chain }, params, this.subscriptionManager);
+                }
+            }
+            catch (e) {
+                logger.error('send error.', e);
+                throw e;
+            }
+        });
+        __classPrivateFieldSet(this, _ChopsticksProvider_eventemitter, new eventemitter3_1.EventEmitter(), "f");
+        __classPrivateFieldSet(this, _ChopsticksProvider_isReadyPromise, new Promise((resolve, reject) => {
+            __classPrivateFieldGet(this, _ChopsticksProvider_eventemitter, "f").once('connected', resolve);
+            __classPrivateFieldGet(this, _ChopsticksProvider_eventemitter, "f").once('error', reject);
+            this.connect();
+        }), "f");
+    }
+    get hasSubscriptions() {
+        return true;
+    }
+    get isClonable() {
+        return true;
+    }
+    get isConnected() {
+        return __classPrivateFieldGet(this, _ChopsticksProvider_isConnected, "f");
+    }
+    get isReady() {
+        return __classPrivateFieldGet(this, _ChopsticksProvider_isReadyPromise, "f");
+    }
+    subscribe(type, method, params, callback) {
+        return this.send(method, params, false, { callback, type });
+    }
+    unsubscribe(_type, method, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!__classPrivateFieldGet(this, _ChopsticksProvider_subscriptions, "f")[id]) {
+                logger.trace(`Unable to find active subscription=${id}`);
+                return false;
+            }
+            try {
+                return this.send(method, [id]);
+            }
+            catch (_b) {
+                return false;
+            }
+        });
+    }
+}
+exports.ChopsticksProvider = ChopsticksProvider;
+_a = ChopsticksProvider, _ChopsticksProvider_isConnected = new WeakMap(), _ChopsticksProvider_eventemitter = new WeakMap(), _ChopsticksProvider_isReadyPromise = new WeakMap(), _ChopsticksProvider_subscriptions = new WeakMap();
+ChopsticksProvider.fromEndpoint = (endpoint, block, cache) => __awaiter(void 0, void 0, void 0, function* () {
+    return new ChopsticksProvider(yield (0, setup_1.setup)({
+        endpoint,
+        mockSignatureHost: true,
+        block,
+        db: cache,
+    }));
+});

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,12 @@ 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 './chopsticks-provider';
+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);
+__exportStar(require("./chopsticks-provider"), exports);
+__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;

package/lib/rpc/substrate/author.d.ts

@@ -0,0 +1,28 @@
+import { HexString } from '@polkadot/util/types';
+import { Handler } from '../shared';
+/**
+ * @param context
+ * @param params - [`extrinsic`]
+ *
+ * @return Hash
+ */
+export declare const author_submitExtrinsic: Handler<[HexString], HexString>;
+/**
+ * @param context
+ * @param params - [`extrinsic`]
+ * @param subscriptionManager
+ *
+ * @return subscription id
+ */
+export declare const author_submitAndWatchExtrinsic: Handler<[HexString], string>;
+/**
+ * @param _context
+ * @param params - [`subid`]
+ */
+export declare const author_unwatchExtrinsic: Handler<[string], void>;
+/**
+ * Get pending extrinsics
+ *
+ * @return Array of pending extrinsics
+ */
+export declare const author_pendingExtrinsics: Handler<void, HexString[]>;