@acala-network/chopsticks 0.2.2 → 0.3.0

package/dist/setup.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setup = void 0;
+require("@polkadot/types-codec");
+const api_1 = require("@polkadot/api");
+const api_2 = require("./api");
+const blockchain_1 = require("./blockchain");
+const genesis_provider_1 = require("./genesis-provider");
+const inherent_1 = require("./blockchain/inherent");
+const logger_1 = require("./logger");
+const import_storage_1 = require("./utils/import-storage");
+const db_1 = require("./db");
+const time_travel_1 = require("./utils/time-travel");
+const setup = async (argv) => {
+    let provider;
+    if (argv.genesis) {
+        if (typeof argv.genesis === 'string') {
+            provider = await genesis_provider_1.GenesisProvider.fromUrl(argv.genesis);
+        }
+        else {
+            provider = new genesis_provider_1.GenesisProvider(argv.genesis);
+        }
+    }
+    else {
+        provider = new api_1.WsProvider(argv.endpoint);
+    }
+    const api = new api_2.Api(provider);
+    await api.isReady;
+    let blockHash;
+    if (argv.block == null) {
+        blockHash = await api.getBlockHash();
+    }
+    else if (Number.isInteger(argv.block)) {
+        blockHash = await api.getBlockHash(Number(argv.block));
+    }
+    else {
+        blockHash = argv.block;
+    }
+    logger_1.defaultLogger.debug({ ...argv, blockHash }, 'Args');
+    let db;
+    if (argv.db) {
+        db = await (0, db_1.openDb)(argv.db);
+    }
+    const header = await api.getHeader(blockHash);
+    const inherents = new inherent_1.InherentProviders(new inherent_1.SetTimestamp(), [new inherent_1.SetValidationData(), new inherent_1.ParaInherentEnter()]);
+    const chain = new blockchain_1.Blockchain({
+        api,
+        buildBlockMode: argv['build-block-mode'],
+        inherentProvider: inherents,
+        db,
+        header: {
+            hash: blockHash,
+            number: Number(header.number),
+        },
+    });
+    if (argv.timestamp)
+        await (0, time_travel_1.timeTravel)(chain, argv.timestamp);
+    await (0, import_storage_1.importStorage)(chain, argv['import-storage']);
+    await (0, import_storage_1.overrideWasm)(chain, argv['wasm-override']);
+    return { chain, api, ws: provider };
+};
+exports.setup = setup;

package/dist/utils/index.d.ts

@@ -1,7 +1,9 @@
 import { HexString } from '@polkadot/util/types';
 import { StorageKey } from '@polkadot/types';
+import { Blockchain } from '../blockchain';
 export type GetKeys = (startKey?: string) => Promise<StorageKey<any>[]>;
 export type ProcessKey = (key: StorageKey<any>) => any;
 export declare function fetchKeys(getKeys: GetKeys, processKey: ProcessKey): Promise<void>;
 export declare function fetchKeysToArray(getKeys: GetKeys): Promise<StorageKey<any>[]>;
 export declare const compactHex: (value: Uint8Array) => HexString;
+export declare const getParaId: (chain: Blockchain) => Promise<import("@polkadot/types").u32>;

