movehat 0.1.9 → 0.2.0

package/src/__tests__/harness/script.test.ts

@@ -0,0 +1,245 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { Harness } from "../../harness/index.js";
+import { CliExecutionError } from "../../errors.js";
+import type {
+  ChildProcessAdapter,
+  RunInput,
+  RunResult,
+} from "../../utils/childProcessAdapter.js";
+import { setupHarnessTestFixture, type HarnessTestFixture } from "./_fixture.js";
+
+describe("Harness.runMoveScript", () => {
+  let fixture: HarnessTestFixture;
+
+  const TX_HASH =
+    "0x9999999999999999999999999999999999999999999999999999999999999999";
+
+  beforeEach(() => {
+    fixture = setupHarnessTestFixture({ withTmpHome: true });
+  });
+
+  afterEach(() => {
+    fixture.teardown();
+  });
+
+  function makeAdapter(result: RunResult): {
+    adapter: ChildProcessAdapter;
+    calls: RunInput[];
+  } {
+    const calls: RunInput[] = [];
+    const adapter: ChildProcessAdapter = {
+      async run(input) {
+        calls.push(input);
+        if (input.args[1] === "run-script") return result;
+        throw new Error(`unexpected movement subcommand: ${input.args[1]}`);
+      },
+      spawn() {
+        throw new Error("spawn not used in script tests");
+      },
+    };
+    return { adapter, calls };
+  }
+
+  function successStdout(): string {
+    return [
+      `transaction hash: ${TX_HASH}`,
+      '{ "Result": { "success": true, "vm_status": "Executed successfully" } }',
+    ].join("\n");
+  }
+
+  it("happy path with .move source: uses --script-path and returns parsed MoveScriptResult", async () => {
+    const scriptPath = join(fixture.tmpCwd, "scripts", "init.move");
+    mkdirSync(join(fixture.tmpCwd, "scripts"), { recursive: true });
+    writeFileSync(scriptPath, "// dummy move script\n");
+
+    const { adapter, calls } = makeAdapter({
+      exitCode: 0,
+      stdout: successStdout(),
+      stderr: "",
+    });
+
+    const harness = await Harness.createLive("testnet");
+    try {
+      const result = await harness.runMoveScript({
+        scriptPath,
+        args: ["u64:42", "bool:true"],
+        typeArgs: ["0x1::aptos_coin::AptosCoin"],
+        adapter,
+      });
+
+      expect(result.txHash).toBe(TX_HASH);
+      expect(result.success).toBe(true);
+      expect(result.vmStatus).toBe("Executed successfully");
+
+      expect(calls).toHaveLength(1);
+      const call = calls[0]!;
+      expect(call.args.slice(0, 2)).toEqual(["move", "run-script"]);
+      expect(call.args).toContain("--script-path");
+      expect(call.args).not.toContain("--compiled-script-path");
+      expect(call.args).toContain(scriptPath);
+      expect(call.args).toContain("--type-args");
+      expect(call.args).toContain("0x1::aptos_coin::AptosCoin");
+      expect(call.args).toContain("--args");
+      expect(call.args).toContain("u64:42");
+      expect(call.args).toContain("bool:true");
+    } finally {
+      await harness.cleanup();
+    }
+  });
+
+  it("happy path with .mv compiled: uses --compiled-script-path", async () => {
+    const scriptPath = join(fixture.tmpCwd, "build", "init.mv");
+    mkdirSync(join(fixture.tmpCwd, "build"), { recursive: true });
+    writeFileSync(scriptPath, "compiled bytecode placeholder");
+
+    const { adapter, calls } = makeAdapter({
+      exitCode: 0,
+      stdout: successStdout(),
+      stderr: "",
+    });
+
+    const harness = await Harness.createLive("testnet");
+    try {
+      const result = await harness.runMoveScript({ scriptPath, adapter });
+
+      expect(result.txHash).toBe(TX_HASH);
+      const call = calls[0]!;
+      expect(call.args).toContain("--compiled-script-path");
+      expect(call.args).not.toContain("--script-path");
+    } finally {
+      await harness.cleanup();
+    }
+  });
+
+  it("unsupported extension throws synchronously before any CLI call", async () => {
+    const scriptPath = join(fixture.tmpCwd, "notes.txt");
+    writeFileSync(scriptPath, "not a script");
+
+    const { adapter, calls } = makeAdapter({
+      exitCode: 0,
+      stdout: successStdout(),
+      stderr: "",
+    });
+
+    const harness = await Harness.createLive("testnet");
+    try {
+      let caught: unknown;
+      try {
+        await harness.runMoveScript({ scriptPath, adapter });
+      } catch (err) {
+        caught = err;
+      }
+      expect(caught).toBeInstanceOf(Error);
+      expect((caught as Error).message).toMatch(/unsupported script extension/i);
+      expect(calls).toHaveLength(0);
+    } finally {
+      await harness.cleanup();
+    }
+  });
+
+  it("missing script file throws before any CLI call", async () => {
+    const scriptPath = join(fixture.tmpCwd, "scripts", "missing.move");
+    const { adapter, calls } = makeAdapter({
+      exitCode: 0,
+      stdout: successStdout(),
+      stderr: "",
+    });
+
+    const harness = await Harness.createLive("testnet");
+    try {
+      let caught: unknown;
+      try {
+        await harness.runMoveScript({ scriptPath, adapter });
+      } catch (err) {
+        caught = err;
+      }
+      expect(caught).toBeInstanceOf(Error);
+      expect((caught as Error).message).toMatch(/script not found/i);
+      expect(calls).toHaveLength(0);
+    } finally {
+      await harness.cleanup();
+    }
+  });
+
+  it("CLI failure rethrows CliExecutionError and removes the temp profile", async () => {
+    const scriptPath = join(fixture.tmpCwd, "scripts", "fail.move");
+    mkdirSync(join(fixture.tmpCwd, "scripts"), { recursive: true });
+    writeFileSync(scriptPath, "// dummy\n");
+
+    const { adapter } = makeAdapter({
+      exitCode: 1,
+      stdout: "",
+      stderr: "compile error: undefined identifier",
+    });
+
+    const harness = await Harness.createLive("testnet");
+    try {
+      let caught: unknown;
+      try {
+        await harness.runMoveScript({ scriptPath, adapter });
+      } catch (err) {
+        caught = err;
+      }
+      expect(caught).toBeInstanceOf(CliExecutionError);
+      // Temp profile cleaned up in finally.
+      expect(existsSync(join(fixture.tmpHome!, ".aptos", "config.yaml"))).toBe(false);
+    } finally {
+      await harness.cleanup();
+    }
+  });
+
+  it("CLI succeeded but output has no txHash: throws clear non-CliExecutionError", async () => {
+    const scriptPath = join(fixture.tmpCwd, "scripts", "weird.move");
+    mkdirSync(join(fixture.tmpCwd, "scripts"), { recursive: true });
+    writeFileSync(scriptPath, "// dummy\n");
+
+    const { adapter } = makeAdapter({
+      exitCode: 0,
+      stdout: "ran successfully but no hash here",
+      stderr: "",
+    });
+
+    const harness = await Harness.createLive("testnet");
+    try {
+      let caught: unknown;
+      try {
+        await harness.runMoveScript({ scriptPath, adapter });
+      } catch (err) {
+        caught = err;
+      }
+      expect(caught).toBeInstanceOf(Error);
+      expect(caught).not.toBeInstanceOf(CliExecutionError);
+      expect((caught as Error).message).toMatch(/Could not parse transaction hash/);
+    } finally {
+      await harness.cleanup();
+    }
+  });
+
+  it("`success: false` in Result JSON surfaces in MoveScriptResult.success", async () => {
+    const scriptPath = join(fixture.tmpCwd, "scripts", "bad.move");
+    mkdirSync(join(fixture.tmpCwd, "scripts"), { recursive: true });
+    writeFileSync(scriptPath, "// dummy\n");
+
+    const { adapter } = makeAdapter({
+      exitCode: 0,
+      stdout: [
+        `transaction hash: ${TX_HASH}`,
+        '{ "Result": { "success": false, "vm_status": "ABORTED" } }',
+      ].join("\n"),
+      stderr: "",
+    });
+
+    const harness = await Harness.createLive("testnet");
+    try {
+      const result = await harness.runMoveScript({ scriptPath, adapter });
+      expect(result.txHash).toBe(TX_HASH);
+      expect(result.success).toBe(false);
+      expect(result.vmStatus).toBe("ABORTED");
+    } finally {
+      await harness.cleanup();
+    }
+  });
+});

