movehat 0.2.4 → 0.2.5

package/src/core/Publisher.ts

@@ -1,310 +0,0 @@
-import { Account, PrivateKey, PrivateKeyVariants } from "@aptos-labs/ts-sdk";
-import { MovehatConfig } from "../types/config.js";
-import { extractNamedAddresses } from "../commands/compile.js";
-import {
-  saveDeployment,
-  loadDeployment,
-  DeploymentInfo,
-  validateSafeName,
-} from "./deployments.js";
-import { validatePathSafety } from "./shell.js";
-import { CliExecutionError, ModuleAlreadyDeployedError, PostPublishError } from "../errors.js";
-import { runCli } from "../utils/runCli.js";
-import { logger, isVerbose } from "../ui/index.js";
-import { withSpinner } from "../ui/spinner.js";
-import type { ChildProcessAdapter } from "../utils/childProcessAdapter.js";
-import {
-  writeTempKeyFile,
-  removeKeyFile,
-  removeKeyFileSyncBestEffort,
-  ensureSignalHandler,
-  cleanupCallbacks,
-} from "./movementProfile.js";
-import { parseTxHash } from "../utils/parseCliOutput.js";
-
-/** @internal */
-export interface PublisherDeps {
-  adapter?: ChildProcessAdapter | undefined;
-}
-
-/** @internal */
-export interface PublishInput {
-  moduleName: string;
-  config: MovehatConfig;
-  account: Account;
-  packageDir?: string | undefined;
-}
-
-/**
- * Publishes a Move module via the Movement CLI.
- *
- * @internal
- */
-export class Publisher {
-  constructor(private readonly deps: PublisherDeps = {}) {}
-
-  async deploy(input: PublishInput): Promise<DeploymentInfo> {
-    const { moduleName, config, account } = input;
-
-    validateSafeName(moduleName, "module");
-
-    const forceRedeploy = process.env.MH_CLI_REDEPLOY === "true";
-
-    const existingDeployment = loadDeployment(config.network, moduleName);
-    if (existingDeployment && !forceRedeploy) {
-      // Build detailed error message with all deployment info
-      const errorDetails = [
-        `Module "${moduleName}" is already deployed on ${config.network}`,
-        `Address: ${existingDeployment.address}`,
-        `Deployed at: ${new Date(existingDeployment.timestamp).toLocaleString()}`,
-        existingDeployment.txHash ? `Transaction: ${existingDeployment.txHash}` : null,
-        `\nTo redeploy, run with the --redeploy flag:`,
-        `movehat run <script> --network ${config.network} --redeploy`,
-      ]
-        .filter(Boolean)
-        .join("\n");
-
-      // Log formatted error message for user
-      logger.error(`Module "${moduleName}" is already deployed on ${config.network}`);
-      logger.plain(`   Address: ${existingDeployment.address}`);
-      logger.plain(
-        `   Deployed at: ${new Date(existingDeployment.timestamp).toLocaleString()}`
-      );
-      if (existingDeployment.txHash) {
-        logger.plain(`   Transaction: ${existingDeployment.txHash}`);
-      }
-      logger.newline();
-      logger.info("To redeploy, run with the --redeploy flag:");
-      logger.plain(`   movehat run <script> --network ${config.network} --redeploy`);
-      logger.newline();
-
-      // Throw custom error with complete context for programmatic handling
-      throw new ModuleAlreadyDeployedError(
-        errorDetails,
-        moduleName,
-        config.network,
-        existingDeployment.address,
-        existingDeployment.timestamp,
-        existingDeployment.txHash
-      );
-    }
-
-    if (forceRedeploy && existingDeployment) {
-      logger.info(`Redeploying module "${moduleName}" on ${config.network}...`);
-    }
-
-    const dir = input.packageDir || config.moveDir;
-
-    // Validate (no shell escape — runCli uses spawn, which takes args
-    // verbatim and would treat the single-quote wrapping as part of the
-    // literal path, breaking Movement CLI argument parsing).
-    const safeDir = validatePathSafety(dir, "package directory");
-
-    logger.step(`Publishing module "${moduleName}" from ${dir}...`);
-
-    try {
-      // Get the deployer address to use for named addresses
-      const deployerAddress = account.accountAddress.toString();
-
-      // Detect named addresses from Move files
-      const detectedAddresses = extractNamedAddresses(dir);
-
-      // Build named addresses argument - use deployer address for all detected addresses.
-      // Stored as a pre-split args fragment so the spawn path never has to parse
-      // shell tokens; an empty fragment becomes a no-op via spread.
-      const namedAddrArgs: string[] =
-        detectedAddresses.size > 0
-          ? [
-              "--named-addresses",
-              Array.from(detectedAddresses)
-                .map((name) => `${name}=${deployerAddress}`)
-                .join(","),
-            ]
-          : [];
-
-      // Build first with named addresses
-      const buildResult = await withSpinner(
-        "Building package",
-        () =>
-          runCli(
-            {
-              command: "movement",
-              args: ["move", "build", "--package-dir", safeDir, ...namedAddrArgs],
-              timeoutMs: 120000, // 2 minutes for git dependency downloads
-            },
-            { adapter: this.deps.adapter }
-          ),
-      );
-      if (isVerbose() && buildResult.stdout) {
-        logger.info(buildResult.stdout.trim(), 2);
-      }
-
-      // Publish using direct parameters (avoid config file issues)
-
-      // Format the private key into AIP-80 shape so the Movement CLI
-      // doesn't emit its raw-hex deprecation warning. `formatPrivateKey`
-      // is idempotent for already-prefixed inputs.
-      const formattedPrivateKey = PrivateKey.formatPrivateKey(
-        config.privateKey,
-        PrivateKeyVariants.Ed25519,
-      );
-
-      // Move.toml is NOT mutated. All address overrides flow through
-      // the `--named-addresses` flag above, which Movement CLI applies
-      // during build + publish. Rewriting Move.toml on disk would risk
-      // leaving the user's file mutated if the process died before the
-      // restore step.
-
-      let publishOut = "";
-      let publishErr = "";
-
-      // Pass the private key to Movement CLI via a 0o600 temp file
-      // (`--private-key-file <path>`) and the on-chain address via
-      // `--sender-account <addr>`. This avoids the CLI's profile-yaml
-      // lookup chain entirely — no CWD / HOME / .aptos / .movement
-      // dance, no CLI-variant dependency.
-      const keyFilePath = writeTempKeyFile(formattedPrivateKey);
-
-      // Register a sync cleanup hook BEFORE invoking the CLI. If the
-      // user Ctrl+C's (or the process is SIGTERM'd) between the file
-      // write and our finally, the SIGINT handler iterates every
-      // registered callback and unlinks this deploy's key file
-      // synchronously so the private key never persists on disk after
-      // an abnormal exit. The signal-handler path uses the
-      // best-effort variant because the event loop is dead and we
-      // cannot logger.warning.
-      ensureSignalHandler();
-      const syncCleanup = () => removeKeyFileSyncBestEffort(keyFilePath);
-      cleanupCallbacks.add(syncCleanup);
-
-      try {
-        // Execute publish command. Private key reaches the CLI via the
-        // temp key file path (--private-key-file) — never on the
-        // command line — so it can't leak through `ps aux`. runCli's
-        // stdout/stderr redaction still applies as defense in depth
-        // for any `ed25519-priv-…` substring that surfaces in CLI
-        // output (Movement CLI sometimes echoes the key on error).
-        const publishResult = await withSpinner(
-          "Publishing to blockchain",
-          () =>
-            runCli(
-              {
-                command: "movement",
-                args: [
-                  "move",
-                  "publish",
-                  "--package-dir",
-                  safeDir,
-                  "--url",
-                  config.rpc,
-                  "--private-key-file",
-                  keyFilePath,
-                  "--sender-account",
-                  deployerAddress,
-                  "--assume-yes",
-                  ...namedAddrArgs,
-                ],
-                timeoutMs: 120000, // 2 minutes for blockchain transactions
-              },
-              { adapter: this.deps.adapter }
-            ),
-        );
-        publishOut = publishResult.stdout;
-        publishErr = publishResult.stderr;
-        // Both stdout and stderr from the publish subprocess are gated
-        // behind isVerbose() — Movement CLI emits progress to both
-        // streams ("Compiling, may take a little while..."), so a
-        // visible stderr line is not by itself a failure signal. The
-        // surrounding withSpinner converts the runCli throw on real
-        // failure into the visible spinner.fail() output instead.
-        if (isVerbose() && publishOut) logger.info(publishOut.trim(), 2);
-        if (isVerbose() && publishErr) logger.info(publishErr.trim(), 2);
-      } finally {
-        // Unlink the temp key file via the observable cleanup helper.
-        // ENOENT and other already-gone outcomes are benign (null).
-        // A non-null Error means the unlink failed AND the file still
-        // exists on disk — the private key would persist silently
-        // otherwise, so we emit a warning with the manual-cleanup
-        // hint. The SIGINT signal handler's sync callback below also
-        // tries to remove the same file; if SIGINT fires before this
-        // finally runs the file is gone and the next finally call
-        // sees ENOENT (benign).
-        const cleanupErr = removeKeyFile(keyFilePath);
-        if (cleanupErr) {
-          logger.warning(
-            `Failed to remove temp key file '${keyFilePath}': ${cleanupErr.message}. ` +
-              `The file has mode 0o600 but should be removed manually: rm ${keyFilePath}`
-          );
-        }
-        cleanupCallbacks.delete(syncCleanup);
-      }
-
-      // Extract transaction hash from output via the shared helper
-      // (`utils/parseCliOutput.ts`). Same regex pair as before; lifted
-      // for reuse by harness/codeObject.ts and harness/script.ts.
-      const txHash = parseTxHash(publishOut);
-
-      logger.success("Module published successfully!");
-
-      // ←← "Publish succeeded" boundary. Anything thrown below this
-      // point did NOT cause the publish to fail — the module is on
-      // chain. We surface those failures as PostPublishError so callers
-      // can distinguish a genuine publish failure from a local
-      // bookkeeping failure (and avoid a wasteful redeploy).
-
-      const deployment: DeploymentInfo = {
-        address: account.accountAddress.toString(),
-        moduleName,
-        network: config.network,
-        deployer: account.accountAddress.toString(),
-        timestamp: Date.now(),
-        txHash,
-      };
-
-      try {
-        saveDeployment(deployment);
-      } catch (error) {
-        const err = error instanceof Error ? error : new Error(String(error));
-        throw new PostPublishError(
-          `Module "${moduleName}" published to ${deployment.address} ` +
-          `but local deployment record could not be written: ${err.message}`,
-          deployment,
-          err
-        );
-      }
-
-      return deployment;
-    } catch (error) {
-      if (error instanceof PostPublishError) {
-        // Publish DID succeed; only local persistence failed. Log as
-        // warning (not error) so the user knows the deploy is real on
-        // chain. Re-throw so programmatic callers can react.
-        logger.warning(
-          `Module published successfully to ${error.deployment.address} ` +
-          `(tx=${error.deployment.txHash ?? "unknown"}) ` +
-          `but local deployment record could not be written.`
-        );
-        logger.warning(`   Cause: ${error.cause.message}`);
-        logger.warning(
-          `   To recover, manually write the deployment to ` +
-          `deployments/${error.deployment.network}/${error.deployment.moduleName}.json.`
-        );
-        throw error;
-      }
-      if (error instanceof CliExecutionError) {
-        // stdout/stderr are already redacted by runCli before reaching here,
-        // so this branch is safe to log verbatim.
-        if (error.stdoutPreview) logger.info(error.stdoutPreview, 2);
-        logger.error(`Failed to publish module: ${error.message}\n${error.stderr}`);
-      } else {
-        // Preserve existing behaviour for non-CLI errors (filesystem write
-        // failures from Move.toml / ~/.aptos/config.yaml, yaml parse errors,
-        // etc.). These paths can't carry private-key material so logging raw
-        // is safe.
-        const err = error instanceof Error ? error : new Error(String(error));
-        logger.error(`Failed to publish module: ${err.message}`);
-      }
-      throw error;
-    }
-  }
-}