package/dist/utils/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compactHex = exports.fetchKeysToArray = exports.fetchKeys = void 0;
+exports.getParaId = exports.compactHex = exports.fetchKeysToArray = exports.fetchKeys = void 0;
 const util_1 = require("@polkadot/util");
 async function fetchKeys(getKeys, processKey) {
     const processKeys = async (keys) => {
@@ -30,3 +30,11 @@ const compactHex = (value) => {
     return (0, util_1.u8aToHex)((0, util_1.compactStripLength)(value)[1]);
 };
 exports.compactHex = compactHex;
+const getParaId = async (chain) => {
+    const meta = await chain.head.meta;
+    const raw = await chain.head.get((0, exports.compactHex)(meta.query.parachainInfo.parachainId()));
+    if (!raw)
+        throw new Error('Cannot find parachain id');
+    return meta.registry.createType('u32', (0, util_1.hexToU8a)(raw));
+};
+exports.getParaId = getParaId;

package/dist/utils/proof.d.ts

@@ -1,7 +1,15 @@
-import { HexString } from '@polkadot/util/types';
+import { HrmpChannelId } from '@polkadot/types/interfaces';
 import { u32 } from '@polkadot/types';
-export declare const WELL_KNOWN_KEYS: Record<string, HexString>;
+export declare const WELL_KNOWN_KEYS: {
+    EPOCH_INDEX: `0x${string}`;
+    CURRENT_BLOCK_RANDOMNESS: `0x${string}`;
+    ONE_EPOCH_AGO_RANDOMNESS: `0x${string}`;
+    TWO_EPOCHS_AGO_RANDOMNESS: `0x${string}`;
+    CURRENT_SLOT: `0x${string}`;
+    ACTIVE_CONFIG: `0x${string}`;
+};
 export declare const dmqMqcHead: (paraId: u32) => `0x${string}`;
 export declare const upgradeGoAheadSignal: (paraId: u32) => `0x${string}`;
 export declare const hrmpIngressChannelIndex: (paraId: u32) => `0x${string}`;
 export declare const hrmpEgressChannelIndex: (paraId: u32) => `0x${string}`;
+export declare const hrmpChannels: (channelId: HrmpChannelId) => `0x${string}`;

package/dist/utils/proof.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hrmpEgressChannelIndex = exports.hrmpIngressChannelIndex = exports.upgradeGoAheadSignal = exports.dmqMqcHead = exports.WELL_KNOWN_KEYS = void 0;
+exports.hrmpChannels = exports.hrmpEgressChannelIndex = exports.hrmpIngressChannelIndex = exports.upgradeGoAheadSignal = exports.dmqMqcHead = exports.WELL_KNOWN_KEYS = void 0;
 const util_1 = require("@polkadot/util");
 const util_crypto_1 = require("@polkadot/util-crypto");
 exports.WELL_KNOWN_KEYS = {
@@ -11,27 +11,31 @@ exports.WELL_KNOWN_KEYS = {
     CURRENT_SLOT: '0x1cb6f36e027abb2091cfb5110ab5087f06155b3cd9a8c9e5e9a23fd5dc13a5ed',
     ACTIVE_CONFIG: '0x06de3d8a54d27e44a9d5ce189618f22db4b49d95320d9021994c850f25b8e385',
 };
-const prefixWithParaId = (prefix, paraId) => {
-    const id = paraId.toU8a();
-    return (0, util_1.u8aToHex)((0, util_1.u8aConcat)((0, util_1.hexToU8a)(prefix), (0, util_crypto_1.xxhashAsU8a)(id, 64), id));
+const hash = (prefix, suffix) => {
+    return (0, util_1.u8aToHex)((0, util_1.u8aConcat)((0, util_1.hexToU8a)(prefix), (0, util_crypto_1.xxhashAsU8a)(suffix, 64), suffix));
 };
 const dmqMqcHead = (paraId) => {
     const prefix = '0x63f78c98723ddc9073523ef3beefda0c4d7fefc408aac59dbfe80a72ac8e3ce5';
-    return prefixWithParaId(prefix, paraId);
+    return hash(prefix, paraId.toU8a());
 };
 exports.dmqMqcHead = dmqMqcHead;
 const upgradeGoAheadSignal = (paraId) => {
     const prefix = '0xcd710b30bd2eab0352ddcc26417aa1949e94c040f5e73d9b7addd6cb603d15d3';
-    return prefixWithParaId(prefix, paraId);
+    return hash(prefix, paraId.toU8a());
 };
 exports.upgradeGoAheadSignal = upgradeGoAheadSignal;
 const hrmpIngressChannelIndex = (paraId) => {
     const prefix = '0x6a0da05ca59913bc38a8630590f2627c1d3719f5b0b12c7105c073c507445948';
-    return prefixWithParaId(prefix, paraId);
+    return hash(prefix, paraId.toU8a());
 };
 exports.hrmpIngressChannelIndex = hrmpIngressChannelIndex;
 const hrmpEgressChannelIndex = (paraId) => {
     const prefix = '0x6a0da05ca59913bc38a8630590f2627cf12b746dcf32e843354583c9702cc020';
-    return prefixWithParaId(prefix, paraId);
+    return hash(prefix, paraId.toU8a());
 };
 exports.hrmpEgressChannelIndex = hrmpEgressChannelIndex;
+const hrmpChannels = (channelId) => {
+    const prefix = '0x6a0da05ca59913bc38a8630590f2627cb6604cff828a6e3f579ca6c59ace013d';
+    return hash(prefix, channelId.toU8a());
+};
+exports.hrmpChannels = hrmpChannels;

package/dist/utils/set-storage.d.ts

@@ -1,6 +1,7 @@
+import { HexString } from '@polkadot/util/types';
 import { Blockchain } from '../blockchain';
 type RawStorageValues = [string, string | null][];
 type StorageConfig = Record<string, Record<string, any>>;
 export type StorageValues = RawStorageValues | StorageConfig;
-export declare const setStorage: (chain: Blockchain, storage: StorageValues, blockHash?: string) => Promise<string>;
+export declare const setStorage: (chain: Blockchain, storage: StorageValues, blockHash?: HexString) => Promise<HexString>;
 export {};

package/dist/utils/set-storage.js

@@ -49,7 +49,7 @@ const setStorage = async (chain, storage, blockHash) => {
         storageItems = storage;
     }
     else {
-        storageItems = objectToStorageItems(await block.withAvoidTasks(() => block.meta), storage);
+        storageItems = objectToStorageItems(await block.meta, storage);
     }
     block.pushStorageLayer().setAll(storageItems);
     return block.hash;

package/dist/utils/time-travel.d.ts

@@ -0,0 +1,5 @@
+import { Blockchain } from '../blockchain';
+export declare const getCurrentSlot: (chain: Blockchain) => Promise<number>;
+export declare const getCurrentTimestamp: (chain: Blockchain) => Promise<number>;
+export declare const getSlotDuration: (chain: Blockchain) => Promise<number>;
+export declare const timeTravel: (chain: Blockchain, timestamp: number) => Promise<void>;

package/dist/utils/time-travel.js

@@ -0,0 +1,64 @@
+"use strict";
+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 set_storage_1 = require("./set-storage");
+const getCurrentSlot = async (chain) => {
+    const meta = await chain.head.meta;
+    const slotRaw = meta.consts.babe
+        ? await chain.head.get((0, _1.compactHex)(meta.query.babe.currentSlot()))
+        : await chain.head.get((0, _1.compactHex)(meta.query.aura.currentSlot()));
+    if (!slotRaw)
+        throw new Error('Cannot find current slot');
+    return meta.registry.createType('Slot', (0, util_1.hexToU8a)(slotRaw)).toNumber();
+};
+exports.getCurrentSlot = getCurrentSlot;
+const getCurrentTimestamp = async (chain) => {
+    const meta = await chain.head.meta;
+    const currentTimestampRaw = (await chain.head.get((0, _1.compactHex)(meta.query.timestamp.now()))) || '0x';
+    return meta.registry.createType('u64', (0, util_1.hexToU8a)(currentTimestampRaw)).toNumber();
+};
+exports.getCurrentTimestamp = getCurrentTimestamp;
+const getSlotDuration = async (chain) => {
+    const meta = await chain.head.meta;
+    return meta.consts.babe
+        ? meta.consts.babe.expectedBlockTime.toNumber()
+        : meta.query.aura
+            ? (0, executor_1.getAuraSlotDuration)(await chain.head.wasm, meta.registry)
+            : 12_000;
+};
+exports.getSlotDuration = getSlotDuration;
+const timeTravel = async (chain, timestamp) => {
+    const meta = await chain.head.meta;
+    const slotDuration = await (0, exports.getSlotDuration)(chain);
+    const newSlot = Math.floor(timestamp / slotDuration);
+    // new timestamp
+    const storage = [
+        [(0, _1.compactHex)(meta.query.timestamp.now()), (0, util_1.u8aToHex)(meta.registry.createType('u64', timestamp).toU8a())],
+    ];
+    if (meta.consts.babe) {
+        // new slot
+        storage.push([
+            (0, _1.compactHex)(meta.query.babe.currentSlot()),
+            (0, util_1.u8aToHex)(meta.registry.createType('Slot', newSlot).toU8a()),
+        ]);
+        // new epoch
+        const epochDuration = meta.consts.babe.epochDuration.toNumber();
+        const newEpoch = Math.floor(timestamp / epochDuration);
+        storage.push([
+            (0, _1.compactHex)(meta.query.babe.epochIndex()),
+            (0, util_1.u8aToHex)(meta.registry.createType('u64', newEpoch).toU8a()),
+        ]);
+    }
+    else if (meta.query.aura) {
+        // new slot
+        storage.push([
+            (0, _1.compactHex)(meta.query.aura.currentSlot()),
+            (0, util_1.u8aToHex)(meta.registry.createType('Slot', newSlot).toU8a()),
+        ]);
+    }
+    await (0, set_storage_1.setStorage)(chain, storage);
+};
+exports.timeTravel = timeTravel;

package/dist/xcm/index.d.ts

@@ -0,0 +1,3 @@
+import { Blockchain } from '../blockchain';
+export declare const connectDownward: (relaychain: Blockchain, parachain: Blockchain) => Promise<void>;
+export declare const connectParachains: (parachains: Blockchain[]) => Promise<void>;

package/dist/xcm/index.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.connectParachains = exports.connectDownward = void 0;
+const util_1 = require("@polkadot/util");
+const utils_1 = require("../utils");
+const logger_1 = require("../logger");
+const set_storage_1 = require("../utils/set-storage");
+const logger = logger_1.defaultLogger.child({ name: 'xcm' });
+const connectDownward = async (relaychain, parachain) => {
+    const meta = await relaychain.head.meta;
+    const paraId = await (0, utils_1.getParaId)(parachain);
+    const downwardMessageQueuesKey = (0, utils_1.compactHex)(meta.query.dmp.downwardMessageQueues(paraId));
+    await relaychain.headState.subscribeStorage([downwardMessageQueuesKey], async (head, pairs) => {
+        const value = pairs[0][1];
+        if (!value)
+            return;
+        const meta = await relaychain.head.meta;
+        const downwardMessageQueuesKey = (0, utils_1.compactHex)(meta.query.dmp.downwardMessageQueues(paraId));
+        // clear relaychain message queue
+        await (0, set_storage_1.setStorage)(relaychain, [[downwardMessageQueuesKey, null]], head.hash);
+        const downwardMessages = meta.registry
+            .createType('Vec<PolkadotCorePrimitivesInboundDownwardMessage>', (0, util_1.hexToU8a)(value))
+            .toJSON();
+        logger.debug({ downwardMessages }, 'downward_message');
+        await parachain.newBlock({ inherent: { downwardMessages } });
+    });
+    logger.info(`Connected relaychain '${await relaychain.api.getSystemChain()}' with parachain '${await parachain.api.getSystemChain()}'`);
+};
+exports.connectDownward = connectDownward;
+const connectParachains = async (parachains) => {
+    const list = {};
+    for (const chain of parachains) {
+        const paraId = await (0, utils_1.getParaId)(chain);
+        list[paraId.toNumber()] = chain;
+    }
+    await connectHorizontal(list);
+    logger.info('Parachains connected');
+};
+exports.connectParachains = connectParachains;
+const connectHorizontal = async (parachains) => {
+    for (const [id, chain] of Object.entries(parachains)) {
+        const meta = await chain.head.meta;
+        const hrmpOutboundMessagesKey = (0, utils_1.compactHex)(meta.query.parachainSystem.hrmpOutboundMessages());
+        await chain.headState.subscribeStorage([hrmpOutboundMessagesKey], async (head, pairs) => {
+            const value = pairs[0][1];
+            if (!value)
+                return;
+            const meta = await chain.head.meta;
+            const hrmpOutboundMessagesKey = (0, utils_1.compactHex)(meta.query.parachainSystem.hrmpOutboundMessages());
+            // clear sender message queue
+            await (0, set_storage_1.setStorage)(chain, [[hrmpOutboundMessagesKey, null]], head.hash);
+            const outboundHrmpMessage = meta.registry
+                .createType('Vec<PolkadotCorePrimitivesOutboundHrmpMessage>', (0, util_1.hexToU8a)(value))
+                .toJSON();
+            logger.info({ outboundHrmpMessage }, 'outboundHrmpMessage');
+            for (const { recipient, data } of outboundHrmpMessage) {
+                const horizontalMessages = {
+                    [Number(id)]: [{ sentAt: chain.head.number, data }],
+                };
+                const receiver = parachains[recipient];
+                if (receiver) {
+                    await receiver.newBlock({ inherent: { horizontalMessages } });
+                }
+            }
+        });
+    }
+};

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@acala-network/chopsticks",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "author": "Bryan Chen <xlchen1291@gmail.com>",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "packageManager": "yarn@3.2.4",
   "workspaces": [
     ".",
@@ -17,18 +17,17 @@
     "prepare": "husky install",
     "start": "ts-node --transpile-only src/index.ts",
     "build": "rimraf dist && tsc -p tsconfig.prod.json",
-    "build-wasm": "cd executor && wasm-pack --log-level=info build --target nodejs --no-default-features --scope acala-network",
+    "build-wasm": "wasm-pack build executor --target nodejs --scope acala-network",
+    "build-wasm-logging": "yarn build-wasm --features=logging",
     "check": "cd executor && cargo check --locked",
     "test": "vitest --silent",
-    "test:native": "EXECUTOR_CMD='cargo run --manifest-path executor/Cargo.toml --' vitest",
     "test:dev": "LOG_LEVEL=trace vitest --inspect",
     "dev": "LOG_LEVEL=trace ts-node-dev --transpile-only --inspect --notify=false src/index.ts -- dev --config=configs/dev.yml",
-    "dev:native": "yarn dev --executor-cmd='cargo run --manifest-path executor/Cargo.toml --'",
     "dev:karura": "ts-node-dev --transpile-only --inspect --notify=false src/index.ts -- dev --config=configs/karura.yml",
     "dev:acala": "ts-node-dev --transpile-only --inspect --notify=false src/index.ts -- dev --config=configs/acala.yml"
   },
   "dependencies": {
-    "@acala-network/chopsticks-executor": "0.2.2",
+    "@acala-network/chopsticks-executor": "0.2.3",
     "@polkadot/api": "^9.10.1",
     "@polkadot/rpc-provider": "^9.10.1",
     "@polkadot/types": "^9.10.1",
@@ -36,7 +35,7 @@
     "@polkadot/types-known": "^9.10.1",
     "@polkadot/util": "^10.2.1",
     "@polkadot/util-crypto": "^10.2.1",
-    "axios": "^1.2.1",
+    "axios": "^1.2.2",
     "js-yaml": "^4.1.0",
     "lodash": "^4.17.21",
     "pino": "^8.7.0",
@@ -52,13 +51,13 @@
   "devDependencies": {
     "@types/js-yaml": "^4.0.5",
     "@types/lodash": "^4.14.191",
-    "@types/node": "^18.11.10",
+    "@types/node": "^18.11.18",
     "@types/rimraf": "^3",
     "@types/ws": "^8.5.3",
-    "@types/yargs": "^17.0.15",
+    "@types/yargs": "^17.0.18",
     "@typescript-eslint/eslint-plugin": "^5.45.0",
     "@typescript-eslint/parser": "^5.45.0",
-    "eslint": "^8.29.0",
+    "eslint": "^8.31.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-import": "^2.26.0",
     "eslint-plugin-sort-imports-es6-autofix": "^0.6.0",

package/dist/blockchain/inherents.d.ts

@@ -1,26 +0,0 @@
-import { Block } from './block';
-import { DecoratedMeta } from '@polkadot/types/metadata/decorate/types';
-import { TaskManager } from '../task';
-export interface CreateInherents {
-    createInherents(meta: DecoratedMeta, timestamp: number, parent: Block): Promise<string[]>;
-}
-export interface InherentProvider extends CreateInherents {
-    getTimestamp(blockNumber: number): number;
-}
-export declare class SetTimestamp implements InherentProvider {
-    #private;
-    constructor(getTimestamp?: (blockNumber: number) => number);
-    createInherents(meta: DecoratedMeta, timestamp: number, _parent: Block): Promise<string[]>;
-    getTimestamp(blockNumber: number): number;
-}
-export declare class InherentProviders implements InherentProvider {
-    #private;
-    constructor(base: InherentProvider, providers: CreateInherents[]);
-    createInherents(meta: DecoratedMeta, timestamp: number, parent: Block): Promise<string[]>;
-    getTimestamp(blockNumber: number): number;
-}
-export declare class SetValidationData implements CreateInherents {
-    #private;
-    constructor(tasks: TaskManager, expectedIndex: number);
-    createInherents(meta: DecoratedMeta, _timestamp: number, parent: Block): Promise<string[]>;
-}

package/dist/rpc/exec.d.ts

@@ -1,3 +0,0 @@
-import { Handlers } from './shared';
-declare const handlers: Handlers;
-export default handlers;

package/dist/rpc/exec.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const shared_1 = require("./shared");
-const logger_1 = require("../logger");
-const logger = logger_1.defaultLogger.child({ name: 'rpc-exec' });
-const handlers = {
-    exec_storageGet: async (context, [_taskId, blockHash, key]) => {
-        const block = await context.chain.getBlock(blockHash);
-        if (!block) {
-            throw new shared_1.ResponseError(1, `Block not found ${blockHash}`);
-        }
-        const value = await block.get(key);
-        logger.trace({ blockHash, key, value: (0, logger_1.truncate)(value) }, 'exec_storageGet');
-        return value;
-    },
-    exec_prefixKeys: async (context, [_taskId, blockHash, key]) => {
-        const block = await context.chain.getBlock(blockHash);
-        if (!block) {
-            throw new shared_1.ResponseError(1, `Block not found ${blockHash}`);
-        }
-        return block.getKeysPaged({ prefix: key, pageSize: 1000, startKey: key });
-    },
-    exec_nextKey: async (context, [_taskId, blockHash, key]) => {
-        const block = await context.chain.getBlock(blockHash);
-        if (!block) {
-            throw new shared_1.ResponseError(1, `Block not found ${blockHash}`);
-        }
-        const res = await block.getKeysPaged({ prefix: key, pageSize: 1, startKey: key });
-        return res[0] || null;
-    },
-    exec_getTask: async (context, [taskId]) => {
-        logger.trace({ taskId }, 'exec_getTask');
-        const task = context.tasks.getTask(Number(taskId));
-        if (!task) {
-            throw new shared_1.ResponseError(1, `Task not found ${taskId}`);
-        }
-        return task.task;
-    },
-    exec_taskResult: async (context, [taskId, resp]) => {
-        logger.trace({ taskId }, 'exec_taskResult');
-        context.tasks.getTask(Number(taskId))?.callback(resp);
-    },
-};
-exports.default = handlers;

package/dist/task.d.ts

@@ -1,38 +0,0 @@
-export interface TaskResponseCall {
-    Call: {
-        result: `0x${string}}`;
-        storageDiff: [`0x${string}}`, `0x${string}}` | null][];
-    };
-}
-export interface TaskResponseError {
-    Error: string;
-}
-export type TaskResponse = TaskResponseCall | TaskResponseError;
-interface TaskCall {
-    wasm: string;
-    blockHash: string;
-    calls: [string, string][];
-    mockSignatureHost?: boolean;
-    allowUnresolvedImports?: boolean;
-}
-interface TaskCalculateStateRoot {
-    entries: [string, string][];
-}
-type Task = {
-    Call: TaskCall;
-} | {
-    CalculateStateRoot: TaskCalculateStateRoot;
-};
-export declare class TaskManager {
-    #private;
-    constructor(listeningPort: number, mockSignatureHost?: boolean, executorCmd?: string, allowUnresolvedImports?: boolean);
-    updateListeningPort(port: number): void;
-    addTask(task: Task, callback?: (res: TaskResponse) => any): number;
-    getTask(taskId: number): {
-        task: Task;
-        callback: (res: TaskResponse) => any;
-    };
-    runTask(taskId: number): Promise<void>;
-    addAndRunTask(task: Task, callback?: (res: TaskResponse) => any): Promise<void>;
-}
-export {};

package/dist/task.js

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskManager = void 0;
-const node_child_process_1 = require("node:child_process");
-const logger_1 = require("./logger");
-const executor_1 = require("./executor");
-const logger = logger_1.defaultLogger.child({ name: 'task' });
-class TaskManager {
-    #tasks = [];
-    #listeningPort;
-    #mockSignatureHost;
-    #executorCmd;
-    #allowUnresolvedImports;
-    constructor(listeningPort, mockSignatureHost = false, executorCmd, allowUnresolvedImports = false) {
-        this.#listeningPort = listeningPort;
-        this.#mockSignatureHost = mockSignatureHost;
-        this.#executorCmd = executorCmd;
-        this.#allowUnresolvedImports = allowUnresolvedImports;
-        if (this.#mockSignatureHost) {
-            logger.info('Mock signature host enabled');
-        }
-        if (this.#allowUnresolvedImports) {
-            logger.info('Allow unresolved imports enabled. Wasm may expect more host functions, but will not fail on load');
-        }
-    }
-    updateListeningPort(port) {
-        this.#listeningPort = port;
-    }
-    addTask(task, callback = () => { }) {
-        logger.debug({
-            kind: Object.keys(task)[0],
-            port: this.#listeningPort,
-        }, 'AddTask');
-        if ('Call' in task && task.Call.mockSignatureHost === undefined) {
-            task.Call.mockSignatureHost = this.#mockSignatureHost;
-        }
-        if ('Call' in task && task.Call.allowUnresolvedImports === undefined) {
-            task.Call.allowUnresolvedImports = this.#allowUnresolvedImports;
-        }
-        this.#tasks.push({ task, callback });
-        return this.#tasks.length - 1;
-    }
-    getTask(taskId) {
-        return this.#tasks[taskId];
-    }
-    runTask(taskId) {
-        if (this.#executorCmd) {
-            const cmd = `${this.#executorCmd} --runner-url=ws://localhost:${this.#listeningPort} --task-id=${taskId}`;
-            logger.info({ taskId, cmd }, 'RunTask');
-            const p = (0, node_child_process_1.spawn)(cmd, { shell: true, stdio: 'inherit' });
-            return new Promise((resolve) => {
-                p.once('exit', (code) => {
-                    logger.debug({ taskId, code }, 'RunTask done');
-                    resolve();
-                });
-            });
-        }
-        else {
-            return (0, executor_1.runTask)(taskId, `ws://localhost:${this.#listeningPort}`);
-        }
-    }
-    async addAndRunTask(task, callback = () => { }) {
-        const taskId = this.addTask(task, callback);
-        await this.runTask(taskId);
-    }
-}
-exports.TaskManager = TaskManager;