@acala-network/chopsticks-core 0.8.2 → 0.8.4

package/lib/blockchain/block-builder.d.ts

@@ -2,7 +2,11 @@ import { Header, TransactionValidityError } from '@polkadot/types/interfaces';
 import { Block, TaskCallResponse } from './block';
 import { HexString } from '@polkadot/util/types';
 export declare const newHeader: (head: Block, unsafeBlockHeight?: number) => Promise<Header>;
-export declare const buildBlock: (head: Block, inherents: HexString[], extrinsics: HexString[], ump: Record<number, HexString[]>, onApplyExtrinsicError: (extrinsic: HexString, error: TransactionValidityError) => void, unsafeBlockHeight?: number) => Promise<[Block, HexString[]]>;
+export type BuildBlockCallbacks = {
+    onApplyExtrinsicError?: (extrinsic: HexString, error: TransactionValidityError) => void;
+    onPhaseApplied?: (phase: 'initialize' | 'finalize' | number, resp: TaskCallResponse) => void;
+};
+export declare const buildBlock: (head: Block, inherents: HexString[], extrinsics: HexString[], ump: Record<number, HexString[]>, callbacks?: BuildBlockCallbacks, unsafeBlockHeight?: number) => Promise<[Block, HexString[]]>;
 export declare const dryRunExtrinsic: (head: Block, inherents: HexString[], extrinsic: HexString | {
     call: HexString;
     address: string;

package/lib/blockchain/block-builder.js

@@ -90,7 +90,8 @@ const newHeader = (head, unsafeBlockHeight) => __awaiter(void 0, void 0, void 0,
     return header;
 });
 exports.newHeader = newHeader;
-const initNewBlock = (head, header, inherents, storageLayer) => __awaiter(void 0, void 0, void 0, function* () {
+const initNewBlock = (head, header, inherents, storageLayer, callback) => __awaiter(void 0, void 0, void 0, function* () {
+    var _c, _d;
     const blockNumber = header.number.toNumber();
     const hash = `0x${Math.round(Math.random() * 100000000)
         .toString(16)
@@ -102,19 +103,19 @@ const initNewBlock = (head, header, inherents, storageLayer) => __awaiter(void 0
     });
     {
         // initialize block
-        const { storageDiff } = yield newBlock.call('Core_initialize_block', [header.toHex()]);
-        newBlock.pushStorageLayer().setAll(storageDiff);
-        logger.trace((0, logger_1.truncate)(storageDiff), 'Initialize block');
+        const resp = yield newBlock.call('Core_initialize_block', [header.toHex()]);
+        newBlock.pushStorageLayer().setAll(resp.storageDiff);
+        (_c = callback === null || callback === void 0 ? void 0 : callback.onPhaseApplied) === null || _c === void 0 ? void 0 : _c.call(callback, 'initialize', resp);
     }
     const layers = [];
     // apply inherents
     for (const extrinsic of inherents) {
         try {
-            const { storageDiff } = yield newBlock.call('BlockBuilder_apply_extrinsic', [extrinsic]);
+            const resp = yield newBlock.call('BlockBuilder_apply_extrinsic', [extrinsic]);
             const layer = newBlock.pushStorageLayer();
-            layer.setAll(storageDiff);
+            layer.setAll(resp.storageDiff);
             layers.push(layer);
-            logger.trace((0, logger_1.truncate)(storageDiff), 'Applied inherent');
+            (_d = callback === null || callback === void 0 ? void 0 : callback.onPhaseApplied) === null || _d === void 0 ? void 0 : _d.call(callback, layers.length - 1, resp);
         }
         catch (e) {
             logger.warn('Failed to apply inherents %o %s', e, e);
@@ -126,13 +127,11 @@ const initNewBlock = (head, header, inherents, storageLayer) => __awaiter(void 0
         layers: layers,
     };
 });
-const buildBlock = (head, inherents, extrinsics, ump, onApplyExtrinsicError, unsafeBlockHeight) => __awaiter(void 0, void 0, void 0, function* () {
+const buildBlock = (head, inherents, extrinsics, ump, callbacks, unsafeBlockHeight) => __awaiter(void 0, void 0, void 0, function* () {
+    var _e, _f, _g;
     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,
@@ -216,15 +215,15 @@ const buildBlock = (head, inherents, extrinsics, ump, onApplyExtrinsicError, uns
     // apply extrinsics
     for (const extrinsic of extrinsics) {
         try {
-            const { result, storageDiff } = yield newBlock.call('BlockBuilder_apply_extrinsic', [extrinsic]);
-            const outcome = registry.createType('ApplyExtrinsicResult', result);
+            const resp = yield newBlock.call('BlockBuilder_apply_extrinsic', [extrinsic]);
+            const outcome = registry.createType('ApplyExtrinsicResult', resp.result);
             if (outcome.isErr) {
-                onApplyExtrinsicError(extrinsic, outcome.asErr);
+                (_e = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onApplyExtrinsicError) === null || _e === void 0 ? void 0 : _e.call(callbacks, extrinsic, outcome.asErr);
                 continue;
             }
-            newBlock.pushStorageLayer().setAll(storageDiff);
-            logger.trace((0, logger_1.truncate)(storageDiff), 'Applied extrinsic');
+            newBlock.pushStorageLayer().setAll(resp.storageDiff);
             includedExtrinsic.push(extrinsic);
+            (_f = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onPhaseApplied) === null || _f === void 0 ? void 0 : _f.call(callbacks, includedExtrinsic.length - 1, resp);
         }
         catch (e) {
             logger.info('Failed to apply extrinsic %o %s', e, e);
@@ -233,16 +232,18 @@ const buildBlock = (head, inherents, extrinsics, ump, onApplyExtrinsicError, uns
     }
     {
         // finalize block
-        const { storageDiff } = yield newBlock.call('BlockBuilder_finalize_block', []);
-        newBlock.pushStorageLayer().setAll(storageDiff);
-        logger.trace((0, logger_1.truncate)(storageDiff), 'Finalize block');
+        const resp = yield newBlock.call('BlockBuilder_finalize_block', []);
+        newBlock.pushStorageLayer().setAll(resp.storageDiff);
+        (_g = callbacks === null || callbacks === void 0 ? void 0 : callbacks.onPhaseApplied) === null || _g === void 0 ? void 0 : _g.call(callbacks, 'finalize', resp);
     }
     const blockData = registry.createType('Block', {
         header,
         extrinsics: includedExtrinsic,
     });
     const storageDiff = yield newBlock.storageDiff();
-    logger.trace(Object.entries(storageDiff).map(([key, value]) => [key, (0, logger_1.truncate)(value)]), 'Final block');
+    if (logger.level.toLowerCase() === 'trace') {
+        logger.trace(Object.entries(storageDiff).map(([key, value]) => [key, (0, logger_1.truncate)(value)]), 'Final block');
+    }
     const finalBlock = new block_1.Block(head.chain, newBlock.number, blockData.hash.toHex(), head, {
         header,
         extrinsics: [...inherents, ...includedExtrinsic],

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/blockchain/storage-layer.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 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) {
@@ -28,7 +51,7 @@ exports.StorageLayer = exports.RemoteStorageLayer = exports.StorageValueKind = v
 const lodash_1 = __importDefault(require("lodash"));
 const entities_1 = require("../db/entities");
 const logger_1 = require("../logger");
-const key_cache_1 = __importDefault(require("../utils/key-cache"));
+const key_cache_1 = __importStar(require("../utils/key-cache"));
 const logger = logger_1.defaultLogger.child({ name: 'layer' });
 const BATCH_SIZE = 1000;
 var StorageValueKind;
@@ -76,7 +99,7 @@ class RemoteStorageLayer {
                 throw new Error(`pageSize must be less or equal to ${BATCH_SIZE}`);
             logger.trace({ at: __classPrivateFieldGet(this, _RemoteStorageLayer_at, "f"), prefix, pageSize, startKey }, 'RemoteStorageLayer getKeysPaged');
             // can't handle keyCache without prefix
-            if (prefix.length < 66) {
+            if (prefix.length < key_cache_1.PREFIX_LENGTH || startKey.length < key_cache_1.PREFIX_LENGTH) {
                 return __classPrivateFieldGet(this, _RemoteStorageLayer_api, "f").getKeysPaged(prefix, pageSize, startKey, __classPrivateFieldGet(this, _RemoteStorageLayer_at, "f"));
             }
             let batchComplete = false;

package/lib/blockchain/txpool.js

@@ -209,8 +209,24 @@ _TxPool_chain = new WeakMap(), _TxPool_pool = new WeakMap(), _TxPool_ump = new W
         logger.trace({ params }, 'build block');
         const head = __classPrivateFieldGet(this, _TxPool_chain, "f").head;
         const inherents = yield __classPrivateFieldGet(this, _TxPool_inherentProvider, "f").createInherents(head, params);
-        const [newBlock, pendingExtrinsics] = yield (0, block_builder_1.buildBlock)(head, inherents, params.transactions, params.upwardMessages, (extrinsic, error) => {
-            this.event.emit(exports.APPLY_EXTRINSIC_ERROR, [extrinsic, error]);
+        const [newBlock, pendingExtrinsics] = yield (0, block_builder_1.buildBlock)(head, inherents, params.transactions, params.upwardMessages, {
+            onApplyExtrinsicError: (extrinsic, error) => {
+                this.event.emit(exports.APPLY_EXTRINSIC_ERROR, [extrinsic, error]);
+            },
+            onPhaseApplied: logger.level.toLowerCase() === 'trace'
+                ? (phase, resp) => {
+                    switch (phase) {
+                        case 'initialize':
+                            logger.trace((0, logger_1.truncate)(resp.storageDiff), 'Initialize block');
+                            break;
+                        case 'finalize':
+                            logger.trace((0, logger_1.truncate)(resp.storageDiff), 'Finalize block');
+                            break;
+                        default:
+                            logger.trace((0, logger_1.truncate)(resp.storageDiff), `Apply extrinsic ${phase}`);
+                    }
+                }
+                : undefined,
         }, params.unsafeBlockHeight);
         for (const extrinsic of pendingExtrinsics) {
             __classPrivateFieldGet(this, _TxPool_pool, "f").push({ extrinsic, signer: yield __classPrivateFieldGet(this, _TxPool_instances, "m", _TxPool_getSigner).call(this, extrinsic) });

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 {};