package/src/__tests__/harness/view.test.ts

@@ -0,0 +1,104 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { Harness } from "../../harness/index.js";
+import { setupHarnessTestFixture, type HarnessTestFixture } from "./_fixture.js";
+
+/**
+ * Tests for `Harness.runViewFunction` — the SDK delegation path.
+ *
+ * The Aptos SDK isn't behind an injectable adapter, so we monkey-patch
+ * `harness.runtime.aptos.view` after `createLive`. One-off for M2.3.
+ * Acceptable here because the function under test is a 6-line wrapper
+ * that only forwards options.
+ */
+describe("Harness.runViewFunction", () => {
+  let fixture: HarnessTestFixture;
+
+  beforeEach(() => {
+    fixture = setupHarnessTestFixture();
+  });
+
+  afterEach(() => {
+    fixture.teardown();
+  });
+
+  it("happy path: forwards correct payload to aptos.view and returns the raw result array", async () => {
+    const harness = await Harness.createLive("testnet");
+    try {
+      const fake = vi.fn().mockResolvedValue([42n, "hello"]);
+      // Monkey-patch — the SDK boundary isn't behind an adapter.
+      harness.runtime.aptos.view = fake as never;
+
+      const result = await harness.runViewFunction({
+        function: "0xCAFE::counter::get",
+        typeArguments: ["0x1::aptos_coin::AptosCoin"],
+        functionArguments: ["0xdeployer", 1n],
+      });
+
+      expect(result).toEqual([42n, "hello"]);
+      expect(fake).toHaveBeenCalledTimes(1);
+      expect(fake).toHaveBeenCalledWith({
+        payload: {
+          function: "0xCAFE::counter::get",
+          typeArguments: ["0x1::aptos_coin::AptosCoin"],
+          functionArguments: ["0xdeployer", 1n],
+        },
+      });
+    } finally {
+      await harness.cleanup();
+    }
+  });
+
+  it("defaults typeArguments and functionArguments to empty arrays when omitted", async () => {
+    const harness = await Harness.createLive("testnet");
+    try {
+      const fake = vi.fn().mockResolvedValue([0n]);
+      harness.runtime.aptos.view = fake as never;
+
+      const result = await harness.runViewFunction({
+        function: "0xCAFE::counter::count",
+      });
+
+      expect(result).toEqual([0n]);
+      expect(fake).toHaveBeenCalledWith({
+        payload: {
+          function: "0xCAFE::counter::count",
+          typeArguments: [],
+          functionArguments: [],
+        },
+      });
+    } finally {
+      await harness.cleanup();
+    }
+  });
+
+  it("passes empty results through unchanged", async () => {
+    const harness = await Harness.createLive("testnet");
+    try {
+      const fake = vi.fn().mockResolvedValue([]);
+      harness.runtime.aptos.view = fake as never;
+
+      const result = await harness.runViewFunction({
+        function: "0xCAFE::nothing::nothing",
+      });
+
+      expect(result).toEqual([]);
+    } finally {
+      await harness.cleanup();
+    }
+  });
+
+  it("rethrows errors from aptos.view", async () => {
+    const harness = await Harness.createLive("testnet");
+    try {
+      const fake = vi.fn().mockRejectedValue(new Error("module not found"));
+      harness.runtime.aptos.view = fake as never;
+
+      await expect(
+        harness.runViewFunction({ function: "0xCAFE::missing::get" })
+      ).rejects.toThrow(/module not found/);
+    } finally {
+      await harness.cleanup();
+    }
+  });
+});

