movehat 0.2.7 → 0.2.9

package/dist/fork/validation.js

@@ -0,0 +1,88 @@
+function isObject(v) {
+    return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function hasString(o, key) {
+    return typeof o[key] === "string";
+}
+export function assertLedgerInfo(v) {
+    if (!isObject(v) ||
+        typeof v.chain_id !== "number" ||
+        !hasString(v, "epoch") ||
+        !hasString(v, "ledger_version") ||
+        !hasString(v, "oldest_ledger_version") ||
+        !hasString(v, "ledger_timestamp") ||
+        !hasString(v, "node_role") ||
+        !hasString(v, "oldest_block_height") ||
+        !hasString(v, "block_height")) {
+        throw new Error("Invalid LedgerInfo: missing or incorrectly typed fields");
+    }
+    return v;
+}
+export function assertAccountData(v) {
+    if (!isObject(v) ||
+        !hasString(v, "sequence_number") ||
+        !hasString(v, "authentication_key")) {
+        throw new Error("Invalid AccountData: expected object with 'sequence_number' and 'authentication_key' strings");
+    }
+    return v;
+}
+export function assertAccountResource(v) {
+    if (!isObject(v) || !hasString(v, "type") || !("data" in v)) {
+        throw new Error("Invalid AccountResource: expected object with 'type' string and 'data' field");
+    }
+    return v;
+}
+export function assertAccountResourceArray(v) {
+    if (!Array.isArray(v)) {
+        throw new Error("Invalid resources response: expected array");
+    }
+    for (let i = 0; i < v.length; i++) {
+        if (!isObject(v[i]) || !hasString(v[i], "type") || !("data" in v[i])) {
+            throw new Error(`Invalid AccountResource at index ${i}: expected object with 'type' and 'data'`);
+        }
+    }
+    return v;
+}
+export function assertForkMetadata(v) {
+    if (!isObject(v) ||
+        !hasString(v, "network") ||
+        !hasString(v, "nodeUrl") ||
+        typeof v.chainId !== "number" ||
+        !hasString(v, "ledgerVersion") ||
+        !hasString(v, "timestamp") ||
+        !hasString(v, "epoch") ||
+        !hasString(v, "blockHeight") ||
+        !hasString(v, "createdAt")) {
+        throw new Error("Invalid ForkMetadata: missing or incorrectly typed fields");
+    }
+    return v;
+}
+export function assertAccountState(v) {
+    if (!isObject(v) ||
+        !hasString(v, "sequenceNumber") ||
+        !hasString(v, "authenticationKey")) {
+        throw new Error("Invalid AccountState: expected object with 'sequenceNumber' and 'authenticationKey' strings");
+    }
+    return v;
+}
+export function assertAccountStateRecord(v) {
+    if (!isObject(v)) {
+        throw new Error("Invalid account state record: expected object");
+    }
+    for (const [key, val] of Object.entries(v)) {
+        if (!isObject(val) ||
+            !hasString(val, "sequenceNumber") ||
+            !hasString(val, "authenticationKey")) {
+            throw new Error(`Invalid AccountState for key "${key}": missing 'sequenceNumber' or 'authenticationKey'`);
+        }
+    }
+    return v;
+}
+export function assertCoinStore(v) {
+    if (!isObject(v) ||
+        !isObject(v.coin) ||
+        !hasString(v.coin, "value")) {
+        throw new Error("Invalid CoinStore: expected object with 'coin.value' string");
+    }
+    return v;
+}

package/dist/harness/Harness.d.ts

@@ -1,6 +1,6 @@
 import type { Account } from "@aptos-labs/ts-sdk";
 import type { MovehatRuntime } from "../types/runtime.js";
-import type { LocalNodeManager } from "../node/LocalNodeManager.js";
+import type { NodeProvider } from "../node/NodeProvider.js";
 import type { ForkServer } from "../fork/server.js";
 import type { ForkManager } from "../fork/manager.js";
 import type { LocalTestOptions } from "../types/config.js";
@@ -50,12 +50,13 @@ export declare class Harness {
      */
     readonly accounts: Readonly<Record<string, Account>>;
     /** @internal */
-    readonly localNode?: LocalNodeManager;
+    readonly localNode?: NodeProvider;
     /** @internal */
     readonly forkServer?: ForkServer;
     /** @internal */
     readonly forkManager?: ForkManager;
     private _poisoned;
+    private readonly ownsLocalNode;
     private constructor();
     /** True once `cleanup()` has been awaited at least once. */
     get poisoned(): boolean;

package/dist/harness/Harness.js

@@ -54,10 +54,12 @@ export class Harness {
     /** @internal */
     forkManager;
     _poisoned = false;
+    ownsLocalNode;
     constructor(init) {
         this.mode = init.mode;
         this.runtime = init.runtime;
         this.accounts = init.runtime.accountManager.getLabeledAccounts();
+        this.ownsLocalNode = init.ownsLocalNode ?? true;
         if (init.localNode)
             this.localNode = init.localNode;
         if (init.forkServer)
@@ -81,6 +83,7 @@ export class Harness {
         const init = {
             mode: "local",
             runtime: ctx.runtime,
+            ownsLocalNode: !options.localNode,
         };
         if (ctx.localNode)
             init.localNode = ctx.localNode;
@@ -156,7 +159,7 @@ export class Harness {
         if (this._poisoned)
             return;
         this._poisoned = true;
-        if (this.localNode) {
+        if (this.localNode && this.ownsLocalNode) {
             await this.localNode.stop().catch(() => { });
         }
         if (this.forkServer) {

package/dist/helpers/index.d.ts

@@ -11,6 +11,7 @@ export { AccountManager } from "../core/AccountManager.js";
 export type { StoredAccount } from "../core/AccountManager.js";
 export { LocalNodeManager } from "../node/LocalNodeManager.js";
 export type { LocalNodeOptions, LocalNodeInfo } from "../node/LocalNodeManager.js";
+export { MoveliteManager, findMoveliteBinary } from "../node/MoveliteManager.js";
 export { setupLocalTesting } from "./setupLocalTesting.js";
 export type { LocalTestingContext } from "./setupLocalTesting.js";
 export { setupTestFixture, setupMinimalFixture, } from "./testFixtures.js";

package/dist/helpers/index.js

@@ -6,5 +6,6 @@ export { saveDeployment, loadDeployment, getAllDeployments, getDeployedAddress,
 export { snapshot, getForkInfo, viewForkResource, compareForkState, listSnapshots, } from "../fork/test.js";
 export { AccountManager } from "../core/AccountManager.js";
 export { LocalNodeManager } from "../node/LocalNodeManager.js";
+export { MoveliteManager, findMoveliteBinary } from "../node/MoveliteManager.js";
 export { setupLocalTesting } from "./setupLocalTesting.js";
 export { setupTestFixture, setupMinimalFixture, } from "./testFixtures.js";

package/dist/helpers/move-tests.js

@@ -2,6 +2,7 @@ import { existsSync } from "fs";
 import { resolve } from "path";
 import { loadUserConfig } from "../core/config.js";
 import { runCli } from "../utils/runCli.js";
+import { logger } from "../ui/index.js";
 /**
  * Run Move unit tests using Movement CLI
  * @param options Test options including filter, warnings, and skip behavior
@@ -12,8 +13,9 @@ export async function runMoveTests(options = {}) {
     const moveDir = resolve(process.cwd(), userConfig.moveDir || "./move");
     if (!existsSync(moveDir)) {
         if (options.skipIfMissing) {
-            console.log("⊘ No Move directory found (./move not found)");
-            console.log("   Skipping Move tests...\n");
+            logger.info("No Move directory found (./move not found)");
+            logger.plain("   Skipping Move tests...");
+            logger.newline();
             return;
         }
         else {
@@ -42,12 +44,13 @@ export async function runMoveTests(options = {}) {
     catch (error) {
         // Spawn-time failure (ENOENT, etc.). The original code logged a
         // Movement-CLI-install hint here; keep that.
-        console.error(`Failed to run Move tests: ${error.message}`);
-        console.error("   Make sure Movement CLI is installed");
+        logger.error(`Failed to run Move tests: ${error.message}`);
+        logger.error("   Make sure Movement CLI is installed");
         throw error;
     }
     if (result.exitCode === 0) {
-        console.log("\n✓ Move tests passed");
+        logger.newline();
+        logger.success("Move tests passed");
         return;
     }
     throw new Error("Move tests failed");

package/dist/helpers/setupLocalTesting.d.ts

@@ -1,7 +1,7 @@
 import type { MovehatRuntime } from "../types/runtime.js";
 import { ForkManager } from "../fork/manager.js";
 import { ForkServer } from "../fork/server.js";
-import { LocalNodeManager } from "../node/LocalNodeManager.js";
+import type { NodeProvider } from "../node/NodeProvider.js";
 import type { LocalTestOptions } from "../types/config.js";
 /**
  * Context returned by {@link setupLocalTesting}.
@@ -17,7 +17,7 @@ import type { LocalTestOptions } from "../types/config.js";
 export interface LocalTestingContext {
     runtime: MovehatRuntime;
     /** @internal */
-    localNode?: LocalNodeManager;
+    localNode?: NodeProvider;
     /** @internal */
     forkServer?: ForkServer;
     /** @internal */

package/dist/helpers/setupLocalTesting.js

@@ -4,6 +4,7 @@ import { initRuntime } from "../runtime.js";
 import { ForkManager } from "../fork/manager.js";
 import { ForkServer } from "../fork/server.js";
 import { LocalNodeManager } from "../node/LocalNodeManager.js";
+import { MoveliteManager, findMoveliteBinary } from "../node/MoveliteManager.js";
 import { AccountManager } from "../core/AccountManager.js";
 import { logger } from "../ui/index.js";
 const BUILTIN_FORK_RPCS = {
@@ -64,11 +65,13 @@ export async function setupLocalTesting(options = {}) {
     logger.kv("Accounts", accountLabels.join(", "), 2);
     logger.newline();
     if (mode === 'local-node') {
-        const { runtime, localNode } = await setupWithLocalNode(options, accountLabels, autoFund, defaultBalance);
+        const { runtime, localNode, ownsNode } = await setupWithLocalNode(options, accountLabels, autoFund, defaultBalance);
         return {
             runtime,
             localNode,
             teardown: async () => {
+                if (!ownsNode)
+                    return;
                 logger.newline();
                 logger.step("Stopping local testing environment...");
                 await localNode.stop();
@@ -93,25 +96,56 @@ export async function setupLocalTesting(options = {}) {
         };
     }
 }
+/**
+ * Resolve whether to prefer movelite. Explicit `useMovelite` wins; otherwise
+ * the `MOVEHAT_USE_MOVELITE` env var acts as an override (`0` disables, `1`
+ * enables); default is enabled. Lets tooling force a backend without editing
+ * test code.
+ */
+function resolveUseMovelite(useMovelite) {
+    if (useMovelite !== undefined)
+        return useMovelite;
+    return process.env.MOVEHAT_USE_MOVELITE !== "0";
+}
 /**
  * Setup using local Movement node (full blockchain)
  */
 async function setupWithLocalNode(options, accountLabels, autoFund, defaultBalance) {
-    const nodeTestDir = options.nodeTestDir || join(process.cwd(), ".movehat", "local-node");
-    const nodeForceRestart = options.nodeForceRestart !== false;
-    const nodeFaucetPort = options.nodeFaucetPort || 8081;
-    const nodeApiPort = options.nodeApiPort || 8080;
-    const nodeReadyPort = options.nodeReadyPort || 8070;
-    const nodeSilent = options.nodeSilent ?? false;
-    const localNode = new LocalNodeManager({
-        testDir: nodeTestDir,
-        forceRestart: nodeForceRestart,
-        faucetPort: nodeFaucetPort,
-        apiPort: nodeApiPort,
-        readyPort: nodeReadyPort,
-        silent: nodeSilent,
-    });
-    const nodeInfo = await localNode.start();
+    let localNode;
+    let ownsNode;
+    let nodeInfo;
+    if (options.localNode) {
+        localNode = options.localNode;
+        ownsNode = false;
+        if (!localNode.isRunning()) {
+            throw new Error("localNode was provided but isRunning() is false. " +
+                "Start the node before passing it to setupLocalTesting.");
+        }
+        nodeInfo = localNode.getNodeInfo();
+    }
+    else if (resolveUseMovelite(options.useMovelite) && findMoveliteBinary()) {
+        localNode = new MoveliteManager(findMoveliteBinary());
+        nodeInfo = await localNode.start();
+        ownsNode = true;
+    }
+    else {
+        const nodeTestDir = options.nodeTestDir || join(process.cwd(), ".movehat", "local-node");
+        const nodeForceRestart = options.nodeForceRestart !== false;
+        const nodeFaucetPort = options.nodeFaucetPort || 8081;
+        const nodeApiPort = options.nodeApiPort || 8080;
+        const nodeReadyPort = options.nodeReadyPort || 8070;
+        const nodeSilent = options.nodeSilent ?? false;
+        localNode = new LocalNodeManager({
+            testDir: nodeTestDir,
+            forceRestart: nodeForceRestart,
+            faucetPort: nodeFaucetPort,
+            apiPort: nodeApiPort,
+            readyPort: nodeReadyPort,
+            silent: nodeSilent,
+        });
+        ownsNode = true;
+        nodeInfo = await localNode.start();
+    }
     // Once the node is up, every later step (account creation, funding,
     // runtime init, autoDeploy) is fallible. If any of them throws we
     // must stop the node we just started — otherwise the child process
@@ -156,11 +190,14 @@ async function setupWithLocalNode(options, accountLabels, autoFund, defaultBalan
             logger.step(`Auto-deploying ${options.autoDeploy.length} module(s)...`);
             const previousRedeploy = process.env.MH_CLI_REDEPLOY;
             process.env.MH_CLI_REDEPLOY = 'true';
+            // movelite's REST responses can't drive the Movement CLI publish flow,
+            // so deploy through the TypeScript SDK when it is the spawned backend.
+            const sdkPublish = localNode instanceof MoveliteManager;
             try {
                 for (const moduleName of options.autoDeploy) {
                     try {
                         logger.plain(`   Deploying ${moduleName}...`);
-                        await runtime.deployContract(moduleName);
+                        await runtime.deployContract(moduleName, { sdkPublish });
                         logger.success(`${moduleName} deployed`, 2);
                     }
                     catch (error) {
@@ -188,12 +225,12 @@ async function setupWithLocalNode(options, accountLabels, autoFund, defaultBalan
         logger.plain(`   Accounts: ${Array.from(accountLabels).join(", ")}`);
         logger.plain(`   Balance per account: ${defaultBalance / 100_000_000} MOVE`);
         logger.newline();
-        return { runtime, localNode };
+        return { runtime, localNode, ownsNode };
     }
     catch (error) {
-        // Best-effort cleanup. Swallow the stop() error so the original
-        // setup failure surfaces unchanged.
-        await localNode.stop().catch(() => { });
+        if (ownsNode) {
+            await localNode.stop().catch(() => { });
+        }
         throw error;
     }
 }

package/dist/helpers/version-check.js

@@ -3,7 +3,7 @@ import { join } from "path";
 import { homedir } from "os";
 import { isNewerVersion } from "./semver-utils.js";
 import { fetchLatestVersion } from "./npm-registry.js";
-import { box, colors, formatCommand } from "../ui/index.js";
+import { box, colors, formatCommand, logger } from "../ui/index.js";
 const CACHE_DURATION = 24 * 60 * 60 * 1000; // 24 hours in milliseconds
 const CACHE_DIR = join(homedir(), ".movehat");
 const CACHE_FILE = join(CACHE_DIR, "version-cache.json");
@@ -72,7 +72,9 @@ export function checkForUpdates(currentVersion, packageName) {
             const updateMessage = box(`${colors.brandBright('Update Available!')}\n\n` +
                 `${currentVersion} ${colors.dim('→')} ${colors.success(cache.latestVersion)}\n\n` +
                 `${formatCommand('movehat update')}`, { borderColor: 'warning', padding: 1 });
-            console.error('\n' + updateMessage + '\n');
+            logger.newline();
+            logger.warning(updateMessage);
+            logger.newline();
         }
         // Update cache in background if needed (doesn't block)
         if (!cache || Date.now() - cache.lastChecked > CACHE_DURATION) {

package/dist/node/MoveliteManager.d.ts

@@ -0,0 +1,18 @@
+import type { Account } from "@aptos-labs/ts-sdk";
+import type { LocalNodeInfo } from "./LocalNodeManager.js";
+export declare class MoveliteManager {
+    private process;
+    private port;
+    private killed;
+    private readonly binaryPath;
+    constructor(binaryPath: string, port?: number);
+    start(): Promise<LocalNodeInfo>;
+    private waitForReady;
+    fundAccount(address: string, amount: number): Promise<void>;
+    fundAccounts(accounts: Account[], balance: number): Promise<void>;
+    stop(): Promise<void>;
+    private isPortInUse;
+    isRunning(): boolean;
+    getNodeInfo(): LocalNodeInfo;
+}
+export declare function findMoveliteBinary(): string | null;

package/dist/node/MoveliteManager.js

@@ -0,0 +1,152 @@
+import { execSync, spawn } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+import { createRequire } from "module";
+import { logger } from "../ui/index.js";
+export class MoveliteManager {
+    process = null;
+    port;
+    killed = false;
+    binaryPath;
+    constructor(binaryPath, port = 8090) {
+        this.binaryPath = binaryPath;
+        this.port = port;
+    }
+    async start() {
+        const binary = this.binaryPath;
+        if (!binary) {
+            throw new Error("movelite binary not found");
+        }
+        if (await this.isPortInUse(this.port)) {
+            this.port = this.port + 1;
+            if (await this.isPortInUse(this.port)) {
+                throw new Error(`Ports ${this.port - 1} and ${this.port} are in use`);
+            }
+        }
+        logger.step("Starting movelite...");
+        this.process = spawn(binary, ["start", "--port", String(this.port), "--no-auth"], {
+            stdio: "pipe",
+            detached: false,
+        });
+        this.process.on("exit", () => {
+            this.process = null;
+        });
+        await this.waitForReady();
+        logger.success(`movelite ready on port ${this.port}`);
+        return this.getNodeInfo();
+    }
+    async waitForReady() {
+        const url = `http://127.0.0.1:${this.port}/v1`;
+        const timeout = 15_000;
+        const start = Date.now();
+        while (Date.now() - start < timeout) {
+            try {
+                const res = await fetch(url);
+                if (res.ok)
+                    return;
+            }
+            catch {
+                // not ready yet
+            }
+            await new Promise((r) => setTimeout(r, 200));
+        }
+        throw new Error(`movelite did not become ready within ${timeout}ms`);
+    }
+    async fundAccount(address, amount) {
+        const res = await fetch(`http://127.0.0.1:${this.port}/mint?address=${address}&amount=${amount}`, { method: "POST" });
+        if (!res.ok) {
+            throw new Error(`Failed to fund account: ${res.status}`);
+        }
+    }
+    async fundAccounts(accounts, balance) {
+        for (const account of accounts) {
+            await this.fundAccount(account.accountAddress.toString(), balance);
+        }
+    }
+    async stop() {
+        if (!this.process || this.killed)
+            return;
+        this.killed = true;
+        this.process.kill("SIGTERM");
+        await new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                if (this.process)
+                    this.process.kill("SIGKILL");
+                resolve();
+            }, 5_000);
+            if (this.process) {
+                this.process.on("exit", () => {
+                    clearTimeout(timer);
+                    resolve();
+                });
+            }
+            else {
+                clearTimeout(timer);
+                resolve();
+            }
+        });
+        this.process = null;
+    }
+    async isPortInUse(port) {
+        try {
+            const res = await fetch(`http://127.0.0.1:${port}/v1`);
+            return res.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    isRunning() {
+        return this.process !== null && !this.killed;
+    }
+    getNodeInfo() {
+        return {
+            rpcUrl: `http://127.0.0.1:${this.port}`,
+            faucetUrl: `http://127.0.0.1:${this.port}`,
+            readyUrl: `http://127.0.0.1:${this.port}/v1`,
+            testDir: "",
+        };
+    }
+}
+export function findMoveliteBinary() {
+    if (process.env.MOVELITE_PATH) {
+        return existsSync(process.env.MOVELITE_PATH)
+            ? process.env.MOVELITE_PATH
+            : null;
+    }
+    const platforms = {
+        "darwin-arm64": "movelite-darwin-arm64",
+        "darwin-x64": "movelite-darwin-x64",
+        "linux-x64": "movelite-linux-x64",
+        "linux-arm64": "movelite-linux-arm64",
+    };
+    const key = `${process.platform}-${process.arch}`;
+    const pkg = platforms[key];
+    if (pkg) {
+        try {
+            // Resolve through the `movelite` shim (movehat's direct dependency),
+            // then resolve the platform package from movelite's own context. The
+            // platform package is movelite's dependency, not movehat's, so a direct
+            // resolve from here fails under pnpm/yarn strict layouts.
+            const req = createRequire(import.meta.url);
+            const movelitePkg = req.resolve("movelite/package.json");
+            const moveliteReq = createRequire(movelitePkg);
+            const pkgPath = moveliteReq.resolve(`${pkg}/package.json`);
+            const binPath = join(pkgPath, "..", "bin", "movelite");
+            if (existsSync(binPath))
+                return binPath;
+        }
+        catch {
+            // package not installed
+        }
+    }
+    try {
+        const found = execSync("which movelite", { encoding: "utf-8" }).trim();
+        if (found && existsSync(found))
+            return found;
+    }
+    catch {
+        // not in PATH
+    }
+    return null;
+}

package/dist/node/NodeProvider.d.ts

@@ -0,0 +1,9 @@
+import type { Account } from "@aptos-labs/ts-sdk";
+import type { LocalNodeInfo } from "./LocalNodeManager.js";
+export interface NodeProvider {
+    start(): Promise<LocalNodeInfo>;
+    stop(): Promise<void>;
+    isRunning(): boolean;
+    getNodeInfo(): LocalNodeInfo;
+    fundAccounts(accounts: Account[], balance: number): Promise<void>;
+}

package/dist/node/NodeProvider.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime.js

@@ -64,6 +64,8 @@ export async function initRuntime(options = {}) {
             config,
             account,
             packageDir: options?.packageDir,
+            sdkPublish: options?.sdkPublish,
+            aptos,
         });
     };
     const getDeployment = (moduleName) => {

package/dist/templates/.mocharc.json

@@ -2,6 +2,7 @@
   "node-option": ["import=tsx"],
   "extensions": ["ts"],
   "spec": ["tests/**/*.test.ts"],
+  "require": ["tests/setup.ts"],
   "timeout": 30000,
   "color": true,
   "reporter": "spec"

package/dist/templates/tests/Counter.test.ts

@@ -2,6 +2,7 @@
 import { describe, it, before, after } from "mocha";
 import { expect } from "chai";
 import { Harness } from "movehat";
+import { getSharedNode } from "./setup.js";
 
 describe("Counter Contract", () => {
   let harness;
@@ -9,16 +10,12 @@ describe("Counter Contract", () => {
   let deployer, alice, bob;
 
   before(async function () {
-    this.timeout(60000); // Allow time for local node startup + deployment
-
-    // Hardhat-style Harness — the primary public API.
-    // createLocal spins up a Movement local node, funds the labeled
-    // accounts from the local faucet, and (via autoDeploy) builds +
-    // publishes the named modules so they're ready to use.
-    //
-    // The setupTestFixture helper still works if you prefer the older
-    // pattern; see `import { setupTestFixture } from "movehat/helpers"`.
+    this.timeout(60000);
+
+    // Reuses the shared Movement node started by root hooks (tests/setup.ts).
+    // Each spec still gets its own accounts + deployments for isolation.
     harness = await Harness.createLocal({
+      localNode: getSharedNode(),
       accountLabels: ["deployer", "alice", "bob"],
       autoDeploy: ["counter"],
     });

package/dist/templates/tests/setup.ts

@@ -0,0 +1,34 @@
+// @ts-nocheck - This is a template file, dependencies are installed in user projects
+import { LocalNodeManager } from "movehat/helpers";
+
+let sharedNode;
+
+/**
+ * Returns the shared local Movement node started by root hooks.
+ * Pass the result as `{ localNode: getSharedNode() }` to
+ * Harness.createLocal() or setupTestFixture().
+ */
+export function getSharedNode() {
+  if (!sharedNode || !sharedNode.isRunning()) {
+    throw new Error(
+      "Shared node not available. " +
+        'Ensure tests/setup.ts is listed in .mocharc.json under "require".'
+    );
+  }
+  return sharedNode;
+}
+
+export const mochaHooks = {
+  async beforeAll() {
+    this.timeout(60000);
+    sharedNode = new LocalNodeManager({ forceRestart: true });
+    await sharedNode.start();
+  },
+
+  async afterAll() {
+    if (sharedNode) {
+      await sharedNode.stop();
+      sharedNode = undefined;
+    }
+  },
+};

package/dist/types/config.d.ts

@@ -41,6 +41,8 @@ export type LocalTestingMode = 'local-node' | 'fork';
  */
 export interface LocalTestOptions {
     mode?: LocalTestingMode;
+    localNode?: import("../node/LocalNodeManager.js").LocalNodeManager;
+    useMovelite?: boolean;
     nodeTestDir?: string;
     nodeForceRestart?: boolean;
     nodeFaucetPort?: number;