@acala-network/chopsticks-core 0.8.2 → 0.8.4

package/lib/rpc/substrate/payment.js

@@ -0,0 +1,54 @@
+"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 });
+exports.payment_queryInfo = exports.payment_queryFeeDetails = void 0;
+const util_1 = require("@polkadot/util");
+const shared_1 = require("../shared");
+/**
+ * @param context
+ * @param params - [`extrinsic`, `blockhash`]
+ *
+ * @return result in hash
+ */
+const payment_queryFeeDetails = (context, [extrinsic, hash]) => __awaiter(void 0, void 0, void 0, function* () {
+    const block = yield context.chain.getBlock(hash);
+    if (!block) {
+        throw new shared_1.ResponseError(1, `Block ${hash} not found`);
+    }
+    const registry = yield block.registry;
+    const tx = (0, util_1.hexToU8a)(extrinsic);
+    const resp = yield block.call('TransactionPaymentApi_query_fee_details', [
+        registry.createType('Extrinsic', tx).toHex(),
+        registry.createType('u32', tx.byteLength).toHex(),
+    ]);
+    return resp.result;
+});
+exports.payment_queryFeeDetails = payment_queryFeeDetails;
+/**
+ * @param context
+ * @param params - [`extrinsic`, `blockhash`]
+ *
+ * @return result in hash
+ */
+const payment_queryInfo = (context, [extrinsic, hash]) => __awaiter(void 0, void 0, void 0, function* () {
+    const block = yield context.chain.getBlock(hash);
+    if (!block) {
+        throw new shared_1.ResponseError(1, `Block ${hash} not found`);
+    }
+    const registry = yield block.registry;
+    const tx = (0, util_1.hexToU8a)(extrinsic);
+    const resp = yield block.call('TransactionPaymentApi_query_info', [
+        registry.createType('Extrinsic', tx).toHex(),
+        registry.createType('u32', tx.byteLength).toHex(),
+    ]);
+    return resp.result;
+});
+exports.payment_queryInfo = payment_queryInfo;

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

@@ -0,0 +1,97 @@
+import { HexString } from '@polkadot/util/types';
+import { Handler } from '../shared';
+import { RuntimeVersion } from '../../wasm-executor';
+/**
+ * @param context
+ * @param params - [`blockhash`]
+ *
+ * @return runtime version
+ */
+export declare const state_getRuntimeVersion: Handler<[HexString], RuntimeVersion | undefined>;
+/**
+ * @param context
+ * @param params - [`blockhash`]
+ *
+ * @return metadata
+ */
+export declare const state_getMetadata: Handler<[HexString], HexString | undefined>;
+/**
+ * @param context
+ * @param params - [`key`, `blockhash`]
+ *
+ * @return storage value
+ */
+export declare const state_getStorage: Handler<[HexString, HexString], string | undefined>;
+/**
+ * @param context
+ * @param params - [`prefix`, `pageSize`, `startKey`, `blockhash`]
+ *
+ * @return paged keys
+ */
+export declare const state_getKeysPaged: Handler<[string, number, string, HexString], string[] | undefined>;
+/**
+ * @param context
+ * @param params - [`keys`, `blockhash`]
+ *
+ * @return storage values
+ */
+export declare const state_queryStorageAt: Handler<[
+    string[],
+    HexString
+], [] | [
+    {
+        block: HexString;
+        changes: (string | undefined)[][];
+    }
+]>;
+/**
+ * @param context
+ * @param params - [`method`, `data`, `blockhash`]
+ *
+ * @return result in hash
+ */
+export declare const state_call: Handler<[HexString, HexString, HexString], HexString>;
+/**
+ * @return subscription id
+ */
+export declare const state_subscribeRuntimeVersion: Handler<[], string>;
+/**
+ * @param context
+ * @param params - [`subid`]
+ * @param subscriptionManager
+ */
+export declare const state_unsubscribeRuntimeVersion: Handler<[HexString], void>;
+/**
+ * @param context
+ * @param params - [`keys`]
+ * @param subscriptionManager
+ *
+ * @return subscription id
+ */
+export declare const state_subscribeStorage: Handler<[string[]], string>;
+/**
+ * @param context
+ * @param params - [`subid`]
+ * @param subscriptionManager
+ */
+export declare const state_unsubscribeStorage: Handler<[string], void>;
+/**
+ * @param context
+ * @param params - [`child`, `key`, `blockhash`]
+ *
+ * @return storage valuse
+ */
+export declare const childstate_getStorage: Handler<[HexString, HexString, HexString], string | undefined>;
+/**
+ * @param context
+ * @param params - [`child`, `prefix`, `pageSize`, `startKey`, `blockhash`]
+ *
+ * @return paged keys
+ */
+export declare const childstate_getKeysPaged: Handler<[
+    HexString,
+    HexString,
+    number,
+    HexString,
+    HexString
+], HexString[] | undefined>;