package/src/core/__tests__/AccountManager.global-state.test.ts

@@ -1,83 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { existsSync, mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { AccountManager } from "../AccountManager.js";
-
-/**
- * F8 — Document the two known limitations of `AccountManager`:
- *
- *   (a) State is class-static. Two harness "sessions" in the same
- *       process share the pool, the labelMap, and the private-key
- *       map. A label re-used across sessions overwrites the entry.
- *       This is intentional per `Harness.ts:39-42` ("Two Harness
- *       instances in the same process share account labels"). This
- *       test captures the contract so a future refactor cannot
- *       silently change it.
- *
- *   (b) `defaultPoolPath = join(process.cwd(), ".movehat", "accounts")`
- *       is evaluated when the module is first imported, NOT lazily on
- *       each call. Changing `process.cwd()` after import does not move
- *       the save destination. Callers needing per-test isolation must
- *       pass an explicit `poolPath` argument.
- */
-
-describe("F8 — AccountManager static state and import-time cwd capture", () => {
-  let cwdBackup: string;
-  let tmpDir: string;
-
-  beforeEach(() => {
-    AccountManager.clearPool();
-    cwdBackup = process.cwd();
-    tmpDir = mkdtempSync(join(tmpdir(), "movehat-f8-"));
-  });
-
-  afterEach(() => {
-    AccountManager.clearPool();
-    if (process.cwd() !== cwdBackup) {
-      process.chdir(cwdBackup);
-    }
-    rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it("(a) re-creating an account with an existing label overwrites the labelMap entry", () => {
-    const first = AccountManager.createAccount("alice");
-    const second = AccountManager.createAccount("alice");
-    expect(second.accountAddress.toString()).not.toBe(
-      first.accountAddress.toString()
-    );
-
-    const lookup = AccountManager.getAccountByLabel("alice");
-    expect(lookup).toBeDefined();
-    expect(lookup!.accountAddress.toString()).toBe(
-      second.accountAddress.toString()
-    );
-    // The first account is still in the pool (keyed by address), only
-    // the label binding moved. A second harness session that creates
-    // its own "alice" will silently shadow the first — this is the
-    // documented Harness limitation. exportPrivateKeys reflects the
-    // current label binding (i.e. the second account).
-    const exportedKeys = AccountManager.exportPrivateKeys(["alice"]);
-    expect(exportedKeys.alice).toBeTypeOf("string");
-    expect(exportedKeys.alice!.length).toBeGreaterThan(0);
-  });
-
-  it("(b) saveAccountPool ignores a process.chdir after import; defaults to the import-time cwd", () => {
-    AccountManager.createAccount("bob");
-
-    process.chdir(tmpDir);
-    // No path argument → uses defaultPoolPath, which was set at module
-    // load time before this chdir.
-    AccountManager.saveAccountPool();
-
-    // The pool file must NOT appear under the freshly-chdir'd cwd.
-    const expectedAtNewCwd = join(tmpDir, ".movehat", "accounts", "test-pool.json");
-    expect(existsSync(expectedAtNewCwd)).toBe(false);
-
-    // Sanity check: explicit poolPath does land where the caller asked.
-    const explicit = join(tmpDir, "explicit");
-    AccountManager.saveAccountPool(explicit);
-    expect(existsSync(join(explicit, "test-pool.json"))).toBe(true);
-  });
-});

package/src/core/__tests__/AccountManager.test.ts

@@ -1,290 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { mkdtempSync, rmSync, statSync, existsSync, writeFileSync } from "fs";
-import { tmpdir, platform } from "os";
-import { join } from "path";
-import { AccountManager } from "../AccountManager.js";
-import type { MovehatConfig } from "../../types/config.js";
-
-describe("AccountManager.saveAccountPool", () => {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), "movehat-acc-pool-"));
-    AccountManager.clearPool();
-  });
-
-  afterEach(() => {
-    AccountManager.clearPool();
-    if (existsSync(tmpDir)) {
-      rmSync(tmpDir, { recursive: true, force: true });
-    }
-  });
-
-  it("writes test-pool.json with 0o600 permissions", () => {
-    AccountManager.createAccount("alice");
-    AccountManager.createAccount("bob");
-
-    const poolDir = join(tmpDir, "accounts");
-    AccountManager.saveAccountPool(poolDir);
-
-    const poolFile = join(poolDir, "test-pool.json");
-    expect(existsSync(poolFile)).toBe(true);
-
-    // Mode check is POSIX-only; skip on Windows where mode bits don't apply.
-    if (platform() !== "win32") {
-      const stat = statSync(poolFile);
-      const mode = stat.mode & 0o777;
-      expect(mode).toBe(0o600);
-    }
-  });
-
-  it("creates the pool directory with 0o700 permissions when missing", () => {
-    AccountManager.createAccount("alice");
-
-    const poolDir = join(tmpDir, "fresh-accounts");
-    AccountManager.saveAccountPool(poolDir);
-
-    expect(existsSync(poolDir)).toBe(true);
-
-    if (platform() !== "win32") {
-      const stat = statSync(poolDir);
-      const mode = stat.mode & 0o777;
-      expect(mode).toBe(0o700);
-    }
-  });
-});
-
-const TEST_KEY_A =
-  "0x0000000000000000000000000000000000000000000000000000000000000001";
-const TEST_KEY_B =
-  "0x0000000000000000000000000000000000000000000000000000000000000002";
-
-describe("AccountManager — create / lookup / label", () => {
-  beforeEach(() => {
-    AccountManager.clearPool();
-  });
-
-  afterEach(() => {
-    AccountManager.clearPool();
-  });
-
-  it("getTestAccount(label) creates on first call, returns the same on second", () => {
-    const first = AccountManager.getTestAccount("alice");
-    const second = AccountManager.getTestAccount("alice");
-    expect(second.accountAddress.toString()).toBe(first.accountAddress.toString());
-  });
-
-  it("getTestAccount() with no label creates a fresh unlabeled account", () => {
-    const a = AccountManager.getTestAccount();
-    const b = AccountManager.getTestAccount();
-    expect(a.accountAddress.toString()).not.toBe(b.accountAddress.toString());
-  });
-
-  it("createAccount tracks the new account in the pool", () => {
-    expect(AccountManager.getPoolSize()).toBe(0);
-    AccountManager.createAccount("alice");
-    AccountManager.createAccount("bob");
-    expect(AccountManager.getPoolSize()).toBe(2);
-  });
-
-  it("getAccountByLabel returns undefined for an unknown label", () => {
-    expect(AccountManager.getAccountByLabel("missing")).toBeUndefined();
-  });
-
-  it("getLabeledAccounts returns a map of every labeled account", () => {
-    AccountManager.createAccount("alice");
-    AccountManager.createAccount("bob");
-    AccountManager.createAccount(); // unlabeled — should NOT appear
-    const labeled = AccountManager.getLabeledAccounts();
-    expect(Object.keys(labeled).sort()).toEqual(["alice", "bob"]);
-  });
-
-  it("hasLabel reflects the label map state", () => {
-    expect(AccountManager.hasLabel("alice")).toBe(false);
-    AccountManager.createAccount("alice");
-    expect(AccountManager.hasLabel("alice")).toBe(true);
-  });
-
-  it("getOrCreateLabeled returns the existing labeled account on second call", () => {
-    const first = AccountManager.getOrCreateLabeled("alice");
-    const second = AccountManager.getOrCreateLabeled("alice");
-    expect(second.accountAddress.toString()).toBe(first.accountAddress.toString());
-    expect(AccountManager.getPoolSize()).toBe(1);
-  });
-
-  it("createBatch creates one account per label and returns the map", () => {
-    const accounts = AccountManager.createBatch(["alice", "bob", "charlie"]);
-    expect(Object.keys(accounts).sort()).toEqual(["alice", "bob", "charlie"]);
-    expect(AccountManager.getPoolSize()).toBe(3);
-  });
-
-  it("getAllAccounts returns every account in insertion order", () => {
-    const a = AccountManager.createAccount("alice");
-    const b = AccountManager.createAccount("bob");
-    const addrs = AccountManager.getAllAccounts().map((acc) =>
-      acc.accountAddress.toString()
-    );
-    // Insertion order is preserved by the underlying Map iteration.
-    expect(addrs).toEqual([
-      a.accountAddress.toString(),
-      b.accountAddress.toString(),
-    ]);
-  });
-
-  it("clearPool resets pool, label map, and poolLoaded flag", () => {
-    AccountManager.createAccount("alice");
-    expect(AccountManager.getPoolSize()).toBe(1);
-    AccountManager.clearPool();
-    expect(AccountManager.getPoolSize()).toBe(0);
-    expect(AccountManager.hasLabel("alice")).toBe(false);
-  });
-});
-
-describe("AccountManager — load from env / key / config", () => {
-  let origEnv: string | undefined;
-
-  beforeEach(() => {
-    AccountManager.clearPool();
-    origEnv = process.env.PRIVATE_KEY;
-    delete process.env.PRIVATE_KEY;
-  });
-
-  afterEach(() => {
-    AccountManager.clearPool();
-    if (origEnv === undefined) delete process.env.PRIVATE_KEY;
-    else process.env.PRIVATE_KEY = origEnv;
-  });
-
-  it("loadAccountFromEnv reads from PRIVATE_KEY by default", () => {
-    process.env.PRIVATE_KEY = TEST_KEY_A;
-    const acc = AccountManager.loadAccountFromEnv();
-    expect(acc.accountAddress.toString()).toMatch(/^0x[a-f0-9]+$/i);
-  });
-
-  it("loadAccountFromEnv reads from a custom env var name", () => {
-    process.env.MY_CUSTOM_KEY = TEST_KEY_A;
-    try {
-      const acc = AccountManager.loadAccountFromEnv("MY_CUSTOM_KEY");
-      expect(acc.accountAddress.toString()).toMatch(/^0x[a-f0-9]+$/i);
-    } finally {
-      delete process.env.MY_CUSTOM_KEY;
-    }
-  });
-
-  it("loadAccountFromEnv throws when the env var is unset", () => {
-    expect(() => AccountManager.loadAccountFromEnv("DEFINITELY_NOT_SET")).toThrow(
-      /not found/
-    );
-  });
-
-  it("loadAccountFromPrivateKey adds the account to the pool", () => {
-    expect(AccountManager.getPoolSize()).toBe(0);
-    AccountManager.loadAccountFromPrivateKey(TEST_KEY_A);
-    expect(AccountManager.getPoolSize()).toBe(1);
-  });
-
-  it("loadAccountsFromConfig loads every valid key", () => {
-    const config = {
-      allAccounts: [TEST_KEY_A, TEST_KEY_B],
-    } as unknown as MovehatConfig;
-    const accounts = AccountManager.loadAccountsFromConfig(config);
-    expect(accounts).toHaveLength(2);
-  });
-
-  it("loadAccountsFromConfig warns on a malformed key and skips it", () => {
-    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => undefined);
-    const config = {
-      allAccounts: [TEST_KEY_A, "not-a-real-key"],
-    } as unknown as MovehatConfig;
-    const accounts = AccountManager.loadAccountsFromConfig(config);
-    expect(accounts).toHaveLength(1);
-    expect(warnSpy).toHaveBeenCalledWith(
-      expect.stringMatching(/Failed to load account from config/)
-    );
-    warnSpy.mockRestore();
-  });
-});
-
-describe("AccountManager.loadAccountPool / exportPrivateKeys", () => {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), "movehat-acc-load-"));
-    AccountManager.clearPool();
-  });
-
-  afterEach(() => {
-    AccountManager.clearPool();
-    if (existsSync(tmpDir)) {
-      rmSync(tmpDir, { recursive: true, force: true });
-    }
-  });
-
-  it("loadAccountPool returns false when the file does not exist", () => {
-    expect(AccountManager.loadAccountPool(tmpDir)).toBe(false);
-  });
-
-  it("loadAccountPool restores accounts and labels from disk", () => {
-    // Plant a pool via save → clear → load round-trip.
-    AccountManager.createAccount("alice");
-    AccountManager.createAccount("bob");
-    const poolDir = join(tmpDir, "accounts");
-    AccountManager.saveAccountPool(poolDir);
-    AccountManager.clearPool();
-    expect(AccountManager.getPoolSize()).toBe(0);
-
-    const ok = AccountManager.loadAccountPool(poolDir);
-    expect(ok).toBe(true);
-    expect(AccountManager.getPoolSize()).toBe(2);
-    expect(AccountManager.hasLabel("alice")).toBe(true);
-    expect(AccountManager.hasLabel("bob")).toBe(true);
-  });
-
-  it("loadAccountPool is a no-op when poolLoaded is already true", () => {
-    AccountManager.createAccount("alice");
-    const poolDir = join(tmpDir, "accounts");
-    AccountManager.saveAccountPool(poolDir);
-    expect(AccountManager.loadAccountPool(poolDir)).toBe(true);
-    // Second call short-circuits via the poolLoaded flag.
-    expect(AccountManager.loadAccountPool(poolDir)).toBe(true);
-  });
-
-  it("loadAccountPool returns false and warns on corrupt JSON", () => {
-    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => undefined);
-    const poolDir = join(tmpDir, "accounts");
-    // mkdir then write a deliberately malformed test-pool.json.
-    AccountManager.createAccount("alice");
-    AccountManager.saveAccountPool(poolDir);
-    writeFileSync(join(poolDir, "test-pool.json"), "{ not valid json");
-    AccountManager.clearPool();
-    expect(AccountManager.loadAccountPool(poolDir)).toBe(false);
-    expect(warnSpy).toHaveBeenCalledWith(
-      expect.stringMatching(/Failed to load account pool/)
-    );
-    warnSpy.mockRestore();
-  });
-
-  it("exportPrivateKeys returns every labeled account's key when called with no args", () => {
-    AccountManager.createAccount("alice");
-    AccountManager.createAccount("bob");
-    const exported = AccountManager.exportPrivateKeys();
-    expect(Object.keys(exported).sort()).toEqual(["alice", "bob"]);
-    for (const key of Object.values(exported)) {
-      expect(typeof key).toBe("string");
-      expect(key.length).toBeGreaterThan(0);
-    }
-  });
-
-  it("exportPrivateKeys filters by labels when an array is passed", () => {
-    AccountManager.createAccount("alice");
-    AccountManager.createAccount("bob");
-    AccountManager.createAccount("charlie");
-    const exported = AccountManager.exportPrivateKeys(["alice", "charlie"]);
-    expect(Object.keys(exported).sort()).toEqual(["alice", "charlie"]);
-  });
-
-  it("exportPrivateKeys with an unknown label returns an empty map", () => {
-    const exported = AccountManager.exportPrivateKeys(["missing"]);
-    expect(exported).toEqual({});
-  });
-});