package/src/__tests__/runtime.test.ts

@@ -0,0 +1,182 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { initRuntime } from "../runtime.js";
+import { _resetConfigCache } from "../core/config.js";
+import { AccountManager } from "../core/AccountManager.js";
+
+/**
+ * Behavioral tests for `runtime.ts` covering the paths
+ * `__tests__/deployContract.test.ts` doesn't exercise:
+ *   - initRuntime returns a fully-wired MovehatRuntime
+ *   - accountIndex selection + out-of-range error
+ *   - config override merging
+ *   - getAccountByIndex bounds error
+ *   - switchNetwork delegates back into initRuntime
+ *
+ * Mainnet/security gates live in `resolveNetworkConfig` and are
+ * covered in `core/__tests__/config.test.ts` to avoid re-driving the
+ * same branch through two layers.
+ */
+
+const TEST_KEY_A =
+  "0x0000000000000000000000000000000000000000000000000000000000000001";
+const TEST_KEY_B =
+  "0x0000000000000000000000000000000000000000000000000000000000000002";
+
+function writeConfig(cwd: string, body: string): void {
+  writeFileSync(join(cwd, "movehat.config.js"), body);
+}
+
+const CONFIG_TWO_NETWORKS_TWO_ACCOUNTS = `export default {
+  defaultNetwork: "testnet",
+  networks: {
+    testnet: {
+      url: "https://testnet.movementnetwork.xyz/v1",
+      chainId: "testnet",
+      accounts: ["${TEST_KEY_A}", "${TEST_KEY_B}"]
+    },
+    custom: {
+      url: "https://custom.example.com/v1",
+      chainId: "custom",
+      accounts: ["${TEST_KEY_A}"]
+    }
+  }
+};
+`;
+
+describe("initRuntime", () => {
+  let tmpCwd: string;
+  let origCwd: string;
+
+  beforeEach(() => {
+    origCwd = process.cwd();
+    tmpCwd = mkdtempSync(join(tmpdir(), "movehat-runtime-test-"));
+    process.chdir(tmpCwd);
+    _resetConfigCache();
+    AccountManager.clearPool();
+    writeConfig(tmpCwd, CONFIG_TWO_NETWORKS_TWO_ACCOUNTS);
+  });
+
+  afterEach(() => {
+    process.chdir(origCwd);
+    rmSync(tmpCwd, { recursive: true, force: true });
+    _resetConfigCache();
+    AccountManager.clearPool();
+  });
+
+  it("returns a runtime bound to defaultNetwork when no network is passed", async () => {
+    const runtime = await initRuntime();
+
+    expect(runtime.network.name).toBe("testnet");
+    expect(runtime.network.rpc).toContain("testnet.movementnetwork.xyz");
+    expect(runtime.config.network).toBe("testnet");
+    expect(runtime.aptos).toBeDefined();
+    expect(runtime.account).toBeDefined();
+    // accounts array reflects both keys configured.
+    expect(runtime.accounts).toHaveLength(2);
+  });
+
+  it("switches network via the `network` option", async () => {
+    const runtime = await initRuntime({ network: "custom" });
+
+    expect(runtime.network.name).toBe("custom");
+    expect(runtime.network.rpc).toContain("custom.example.com");
+    expect(runtime.accounts).toHaveLength(1);
+  });
+
+  it("selects a specific account via `accountIndex`", async () => {
+    const runtime = await initRuntime({ accountIndex: 1 });
+
+    // The primary `account` is the indexed pick.
+    expect(runtime.account.accountAddress.toString()).toBe(
+      runtime.accounts[1]!.accountAddress.toString()
+    );
+    expect(runtime.account.accountAddress.toString()).not.toBe(
+      runtime.accounts[0]!.accountAddress.toString()
+    );
+  });
+
+  it("throws a clear error when accountIndex is out of range", async () => {
+    await expect(initRuntime({ accountIndex: 5 })).rejects.toThrow(
+      /Account index 5 not found/
+    );
+  });
+
+  it("merges `configOverride` on top of the loaded user config", async () => {
+    const runtime = await initRuntime({
+      configOverride: { defaultNetwork: "custom" },
+    });
+
+    // The override flips defaultNetwork → 'custom' so resolveNetworkConfig
+    // picks the custom entry without requiring an explicit `network` arg.
+    expect(runtime.network.name).toBe("custom");
+  });
+
+  it("getAccountByIndex returns the account at the given slot", async () => {
+    const runtime = await initRuntime();
+    expect(runtime.getAccountByIndex(0).accountAddress.toString()).toBe(
+      runtime.accounts[0]!.accountAddress.toString()
+    );
+    expect(runtime.getAccountByIndex(1).accountAddress.toString()).toBe(
+      runtime.accounts[1]!.accountAddress.toString()
+    );
+  });
+
+  it("getAccountByIndex throws on out-of-range index", async () => {
+    const runtime = await initRuntime();
+    expect(() => runtime.getAccountByIndex(99)).toThrow(
+      /Account index 99 out of range/
+    );
+  });
+
+  it("createAccount returns a fresh account each call (pool grows)", async () => {
+    const runtime = await initRuntime();
+    const before = AccountManager.getPoolSize();
+    const a = runtime.createAccount();
+    const b = runtime.createAccount();
+    expect(a.accountAddress.toString()).not.toBe(b.accountAddress.toString());
+    expect(AccountManager.getPoolSize()).toBe(before + 2);
+  });
+
+  it("getAccount loads from a private key hex", async () => {
+    const runtime = await initRuntime();
+    const acc = runtime.getAccount(TEST_KEY_B);
+    expect(acc.accountAddress.toString()).toBe(
+      runtime.accounts[1]!.accountAddress.toString()
+    );
+  });
+
+  it("switchNetwork returns a new runtime bound to the requested network", async () => {
+    const runtime = await initRuntime();
+    expect(runtime.network.name).toBe("testnet");
+
+    const switched = await runtime.switchNetwork("custom");
+    expect(switched.network.name).toBe("custom");
+    expect(switched.network.rpc).toContain("custom.example.com");
+    // Original runtime is unaffected — switchNetwork builds fresh.
+    expect(runtime.network.name).toBe("testnet");
+  });
+
+  it("getDeployment / getDeployments / getDeploymentAddress return null/empty for an unused network", async () => {
+    const runtime = await initRuntime();
+    // Nothing deployed in the tmp cwd, so these all short-circuit.
+    expect(runtime.getDeployment("counter")).toBeNull();
+    expect(runtime.getDeployments()).toEqual({});
+    expect(runtime.getDeploymentAddress("counter")).toBeNull();
+  });
+
+  it("getContract returns a MoveContract bound to the requested address+module", async () => {
+    const runtime = await initRuntime();
+    const dummyAddr = "0x" + "a".repeat(64);
+    const contract = runtime.getContract(dummyAddr, "counter");
+    expect(contract).toBeDefined();
+    // MoveContract holds the address+module pair; assert shape, not behavior
+    // (call/view would require a real chain).
+    expect(contract).toHaveProperty("call");
+    expect(contract).toHaveProperty("view");
+  });
+});
+

package/src/cli.ts

@@ -118,7 +118,7 @@ program
 // Fork commands
 const fork = program
     .command('fork')
-    .description('Manage local forks of Movement/Aptos networks');
+    .description('Manage local forks of Movement networks');
 
 fork
     .command('create')
@@ -154,6 +154,7 @@ fork
     .description('Start a local RPC server serving the fork')
     .option('-f, --fork <path>', 'Path to the fork')
     .option('-p, --port <port>', 'Port to listen on (default: 8080)', parsePort, 8080)
+    .option('--host <host>', 'Interface to bind (default: 127.0.0.1; use 0.0.0.0 to expose to LAN)', '127.0.0.1')
     .action((options) => forkServeCommand(options));
 
 program.parse(process.argv);