package/lib/rpc/substrate/state.js

@@ -0,0 +1,184 @@
+"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 });
+exports.childstate_getKeysPaged = exports.childstate_getStorage = exports.state_unsubscribeStorage = exports.state_subscribeStorage = exports.state_unsubscribeRuntimeVersion = exports.state_subscribeRuntimeVersion = exports.state_call = exports.state_queryStorageAt = exports.state_getKeysPaged = exports.state_getStorage = exports.state_getMetadata = exports.state_getRuntimeVersion = void 0;
+const shared_1 = require("../shared");
+const logger_1 = require("../../logger");
+const utils_1 = require("../../utils");
+const logger = logger_1.defaultLogger.child({ name: 'rpc-state' });
+/**
+ * @param context
+ * @param params - [`blockhash`]
+ *
+ * @return runtime version
+ */
+const state_getRuntimeVersion = (context, [hash]) => __awaiter(void 0, void 0, void 0, function* () {
+    const block = yield context.chain.getBlock(hash);
+    return block === null || block === void 0 ? void 0 : block.runtimeVersion;
+});
+exports.state_getRuntimeVersion = state_getRuntimeVersion;
+/**
+ * @param context
+ * @param params - [`blockhash`]
+ *
+ * @return metadata
+ */
+const state_getMetadata = (context, [hash]) => __awaiter(void 0, void 0, void 0, function* () {
+    const block = yield context.chain.getBlock(hash);
+    return block === null || block === void 0 ? void 0 : block.metadata;
+});
+exports.state_getMetadata = state_getMetadata;
+/**
+ * @param context
+ * @param params - [`key`, `blockhash`]
+ *
+ * @return storage value
+ */
+const state_getStorage = (context, [key, hash]) => __awaiter(void 0, void 0, void 0, function* () {
+    const block = yield context.chain.getBlock(hash);
+    return block === null || block === void 0 ? void 0 : block.get(key);
+});
+exports.state_getStorage = state_getStorage;
+/**
+ * @param context
+ * @param params - [`prefix`, `pageSize`, `startKey`, `blockhash`]
+ *
+ * @return paged keys
+ */
+const state_getKeysPaged = (context, [prefix, pageSize, startKey, hash]) => __awaiter(void 0, void 0, void 0, function* () {
+    const block = yield context.chain.getBlock(hash);
+    return block === null || block === void 0 ? void 0 : block.getKeysPaged({ prefix, pageSize, startKey });
+});
+exports.state_getKeysPaged = state_getKeysPaged;
+/**
+ * @param context
+ * @param params - [`keys`, `blockhash`]
+ *
+ * @return storage values
+ */
+const state_queryStorageAt = (context, [keys, hash]) => __awaiter(void 0, void 0, void 0, function* () {
+    const block = yield context.chain.getBlock(hash);
+    if (!block) {
+        return [];
+    }
+    const values = yield Promise.all(keys.map((key) => __awaiter(void 0, void 0, void 0, function* () { return [key, yield block.get(key)]; })));
+    return [
+        {
+            block: block.hash,
+            changes: values,
+        },
+    ];
+});
+exports.state_queryStorageAt = state_queryStorageAt;
+/**
+ * @param context
+ * @param params - [`method`, `data`, `blockhash`]
+ *
+ * @return result in hash
+ */
+const state_call = (context, [method, data, hash]) => __awaiter(void 0, void 0, void 0, function* () {
+    const block = yield context.chain.getBlock(hash);
+    if (!block) {
+        throw new shared_1.ResponseError(1, `Block ${hash} not found`);
+    }
+    const resp = yield block.call(method, [data]);
+    return resp.result;
+});
+exports.state_call = state_call;
+/**
+ * @return subscription id
+ */
+const state_subscribeRuntimeVersion = (context, _params, { subscribe }) => __awaiter(void 0, void 0, void 0, function* () {
+    let update = (_block) => { };
+    const id = yield context.chain.headState.subscrubeRuntimeVersion((block) => update(block));
+    const callback = subscribe('state_runtimeVersion', id);
+    update = (block) => __awaiter(void 0, void 0, void 0, function* () { return callback(yield block.runtimeVersion); });
+    context.chain.head.runtimeVersion.then(callback);
+    return id;
+});
+exports.state_subscribeRuntimeVersion = state_subscribeRuntimeVersion;
+/**
+ * @param context
+ * @param params - [`subid`]
+ * @param subscriptionManager
+ */
+const state_unsubscribeRuntimeVersion = (_context, [subid], { unsubscribe }) => __awaiter(void 0, void 0, void 0, function* () {
+    unsubscribe(subid);
+});
+exports.state_unsubscribeRuntimeVersion = state_unsubscribeRuntimeVersion;
+/**
+ * @param context
+ * @param params - [`keys`]
+ * @param subscriptionManager
+ *
+ * @return subscription id
+ */
+const state_subscribeStorage = (context, [keys], { subscribe }) => __awaiter(void 0, void 0, void 0, function* () {
+    let update = (_block, _pairs) => { };
+    const id = yield context.chain.headState.subscribeStorage(keys, (block, pairs) => update(block, pairs));
+    const callback = subscribe('state_storage', id, () => context.chain.headState.unsubscribeStorage(id));
+    update = (block, pairs) => __awaiter(void 0, void 0, void 0, function* () {
+        logger.trace({ hash: block.hash }, 'state_subscribeStorage');
+        callback({
+            block: block.hash,
+            changes: pairs,
+        });
+    });
+    (() => __awaiter(void 0, void 0, void 0, function* () {
+        const pairs = yield Promise.all(keys.map((key) => __awaiter(void 0, void 0, void 0, function* () {
+            const val = yield context.chain.head.get(key);
+            return [key, val];
+        })));
+        callback({
+            block: context.chain.head.hash,
+            changes: pairs,
+        });
+    }))();
+    return id;
+});
+exports.state_subscribeStorage = state_subscribeStorage;
+/**
+ * @param context
+ * @param params - [`subid`]
+ * @param subscriptionManager
+ */
+const state_unsubscribeStorage = (_context, [subid], { unsubscribe }) => __awaiter(void 0, void 0, void 0, function* () {
+    unsubscribe(subid);
+});
+exports.state_unsubscribeStorage = state_unsubscribeStorage;
+/**
+ * @param context
+ * @param params - [`child`, `key`, `blockhash`]
+ *
+ * @return storage valuse
+ */
+const childstate_getStorage = (context, [child, key, hash]) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!(0, utils_1.isPrefixedChildKey)(child)) {
+        throw new shared_1.ResponseError(-32000, 'Client error: Invalid child storage key');
+    }
+    const block = yield context.chain.getBlock(hash);
+    return block === null || block === void 0 ? void 0 : block.get((0, utils_1.prefixedChildKey)(child, key));
+});
+exports.childstate_getStorage = childstate_getStorage;
+/**
+ * @param context
+ * @param params - [`child`, `prefix`, `pageSize`, `startKey`, `blockhash`]
+ *
+ * @return paged keys
+ */
+const childstate_getKeysPaged = (context, [child, prefix, pageSize, startKey, hash]) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!(0, utils_1.isPrefixedChildKey)(child)) {
+        throw new shared_1.ResponseError(-32000, 'Client error: Invalid child storage key');
+    }
+    const block = yield context.chain.getBlock(hash);
+    return block === null || block === void 0 ? void 0 : block.getKeysPaged({ prefix: (0, utils_1.prefixedChildKey)(child, prefix), pageSize, startKey: (0, utils_1.prefixedChildKey)(child, startKey) }).then((keys) => keys.map(utils_1.stripChildPrefix));
+});
+exports.childstate_getKeysPaged = childstate_getKeysPaged;

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

