movehat 0.2.6 → 0.2.8

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.d.ts

@@ -1,9 +1,22 @@
 import { MovehatRuntime } from "./types/runtime.js";
 import { MovehatUserConfig } from "./types/config.js";
+import { AccountManager } from "./core/AccountManager.js";
 export interface InitRuntimeOptions {
     network?: string;
     accountIndex?: number;
     configOverride?: Partial<MovehatUserConfig>;
+    /**
+     * Optional pre-constructed `AccountManager` instance. When supplied,
+     * the returned runtime's `accountManager` field is THIS instance —
+     * so labeled accounts created BEFORE `initRuntime` are visible on
+     * the runtime. When omitted, `initRuntime` constructs a fresh
+     * `new AccountManager()` per call.
+     *
+     * `setupLocalTesting` uses this option to thread one manager through
+     * `createBatch` → `exportPrivateKeys` → `initRuntime` so the deployer
+     * key it extracts ends up on the same manager the runtime exposes.
+     */
+    accountManager?: AccountManager;
 }
 /**
  * Initialize the Movehat Runtime Environment.

package/dist/runtime.js

@@ -35,9 +35,12 @@ export async function initRuntime(options = {}) {
         fullnode: config.rpc,
     });
     const aptos = new Aptos(aptosConfig);
-    // Setup accounts using AccountManager
+    // Setup accounts using AccountManager. Use the caller-supplied
+    // instance when threaded in (preserves labels created before
+    // initRuntime); otherwise construct a fresh one.
+    const accountManager = options.accountManager ?? new AccountManager();
     const accountIndex = options.accountIndex || 0;
-    const accounts = AccountManager.loadAccountsFromConfig(config);
+    const accounts = accountManager.loadAccountsFromConfig(config);
     // Primary account (accounts[0] or selected index)
     const account = accounts[accountIndex];
     if (!account) {
@@ -73,10 +76,10 @@ export async function initRuntime(options = {}) {
         return getDeployedAddress(config.network, moduleName);
     };
     const createAccount = () => {
-        return AccountManager.createAccount();
+        return accountManager.createAccount();
     };
     const getAccountHelper = (privateKeyHex) => {
-        return AccountManager.loadAccountFromPrivateKey(privateKeyHex);
+        return accountManager.loadAccountFromPrivateKey(privateKeyHex);
     };
     const getAccountByIndex = (index) => {
         const acc = accounts[index];
@@ -95,6 +98,7 @@ export async function initRuntime(options = {}) {
         aptos,
         account,
         accounts,
+        accountManager,
         getContract: getContractHelper,
         deployContract,
         getDeployment,

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

@@ -1,7 +1,8 @@
 // @ts-nocheck - This is a template file, dependencies are installed in user projects
 import { describe, it, before, after } from "mocha";
 import { expect } from "chai";
-import { Harness, AccountManager } from "movehat";
+import { Harness } from "movehat";
+import { getSharedNode } from "./setup.js";
 
 describe("Counter Contract", () => {
   let harness;
@@ -9,24 +10,21 @@ 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"],
     });
 
-    const labeled = AccountManager.getLabeledAccounts();
-    deployer = labeled.deployer;
-    alice = labeled.alice;
-    bob = labeled.bob;
+    // harness.accounts is a snapshot of the labeled accounts created
+    // during Harness construction. Two `Harness.createLocal({ accountLabels:
+    // ["alice"] })` calls in the same process now produce DIFFERENT
+    // alice accounts (per-Harness isolation introduced in 0.2.7).
+    ({ deployer, alice, bob } = harness.accounts);
 
     const counterAddr = harness.runtime.getDeploymentAddress("counter");
     counter = harness.runtime.getContract(counterAddr, "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;

package/dist/types/fork.d.ts

@@ -40,3 +40,27 @@ export interface AccountResource {
      */
     data: unknown;
 }
+export interface CoinStore {
+    coin: {
+        value: string;
+    };
+    deposit_events: {
+        counter: string;
+        guid: {
+            id: {
+                addr: string;
+                creation_num: string;
+            };
+        };
+    };
+    withdraw_events: {
+        counter: string;
+        guid: {
+            id: {
+                addr: string;
+                creation_num: string;
+            };
+        };
+    };
+    frozen: boolean;
+}

package/dist/types/runtime.d.ts

@@ -2,6 +2,7 @@ import { Aptos, Account } from "@aptos-labs/ts-sdk";
 import { MovehatConfig } from "./config.js";
 import { MoveContract } from "../core/contract.js";
 import { DeploymentInfo } from "../core/deployments.js";
+import type { AccountManager } from "../core/AccountManager.js";
 import type { ChildProcessAdapter } from "../utils/childProcessAdapter.js";
 export interface NetworkInfo {
     name: string;
@@ -14,6 +15,7 @@ export interface MovehatRuntime {
     aptos: Aptos;
     account: Account;
     accounts: Account[];
+    accountManager: AccountManager;
     getContract: (address: string, moduleName: string) => MoveContract;
     deployContract: (moduleName: string, options?: {
         packageDir?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "movehat",
-  "version": "0.2.6",
+  "version": "0.2.8",
   "type": "module",
   "description": "Hardhat-like development framework for Movement L1 smart contracts",
   "bin": {
@@ -70,6 +70,9 @@
     "prompts": "^2.4.2",
     "tsx": "^4.7.0"
   },
+  "optionalDependencies": {
+    "movelite": "^0.1.0"
+  },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^24.10.1",