@acala-network/chopsticks 0.2.1 → 0.2.3

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/dist/bindings.d.ts

@@ -0,0 +1,2 @@
+import { Blockchain } from './blockchain';
+export declare const setupBindings: (chain: Blockchain) => void;

package/dist/bindings.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupBindings = void 0;
+const logger_1 = require("./logger");
+const logger = logger_1.defaultLogger.child({ name: 'binding' });
+const setupBindings = (chain) => {
+    global._chopsticks_binding_ = {
+        getStorage: async function (blockHash, key) {
+            const block = await chain.getBlock(blockHash);
+            if (!block)
+                throw Error(`Block not found ${blockHash}`);
+            const value = await block.get(key);
+            logger.trace({ blockHash, key, value: value && (0, logger_1.truncate)(value) }, 'exec_storageGet');
+            return value;
+        },
+        getPrefixKeys: async function (blockHash, key) {
+            const block = await chain.getBlock(blockHash);
+            if (!block)
+                throw Error(`Block not found ${blockHash}`);
+            return block.getKeysPaged({ prefix: key, pageSize: 1000, startKey: key });
+        },
+        getNextKey: async function (blockHash, key) {
+            const block = await chain.getBlock(blockHash);
+            if (!block)
+                throw Error(`Block not found ${blockHash}`);
+            const keys = await block.getKeysPaged({ prefix: key, pageSize: 1, startKey: key });
+            return keys.length > 0 ? keys[0] : '0x';
+        },
+    };
+};
+exports.setupBindings = setupBindings;

package/dist/blockchain/block.d.ts

@@ -4,19 +4,22 @@ import { TypeRegistry } from '@polkadot/types';
 import type { HexString } from '@polkadot/util/types';
 import { Blockchain } from '.';
 import { StorageLayer, StorageLayerProvider } from './storage-layer';
-import { TaskResponseCall } from '../task';
 import type { RuntimeVersion } from '../executor';
+export type TaskCallResponse = {
+    result: HexString;
+    storageDiff: [HexString, HexString | null][];
+};
 export declare class Block {
     #private;
     readonly number: number;
     readonly hash: string;
     constructor(chain: Blockchain, number: number, hash: string, parentBlock?: Block, block?: {
         header: Header;
-        extrinsics: string[];
+        extrinsics: HexString[];
         storage?: StorageLayerProvider;
     });
     get header(): Header | Promise<Header>;
-    get extrinsics(): string[] | Promise<string[]>;
+    get extrinsics(): HexString[] | Promise<HexString[]>;
     get parentBlock(): undefined | Block | Promise<Block | undefined>;
     get storage(): StorageLayerProvider;
     get(key: string): Promise<string | undefined>;
@@ -33,7 +36,6 @@ export declare class Block {
     get registry(): Promise<TypeRegistry>;
     get runtimeVersion(): Promise<RuntimeVersion>;
     get metadata(): Promise<HexString>;
-    withAvoidTasks<T>(fn: () => Promise<T>): Promise<T>;
     get meta(): Promise<DecoratedMeta>;
-    call(method: string, args: string): Promise<TaskResponseCall['Call']>;
+    call(method: string, args: HexString, storage?: [HexString, HexString | null][]): Promise<TaskCallResponse>;
 }

package/dist/blockchain/block.js

@@ -6,7 +6,6 @@ const metadata_1 = require("@polkadot/types/metadata");
 const util_1 = require("@polkadot/types-known/util");
 const util_2 = require("@polkadot/util");
 const storage_layer_1 = require("./storage-layer");
-const shared_1 = require("../rpc/shared");
 const utils_1 = require("../utils");
 const executor_1 = require("../executor");
 class Block {
@@ -23,7 +22,6 @@ class Block {
     #meta;
     #baseStorage;
     #storages;
-    #avoidTasks = false;
     constructor(chain, number, hash, parentBlock, block) {
         this.number = number;
         this.hash = hash;
@@ -140,51 +138,20 @@ class Block {
     }
     get metadata() {
         if (!this.#metadata) {
-            if (this.#avoidTasks) {
-                this.#metadata = this.wasm.then(executor_1.getMetadata);
-            }
-            else {
-                this.#metadata = this.wasm.then(async (wasm) => {
-                    const res = await new Promise((resolve, reject) => {
-                        this.#chain.tasks.addAndRunTask({
-                            Call: {
-                                blockHash: this.hash,
-                                wasm,
-                                calls: [['Metadata_metadata', '0x']],
-                            },
-                        }, (r) => {
-                            if ('Call' in r) {
-                                resolve((0, utils_1.compactHex)((0, util_2.hexToU8a)(r.Call.result)));
-                            }
-                            else if ('Error' in r) {
-                                reject(new shared_1.ResponseError(1, r.Error));
-                            }
-                            else {
-                                reject(new shared_1.ResponseError(1, 'Unexpected response'));
-                            }
-                        });
-                    });
-                    return res;
+            this.#metadata = this.wasm.then(async (wasm) => {
+                const response = await (0, executor_1.runTask)({
+                    blockHash: this.hash,
+                    wasm,
+                    calls: [['Metadata_metadata', '0x']],
+                    storage: [],
+                    mockSignatureHost: this.#chain.mockSignatureHost,
+                    allowUnresolvedImports: this.#chain.allowUnresolvedImports,
                 });
-            }
+                return (0, utils_1.compactHex)((0, util_2.hexToU8a)(response.Call.result));
+            });
         }
         return this.#metadata;
     }