@@ -0,0 +1,28 @@
+import { HexString } from '@polkadot/util/types';
+import { ChainProperties } from '../../api';
+import { Handler } from '../shared';
+export declare const system_localPeerId: () => Promise<string>;
+export declare const system_nodeRoles: () => Promise<string[]>;
+export declare const system_localListenAddresses: () => Promise<never[]>;
+export declare const system_chain: Handler<void, string>;
+export declare const system_properties: Handler<void, ChainProperties>;
+export declare const system_name: Handler<void, string>;
+export declare const system_version: Handler<void, string>;
+export declare const system_chainType: Handler<void, string>;
+export declare const system_health: () => Promise<{
+    peers: number;
+    isSyncing: boolean;
+    shouldHavePeers: boolean;
+}>;
+/**
+ * @param context
+ * @param params - [`extrinsic`, `at`]
+ *
+ * @return ApplyExtrinsicResult (see `@polkadot/types/interfaces`) in hash
+ */
+export declare const system_dryRun: Handler<[HexString, HexString], string>;
+/**
+ * @param context
+ * @param params - [`address`]
+ */
+export declare const system_accountNextIndex: Handler<[HexString], number>;

package/lib/rpc/substrate/system.js

@@ -0,0 +1,71 @@
+"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 });
+exports.system_accountNextIndex = exports.system_dryRun = exports.system_health = exports.system_chainType = exports.system_version = exports.system_name = exports.system_properties = exports.system_chain = exports.system_localListenAddresses = exports.system_nodeRoles = exports.system_localPeerId = void 0;
+const util_1 = require("@polkadot/util");
+const system_localPeerId = () => __awaiter(void 0, void 0, void 0, function* () { return '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY'; });
+exports.system_localPeerId = system_localPeerId;
+const system_nodeRoles = () => __awaiter(void 0, void 0, void 0, function* () { return ['Full']; });
+exports.system_nodeRoles = system_nodeRoles;
+const system_localListenAddresses = () => __awaiter(void 0, void 0, void 0, function* () { return []; });
+exports.system_localListenAddresses = system_localListenAddresses;
+const system_chain = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    return context.chain.api.getSystemChain();
+});
+exports.system_chain = system_chain;
+const system_properties = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    return context.chain.api.getSystemProperties();
+});
+exports.system_properties = system_properties;
+const system_name = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    return context.chain.api.getSystemName();
+});
+exports.system_name = system_name;
+const system_version = (_context) => __awaiter(void 0, void 0, void 0, function* () {
+    return 'chopsticks-v1';
+});
+exports.system_version = system_version;
+const system_chainType = (_context) => __awaiter(void 0, void 0, void 0, function* () {
+    return 'Development';
+});
+exports.system_chainType = system_chainType;
+const system_health = () => __awaiter(void 0, void 0, void 0, function* () {
+    return {
+        peers: 0,
+        isSyncing: false,
+        shouldHavePeers: false,
+    };
+});
+exports.system_health = system_health;
+/**
+ * @param context
+ * @param params - [`extrinsic`, `at`]
+ *
+ * @return ApplyExtrinsicResult (see `@polkadot/types/interfaces`) in hash
+ */
+const system_dryRun = (context, [extrinsic, at]) => __awaiter(void 0, void 0, void 0, function* () {
+    const { outcome } = yield context.chain.dryRunExtrinsic(extrinsic, at);
+    return outcome.toHex();
+});
+exports.system_dryRun = system_dryRun;
+/**
+ * @param context
+ * @param params - [`address`]
+ */
+const system_accountNextIndex = (context, [address]) => __awaiter(void 0, void 0, void 0, function* () {
+    const head = context.chain.head;
+    const registry = yield head.registry;
+    const account = registry.createType('AccountId', address);
+    const result = yield head.call('AccountNonceApi_account_nonce', [account.toHex()]);
+    const nonce = registry.createType('Index', (0, util_1.hexToU8a)(result.result)).toNumber();
+    return nonce + context.chain.txPool.pendingExtrinsicsBy(address).length;
+});
+exports.system_accountNextIndex = system_accountNextIndex;

package/lib/utils/time-travel.js

@@ -12,7 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.timeTravel = exports.getSlotDuration = exports.getCurrentTimestamp = exports.getCurrentSlot = void 0;
 const util_1 = require("@polkadot/util");
 const _1 = require(".");
-const executor_1 = require("../executor");
+const wasm_executor_1 = require("../wasm-executor");
 const set_storage_1 = require("./set-storage");
 const getCurrentSlot = (chain) => __awaiter(void 0, void 0, void 0, function* () {
     const meta = yield chain.head.meta;
@@ -36,7 +36,7 @@ const getSlotDuration = (chain) => __awaiter(void 0, void 0, void 0, function* (
     return meta.consts.babe
         ? meta.consts.babe.expectedBlockTime.toNumber()
         : meta.query.aura
-            ? (0, executor_1.getAuraSlotDuration)(yield chain.head.wasm, meta.registry)
+            ? (0, wasm_executor_1.getAuraSlotDuration)(yield chain.head.wasm, meta.registry)
             : 12000;
 });
 exports.getSlotDuration = getSlotDuration;

package/lib/wasm-executor/browser-wasm-executor.mjs

@@ -0,0 +1,37 @@
+import * as Comlink from 'comlink'
+import * as pkg from '@acala-network/chopsticks-executor'
+
+const getRuntimeVersion = async (code) => {
+	await pkg.wasmReady
+	return pkg.get_runtime_version(code)
+}
+
+// trie_version: 0 for old trie, 1 for new trie
+const calculateStateRoot = async (entries, trie_version) => {
+	await pkg.wasmReady
+	return pkg.calculate_state_root(entries, trie_version)
+}
+
+const decodeProof = async (trieRootHash, keys, nodes) => {
+	await pkg.wasmReady
+	const decoded = await pkg.decode_proof(trieRootHash, keys, nodes)
+	return decoded.reduce((accum, [key, value]) => {
+		accum[key] = value
+		return accum
+	}, {})
+}
+
+const createProof = async (nodes, entries) => {
+	await pkg.wasmReady
+	const result = await pkg.create_proof(nodes, entries)
+	return { trieRootHash: result[0], nodes: result[1] }
+}
+
+const runTask = async (task, callback) => {
+	await pkg.wasmReady
+	return pkg.run_task(task, callback, 'info')
+}
+
+const wasmExecutor = { runTask, getRuntimeVersion, calculateStateRoot, createProof, decodeProof }
+
+Comlink.expose(wasmExecutor)

package/lib/wasm-executor/browser-worker.d.ts

@@ -0,0 +1,5 @@
+import type { WasmExecutor } from '.';
+export declare const startWorker: () => Promise<{
+    remote: import("comlink").Remote<WasmExecutor>;
+    terminate: () => Promise<void>;
+}>;

package/lib/wasm-executor/browser-worker.js

@@ -0,0 +1,28 @@
+"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 });
+exports.startWorker = void 0;
+const comlink_1 = require("comlink");
+const startWorker = () => __awaiter(void 0, void 0, void 0, function* () {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    const worker = new Worker(new URL('browser-wasm-executor.mjs', import.meta.url), {
+        type: 'module',
+        name: 'chopsticks-wasm-executor',
+    });
+    return {
+        remote: (0, comlink_1.wrap)(worker),
+        terminate: () => __awaiter(void 0, void 0, void 0, function* () {
+            worker.terminate();
+        }),
+    };
+});
+exports.startWorker = startWorker;

package/lib/{executor.d.ts → wasm-executor/index.d.ts}

@@ -1,7 +1,7 @@
 import { HexString } from '@polkadot/util/types';
-import { Block } from './blockchain/block';
 import { Registry } from '@polkadot/types-codec/types';
 import _ from 'lodash';
+import { Block } from '../blockchain/block';
 import type { JsCallback } from '@acala-network/chopsticks-executor';
 export { JsCallback };
 export type RuntimeVersion = {
@@ -14,6 +14,22 @@ export type RuntimeVersion = {
     transactionVersion: number;
     stateVersion: number;
 };
+export interface WasmExecutor {
+    getRuntimeVersion: (code: HexString) => Promise<RuntimeVersion>;
+    calculateStateRoot: (entries: [HexString, HexString][], trie_version: number) => Promise<HexString>;
+    createProof: (nodes: HexString[], entries: [HexString, HexString | null][]) => Promise<{
+        trieRootHash: `0x${string}`;
+        nodes: `0x${string}`[];
+    }>;
+    decodeProof: (trieRootHash: HexString, keys: HexString[], nodes: HexString[]) => Promise<Record<`0x${string}`, `0x${string}` | null>>;
+    runTask: (task: {
+        wasm: HexString;
+        calls: [string, HexString[]][];
+        mockSignatureHost: boolean;
+        allowUnresolvedImports: boolean;
+        runtimeLogLevel: number;
+    }, callback?: JsCallback) => Promise<any>;
+}
 export declare const getRuntimeVersion: (code: HexString) => Promise<RuntimeVersion>;
 export declare const calculateStateRoot: (entries: [HexString, HexString][], trie_version: number) => Promise<HexString>;
 export declare const decodeProof: (trieRootHash: HexString, keys: HexString[], nodes: HexString[]) => Promise<Record<`0x${string}`, `0x${string}` | null>>;
@@ -39,3 +55,4 @@ export declare const emptyTaskHandler: {
     offchainSubmitTransaction: (_tx: HexString) => Promise<never>;
 };
 export declare const getAuraSlotDuration: ((wasm: HexString, registry: Registry) => Promise<number>) & _.MemoizedFunction;
+export declare const releaseWorker: () => Promise<void>;