-    // TODO: avoid this hack
-    // we cannot use this.#chain.tasks during initialization phase
-    // but we want to use it after initialization
-    async withAvoidTasks(fn) {
-        const old = this.#avoidTasks;
-        this.#avoidTasks = true;
-        try {
-            return await fn();
-        }
-        finally {
-            this.#avoidTasks = old;
-            this.#meta = undefined;
-            this.#metadata = undefined;
-        }
-    }
     get meta() {
         if (!this.#meta) {
             this.#meta = Promise.all([this.registry, this.metadata]).then(([registry, metadataStr]) => {
@@ -194,28 +161,21 @@ class Block {
         }
         return this.#meta;
     }
-    async call(method, args) {
+    async call(method, args, storage = []) {
         const wasm = await this.wasm;
-        const res = await new Promise((resolve, reject) => {
-            this.#chain.tasks.addAndRunTask({
-                Call: {
-                    blockHash: this.hash,
-                    wasm,
-                    calls: [[method, args]],
-                },
-            }, (r) => {
-                if ('Call' in r) {
-                    resolve(r.Call);
-                }
-                else if ('Error' in r) {
-                    reject(new shared_1.ResponseError(1, r.Error));
-                }
-                else {
-                    reject(new shared_1.ResponseError(1, 'Unexpected response'));
-                }
-            });
+        const response = await (0, executor_1.runTask)({
+            blockHash: this.hash,
+            wasm,
+            calls: [[method, args]],
+            storage,
+            mockSignatureHost: this.#chain.mockSignatureHost,
+            allowUnresolvedImports: this.#chain.allowUnresolvedImports,
         });
-        return res;
+        if (response.Call)
+            return response.Call;
+        if (response.Error)
+            throw Error(response.Error);
+        throw Error('Unexpected response');
     }
 }
 exports.Block = Block;

package/dist/blockchain/index.d.ts

@@ -1,14 +1,13 @@
 import { DataSource } from 'typeorm';
 import { Header } from '@polkadot/types/interfaces';
+import { HexString } from '@polkadot/util/types';
 import { Api } from '../api';
 import { Block } from './block';
 import { BuildBlockMode } from './txpool';
 import { HeadState } from './head-state';
 import { InherentProvider } from './inherents';
-import { TaskManager } from '../task';
 export interface Options {
     api: Api;
-    tasks: TaskManager;
     buildBlockMode?: BuildBlockMode;
     inherentProvider: InherentProvider;
     db?: DataSource;
@@ -16,20 +15,23 @@ export interface Options {
         number: number;
         hash: string;
     };
+    mockSignatureHost?: boolean;
+    allowUnresolvedImports?: boolean;
 }
 export declare class Blockchain {
     #private;
     readonly api: Api;
-    readonly tasks: TaskManager;
     readonly db: DataSource | undefined;
+    readonly mockSignatureHost: boolean;
+    readonly allowUnresolvedImports: boolean;
     readonly headState: HeadState;
-    constructor({ api, tasks, buildBlockMode, inherentProvider, db, header }: Options);
+    constructor({ api, buildBlockMode, inherentProvider, db, header, mockSignatureHost, allowUnresolvedImports, }: Options);
     get head(): Block;
     getBlockAt(number?: number): Promise<Block | undefined>;
     getBlock(hash?: string): Promise<Block | undefined>;
     newTempBlock(parent: Block, header: Header): Block;
     unregisterBlock(block: Block): void;
     setHead(block: Block): void;
-    submitExtrinsic(extrinsic: string): Promise<string>;
+    submitExtrinsic(extrinsic: HexString): Promise<HexString>;
     newBlock(): Promise<Block>;
 }

package/dist/blockchain/index.js

@@ -8,22 +8,26 @@ const txpool_1 = require("./txpool");
 const head_state_1 = require("./head-state");
 const shared_1 = require("../rpc/shared");
 const logger_1 = require("../logger");
+const bindings_1 = require("../bindings");
 const logger = logger_1.defaultLogger.child({ name: 'blockchain' });
 class Blockchain {
     api;
-    tasks;
     db;
+    mockSignatureHost;
+    allowUnresolvedImports;
     #txpool;
     #head;
     #blocksByNumber = [];
     #blocksByHash = {};
     headState;
-    constructor({ api, tasks, buildBlockMode, inherentProvider, db, header }) {
+    constructor({ api, buildBlockMode, inherentProvider, db, header, mockSignatureHost = false, allowUnresolvedImports = false, }) {
         this.api = api;
-        this.tasks = tasks;
         this.db = db;
+        this.mockSignatureHost = mockSignatureHost;
+        this.allowUnresolvedImports = allowUnresolvedImports;
         this.#head = new block_1.Block(this, header.number, header.hash);
         this.#registerBlock(this.#head);
+        (0, bindings_1.setupBindings)(this);
         this.#txpool = new txpool_1.TxPool(this, inherentProvider, buildBlockMode);
         this.headState = new head_state_1.HeadState(this.#head);
     }

package/dist/blockchain/inherents.d.ts

@@ -1,8 +1,8 @@
 import { Block } from './block';
 import { DecoratedMeta } from '@polkadot/types/metadata/decorate/types';
-import { TaskManager } from '../task';
+import { HexString } from '@polkadot/util/types';
 export interface CreateInherents {
-    createInherents(meta: DecoratedMeta, timestamp: number, parent: Block): Promise<string[]>;
+    createInherents(meta: DecoratedMeta, timestamp: number, parent: Block): Promise<HexString[]>;
 }
 export interface InherentProvider extends CreateInherents {
     getTimestamp(blockNumber: number): number;
@@ -10,17 +10,15 @@ export interface InherentProvider extends CreateInherents {
 export declare class SetTimestamp implements InherentProvider {
     #private;
     constructor(getTimestamp?: (blockNumber: number) => number);
-    createInherents(meta: DecoratedMeta, timestamp: number, _parent: Block): Promise<string[]>;
+    createInherents(meta: DecoratedMeta, timestamp: number, _parent: Block): Promise<HexString[]>;
     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[]>;
+    createInherents(meta: DecoratedMeta, timestamp: number, parent: Block): Promise<HexString[]>;
     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[]>;
+    createInherents(meta: DecoratedMeta, _timestamp: number, parent: Block): Promise<HexString[]>;
 }

package/dist/blockchain/inherents.js

@@ -61,17 +61,10 @@ class InherentProviders {
 }
 exports.InherentProviders = InherentProviders;
 class SetValidationData {
-    #tasks;
-    #expectedIndex;
-    constructor(tasks, expectedIndex) {
-        this.#tasks = tasks;
-        this.#expectedIndex = expectedIndex;
-    }
     async createInherents(meta, _timestamp, parent) {
         if (!meta.tx.parachainSystem?.setValidationData) {
             return [];
         }
-        void this.#tasks; // TODO
         const parentBlock = await parent.parentBlock;
         if (!parentBlock) {
             throw new Error('Parent block not found');
@@ -83,8 +76,16 @@ class SetValidationData {
             newData = MOCK_VALIDATION_DATA;
         }
         else {
-            const method = meta.registry.createType('GenericExtrinsic', extrinsics[this.#expectedIndex]);
-            const extrinsic = method.args[0].toJSON();
+            const validationDataExtrinsic = extrinsics.find((extrinsic) => {
+                const firstArg = meta.registry.createType('GenericExtrinsic', extrinsic)?.args?.[0];
+                return firstArg && 'validationData' in firstArg;
+            });
+            if (!validationDataExtrinsic) {
+                throw new Error('Missing validation data from block');
+            }
+            const extrinsic = meta.registry
+                .createType('GenericExtrinsic', validationDataExtrinsic)
+                .args[0].toJSON();
             const newEntries = [];
             const upgrade = await parentBlock.get((0, utils_1.compactHex)(meta.query.parachainSystem.pendingValidationCode()));
             if (upgrade) {

package/dist/blockchain/txpool.d.ts

@@ -1,3 +1,4 @@
+import { HexString } from '@polkadot/util/types';
 import { Blockchain } from '.';
 import { InherentProvider } from './inherents';
 export declare enum BuildBlockMode {
@@ -8,6 +9,6 @@ export declare enum BuildBlockMode {
 export declare class TxPool {
     #private;
     constructor(chain: Blockchain, inherentProvider: InherentProvider, mode?: BuildBlockMode);
-    submitExtrinsic(extrinsic: string): void;
+    submitExtrinsic(extrinsic: HexString): void;
     buildBlock(): Promise<void>;
 }

package/dist/blockchain/txpool.js

@@ -95,7 +95,7 @@ class TxPool {
             expectedSlot,
         }, 'Building block');
         const resp = await newBlock.call('Core_initialize_block', header.toHex());
-        logger.trace(resp.storageDiff, 'Initialize block');
+        logger.trace((0, logger_1.truncateStorageDiff)(resp.storageDiff), 'Initialize block');
         newBlock.pushStorageLayer().setAll(resp.storageDiff);
         if (meta.query.babe?.currentSlot) {
             // TODO: figure out how to generate a valid babe slot digest instead of just modify the data
@@ -108,7 +108,7 @@ class TxPool {
             try {
                 const resp = await newBlock.call('BlockBuilder_apply_extrinsic', extrinsic);
                 newBlock.pushStorageLayer().setAll(resp.storageDiff);
-                logger.trace(resp.storageDiff, 'Applied inherent');
+                logger.trace((0, logger_1.truncateStorageDiff)(resp.storageDiff), 'Applied inherent');
             }
             catch (e) {
                 logger.warn('Failed to apply inherents %o %s', e, e);
@@ -119,7 +119,7 @@ class TxPool {
             try {
                 const resp = await newBlock.call('BlockBuilder_apply_extrinsic', extrinsic);
                 newBlock.pushStorageLayer().setAll(resp.storageDiff);
-                logger.trace(resp.storageDiff, 'Applied extrinsic');
+                logger.trace((0, logger_1.truncateStorageDiff)(resp.storageDiff), 'Applied extrinsic');
             }
             catch (e) {
                 logger.info('Failed to apply extrinsic %o %s', e, e);
@@ -135,7 +135,7 @@ class TxPool {
         }
         const resp2 = await newBlock.call('BlockBuilder_finalize_block', '0x');
         newBlock.pushStorageLayer().setAll(resp2.storageDiff);
-        logger.trace(resp2.storageDiff, 'Finalize block');
+        logger.trace((0, logger_1.truncateStorageDiff)(resp2.storageDiff), 'Finalize block');
         const blockData = registry.createType('Block', {
             header,
             extrinsics,
@@ -146,7 +146,7 @@ class TxPool {
             storage: head.storage,
         });
         const diff = await newBlock.storageDiff();
-        logger.trace(diff, 'Final block');
+        logger.trace(Object.entries(diff).map(([key, value]) => [key, (0, logger_1.truncate)(value)]), 'Final block');
         finalBlock.pushStorageLayer().setAll(diff);
         this.#chain.unregisterBlock(newBlock);
         this.#chain.setHead(finalBlock);

package/dist/executor.d.ts

@@ -1,5 +1,4 @@
 import { HexString } from '@polkadot/util/types';
-import { run_task } from '../executor/pkg';
 export type RuntimeVersion = {
     specName: string;
     implName: string;
@@ -11,11 +10,17 @@ export type RuntimeVersion = {
     stateVersion: number;
 };
 export declare const getRuntimeVersion: (code: HexString) => Promise<RuntimeVersion>;
-export declare const getMetadata: (code: HexString) => Promise<HexString>;
 export declare const calculateStateRoot: (entries: [HexString, HexString][]) => Promise<HexString>;
 export declare const decodeProof: (trieRootHash: HexString, keys: HexString[], nodes: HexString[]) => Promise<Record<`0x${string}`, `0x${string}` | null>>;
 export declare const createProof: (trieRootHash: HexString, nodes: HexString[], entries: [HexString, HexString][]) => Promise<{
     trieRootHash: `0x${string}`;
     nodes: `0x${string}`[];
 }>;
-export { run_task as runTask };
+export declare const runTask: (task: {
+    blockHash: HexString;
+    wasm: HexString;
+    calls: [string, HexString][];
+    storage: [HexString, HexString | null][];
+    mockSignatureHost: boolean;
+    allowUnresolvedImports: boolean;
+}) => Promise<any>;

package/dist/executor.js

@@ -1,26 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runTask = exports.createProof = exports.decodeProof = exports.calculateStateRoot = exports.getMetadata = exports.getRuntimeVersion = void 0;
+exports.runTask = exports.createProof = exports.decodeProof = exports.calculateStateRoot = exports.getRuntimeVersion = void 0;
 const ws_1 = require("ws");
 const util_1 = require("@polkadot/util");
 global.WebSocket = ws_1.WebSocket;
-const pkg_1 = require("../executor/pkg");
-Object.defineProperty(exports, "runTask", { enumerable: true, get: function () { return pkg_1.run_task; } });
-const utils_1 = require("./utils");
+const chopsticks_executor_1 = require("@acala-network/chopsticks-executor");
+const logger_1 = require("./logger");
+const logger = logger_1.defaultLogger.child({ name: 'executor' });
 const getRuntimeVersion = async (code) => {
-    return (0, pkg_1.get_runtime_version)(code).then((version) => {
+    return (0, chopsticks_executor_1.get_runtime_version)(code).then((version) => {
         version.specName = (0, util_1.hexToString)(version.specName);
         version.implName = (0, util_1.hexToString)(version.implName);
         return version;
     });
 };
 exports.getRuntimeVersion = getRuntimeVersion;
-const getMetadata = async (code) => {
-    return (0, utils_1.compactHex)((0, util_1.hexToU8a)(await (0, pkg_1.get_metadata)(code)));
-};
-exports.getMetadata = getMetadata;
 const calculateStateRoot = async (entries) => {
-    return (0, pkg_1.calculate_state_root)(entries);
+    return (0, chopsticks_executor_1.calculate_state_root)(entries);
 };
 exports.calculateStateRoot = calculateStateRoot;
 const nodesAddLength = (nodes) => {
@@ -28,7 +24,7 @@ const nodesAddLength = (nodes) => {
     return (0, util_1.u8aToHex)((0, util_1.u8aConcatStrict)([(0, util_1.compactToU8a)(nodesWithLength.length), (0, util_1.u8aConcat)(...nodesWithLength)]));
 };
 const decodeProof = async (trieRootHash, keys, nodes) => {
-    const decoded = await (0, pkg_1.decode_proof)(trieRootHash, keys, nodesAddLength(nodes));
+    const decoded = await (0, chopsticks_executor_1.decode_proof)(trieRootHash, keys, nodesAddLength(nodes));
     return decoded.reduce((accum, [key, value]) => {
         accum[key] = value;
         return accum;
@@ -36,7 +32,19 @@ const decodeProof = async (trieRootHash, keys, nodes) => {
 };
 exports.decodeProof = decodeProof;
 const createProof = async (trieRootHash, nodes, entries) => {
-    const result = await (0, pkg_1.create_proof)(trieRootHash, nodesAddLength(nodes), entries);
+    const result = await (0, chopsticks_executor_1.create_proof)(trieRootHash, nodesAddLength(nodes), entries);
     return { trieRootHash: result[0], nodes: result[1] };
 };
 exports.createProof = createProof;
+const runTask = async (task) => {
+    logger.trace({ task: { ...task, wasm: (0, logger_1.truncate)(task.wasm) } }, 'taskRun');
+    const response = await (0, chopsticks_executor_1.run_task)(task);
+    if (response.Call) {
+        logger.trace({ result: (0, logger_1.truncate)(response.Call.result), storageDiff: (0, logger_1.truncateStorageDiff)(response.Call.storageDiff) }, 'taskResponse');
+    }
+    else {
+        logger.trace({ response }, 'taskResponse');
+    }
+    return response;
+};
+exports.runTask = runTask;

package/dist/executor.test.js

@@ -3,25 +3,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const metadata_1 = require("@polkadot/types/metadata");
 const types_1 = require("@polkadot/types");
-const decorate_1 = require("@polkadot/types/metadata/decorate");
 const vitest_1 = require("vitest");
 const node_fs_1 = require("node:fs");
 const node_path_1 = __importDefault(require("node:path"));
 const proof_1 = require("./utils/proof");
 const executor_1 = require("./executor");
 (0, vitest_1.describe)('wasm', () => {
-    (0, vitest_1.it)('get metadata from wasm runtime', async () => {
-        const code = String((0, node_fs_1.readFileSync)(node_path_1.default.join(__dirname, 'runtime.example'))).trim();
-        (0, vitest_1.expect)(code.length).toBeGreaterThan(2);
-        const registry = new types_1.TypeRegistry();
-        const metadata = new metadata_1.Metadata(registry, await (0, executor_1.getMetadata)(code));
-        registry.setMetadata(metadata);
-        (0, vitest_1.expect)(registry.metadata.pallets.length).toBeGreaterThan(0);
-        const storage = (0, decorate_1.decorateStorage)(registry, metadata.asLatest, metadata.version);
-        (0, vitest_1.expect)(storage.system).toBeTruthy;
-    });
     (0, vitest_1.it)('get runtime version from wasm runtime', async () => {
         const code = String((0, node_fs_1.readFileSync)(node_path_1.default.join(__dirname, 'runtime.example'))).trim();
         (0, vitest_1.expect)(code.length).toBeGreaterThan(2);

package/dist/genesis-provider.js

@@ -114,7 +114,14 @@ class GenesisProvider {
                 return this.#genesis.name;
             case 'state_getMetadata': {
                 const code = this.#genesis.genesis.raw.top[(0, util_1.stringToHex)(':code')];
-                return (0, executor_1.getMetadata)(code);
+                return (0, executor_1.runTask)({
+                    blockHash: this.blockHash,
+                    wasm: code,
+                    calls: [['Metadata_metadata', '0x']],
+                    storage: [],
+                    mockSignatureHost: false,
+                    allowUnresolvedImports: true,
+                });
             }
             case 'chain_getHeader':
                 return this.getHeader();

package/dist/index.d.ts

@@ -3,19 +3,16 @@ import { ProviderInterface } from '@polkadot/rpc-provider/types';
 import { Api } from './api';
 import { Blockchain } from './blockchain';
 import { Config } from './schema';
-import { TaskManager } from './task';
 export declare const setup: (argv: Config) => Promise<{
     chain: Blockchain;
     api: Api;
     ws: ProviderInterface;
-    tasks: TaskManager;
 }>;
 export declare const setupWithServer: (argv: Config) => Promise<{
     close: () => Promise<void>;
     chain: Blockchain;
     api: Api;
     ws: ProviderInterface;
-    tasks: TaskManager;
 }>;
 export declare const runBlock: (argv: Config) => Promise<void>;
 export declare const decodeKey: (argv: any) => Promise<void>;

package/dist/index.js

@@ -17,12 +17,12 @@ const txpool_1 = require("./blockchain/txpool");
 const schema_1 = require("./schema");
 const genesis_provider_1 = require("./genesis-provider");
 const inherents_1 = require("./blockchain/inherents");
-const task_1 = require("./task");
 const server_1 = require("./server");
 const logger_1 = require("./logger");
 const rpc_1 = require("./rpc");
 const import_storage_1 = require("./utils/import-storage");
 const db_1 = require("./db");
+const executor_1 = require("./executor");
 const setup = async (argv) => {
     let provider;
     if (argv.genesis) {
@@ -54,19 +54,14 @@ const setup = async (argv) => {
         db = await (0, db_1.openDb)(argv.db);
     }
     const header = await api.getHeader(blockHash);
-    const port = argv.port || Number(process.env.PORT) || 8000;
-    const tasks = new task_1.TaskManager(port, argv['mock-signature-host'], argv['executor-cmd']);
     const blockNumber = +header.number;
+    const timestamp = argv.timestamp ?? Date.now();
     const setTimestamp = new inherents_1.SetTimestamp((newBlockNumber) => {
-        if (argv.timestamp) {
-            return argv.timestamp + (newBlockNumber - blockNumber) * 12000; // TODO: make this more flexible
-        }
-        return Date.now();
+        return timestamp + (newBlockNumber - blockNumber) * 12000; // TODO: make this more flexible
     });
-    const inherents = new inherents_1.InherentProviders(setTimestamp, [new inherents_1.SetValidationData(tasks, 1)]);
+    const inherents = new inherents_1.InherentProviders(setTimestamp, [new inherents_1.SetValidationData()]);
     const chain = new blockchain_1.Blockchain({
         api,
-        tasks,
         buildBlockMode: argv['build-block-mode'],
         inherentProvider: inherents,
         db,
@@ -75,7 +70,7 @@ const setup = async (argv) => {
             number: Number(header.number),
         },
     });
-    const context = { chain, api, ws: provider, tasks };
+    const context = { chain, api, ws: provider };
     await (0, import_storage_1.importStorage)(chain, argv['import-storage']);
     await (0, import_storage_1.overrideWasm)(chain, argv['wasm-override']);
     return context;
@@ -84,8 +79,7 @@ exports.setup = setup;
 const setupWithServer = async (argv) => {
     const context = await (0, exports.setup)(argv);
     const port = argv.port || Number(process.env.PORT) || 8000;
-    const { port: listeningPort, close } = (0, server_1.createServer)(port, (0, rpc_1.handler)(context));
-    context.tasks.updateListeningPort(await listeningPort);
+    const { close } = (0, server_1.createServer)(port, (0, rpc_1.handler)(context));
     if (argv.genesis) {
         // mine 1st block when starting from genesis to set some mock validation data
         await context.chain.newBlock();
@@ -107,20 +101,20 @@ const runBlock = async (argv) => {
         calls.push(['BlockBuilder_apply_extrinsic', extrinsic]);
     }
     calls.push(['BlockBuilder_finalize_block', '0x']);
-    await context.tasks.addAndRunTask({
-        Call: {
-            blockHash: parent,
-            wasm,
-            calls,
-        },
-    }, (output) => {
-        if (argv['output-path']) {
-            (0, node_fs_1.writeFileSync)(argv['output-path'], JSON.stringify(output, null, 2));
-        }
-        else {
-            console.dir(output, { depth: null, colors: false });
-        }
+    const result = await (0, executor_1.runTask)({
+        blockHash: parent,
+        wasm,
+        calls,
+        storage: [],
+        mockSignatureHost: false,
+        allowUnresolvedImports: false,
     });
+    if (argv['output-path']) {
+        (0, node_fs_1.writeFileSync)(argv['output-path'], JSON.stringify(result, null, 2));
+    }
+    else {
+        console.dir(result, { depth: null, colors: false });
+    }
     await context.close();
     setTimeout(() => process.exit(0), 50);
 };
@@ -182,10 +176,6 @@ const defaultOptions = {
         desc: 'Port to listen on',
         number: true,
     },
-    'executor-cmd': {
-        desc: 'Command to execute the executor',
-        string: true,
-    },
     'output-path': {
         desc: 'File path to print output',
         string: true,
@@ -202,10 +192,6 @@ const defaultOptions = {
         desc: 'Port to listen on',
         number: true,
     },
-    'executor-cmd': {
-        desc: 'Command to execute the executor',
-        string: true,
-    },
     'build-block-mode': {
         desc: 'Build block mode. Default to Batch',
         enum: [txpool_1.BuildBlockMode.Batch, txpool_1.BuildBlockMode.Manual, txpool_1.BuildBlockMode.Instant],

package/dist/logger.d.ts

@@ -1,7 +1,9 @@
+import { HexString } from '@polkadot/util/types';
 export declare const defaultLogger: import("pino").Logger<{
     level: string;
     transport: {
         target: string;
     };
 }>;
-export declare const truncate: (str?: string) => string | undefined;
+export declare const truncate: (str: string | null) => string | null;
+export declare const truncateStorageDiff: (diff: [HexString, HexString | null][]) => [HexString, string | null][];

package/dist/logger.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.truncate = exports.defaultLogger = void 0;
+exports.truncateStorageDiff = exports.truncate = exports.defaultLogger = void 0;
 const pino_1 = __importDefault(require("pino"));
 exports.defaultLogger = (0, pino_1.default)({
     level: process.env.LOG_LEVEL || 'info',
@@ -23,3 +23,7 @@ const truncate = (str) => {
     }
 };
 exports.truncate = truncate;
+const truncateStorageDiff = (diff) => {
+    return diff.map(([key, value]) => [key, (0, exports.truncate)(value)]);
+};
+exports.truncateStorageDiff = truncateStorageDiff;

package/dist/rpc/index.js

@@ -6,10 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handler = void 0;
 const shared_1 = require("./shared");
 const dev_1 = __importDefault(require("./dev"));
-const exec_1 = __importDefault(require("./exec"));
 const substrate_1 = __importDefault(require("./substrate"));
 const allHandlers = {
-    ...exec_1.default,
     ...substrate_1.default,
     ...dev_1.default,
 };

package/dist/rpc/shared.d.ts

@@ -1,7 +1,6 @@
 import { ProviderInterface } from '@polkadot/rpc-provider/types';
 import { Api } from '../api';
 import { Blockchain } from '../blockchain';
-import { TaskManager } from '../task';
 export declare const logger: import("pino").default.Logger<{
     level: string;
     transport: {
@@ -20,7 +19,6 @@ export interface Context {
     chain: Blockchain;
     api: Api;
     ws: ProviderInterface;
-    tasks: TaskManager;
 }
 export interface SubscriptionManager {
     subscribe: (method: string, subid: string, onCancel?: () => void) => (data: any) => void;

package/dist/schema/index.d.ts

@@ -65,7 +65,6 @@ export declare const configSchema: z.ZodObject<{
     port: z.ZodOptional<z.ZodNumber>;
     endpoint: z.ZodOptional<z.ZodString>;
     block: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber]>>;
-    'executor-cmd': z.ZodOptional<z.ZodString>;
     'build-block-mode': z.ZodOptional<z.ZodNativeEnum<typeof BuildBlockMode>>;
     'import-storage': z.ZodOptional<z.ZodAny>;
     'mock-signature-host': z.ZodOptional<z.ZodBoolean>;
@@ -133,7 +132,6 @@ export declare const configSchema: z.ZodObject<{
     }>]>>;
     timestamp: z.ZodOptional<z.ZodNumber>;
 }, "strict", z.ZodTypeAny, {
-    port?: number | undefined;
     timestamp?: number | undefined;
     db?: string | undefined;
     genesis?: string | {
@@ -150,15 +148,14 @@ export declare const configSchema: z.ZodObject<{
             };
         };
     } | undefined;
+    port?: number | undefined;
     endpoint?: string | undefined;
     block?: string | number | undefined;
-    'executor-cmd'?: string | undefined;
     'build-block-mode'?: BuildBlockMode | undefined;
     'import-storage'?: any;
     'mock-signature-host'?: boolean | undefined;
     'wasm-override'?: string | undefined;
 }, {
-    port?: number | undefined;
     timestamp?: number | undefined;
     db?: string | undefined;
     genesis?: string | {
@@ -175,9 +172,9 @@ export declare const configSchema: z.ZodObject<{
             };
         };
     } | undefined;
+    port?: number | undefined;
     endpoint?: string | undefined;
     block?: string | number | undefined;
-    'executor-cmd'?: string | undefined;
     'build-block-mode'?: BuildBlockMode | undefined;
     'import-storage'?: any;
     'mock-signature-host'?: boolean | undefined;

package/dist/schema/index.js

@@ -18,7 +18,6 @@ exports.configSchema = zod_1.z
     port: zod_1.z.number().optional(),
     endpoint: zod_1.z.string().optional(),
     block: zod_1.z.union([zod_1.z.string(), zod_1.z.number()]).optional(),
-    'executor-cmd': zod_1.z.string().optional(),
     'build-block-mode': zod_1.z.nativeEnum(txpool_1.BuildBlockMode).optional(),
     'import-storage': zod_1.z.any().optional(),
     'mock-signature-host': zod_1.z.boolean().optional(),

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/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@acala-network/chopsticks",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "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.1",
+    "@acala-network/chopsticks-executor": "0.2.3",
     "@polkadot/api": "^9.10.1",
     "@polkadot/rpc-provider": "^9.10.1",
     "@polkadot/types": "^9.10.1",

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;