movehat 0.1.8 → 0.2.0

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

@@ -0,0 +1,290 @@
+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({});
+  });
+});

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

@@ -0,0 +1,377 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  utimesSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadUserConfig, resolveNetworkConfig, _resetConfigCache } from "../config.js";
+import type { MovehatUserConfig } from "../../types/config.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const CONFIG_A = `export default {
+  defaultNetwork: "testnet",
+  networks: {
+    testnet: { url: "https://testnet.movementnetwork.xyz/v1", chainId: "testnet" }
+  }
+};
+`;
+
+const CONFIG_B = `export default {
+  defaultNetwork: "mainnet",
+  networks: {
+    mainnet: { url: "https://mainnet.movementnetwork.xyz/v1", chainId: "mainnet" }
+  }
+};
+`;
+
+describe("loadUserConfig — mtime cache (#81, #62)", () => {
+  let tmpCwd: string;
+  let origCwd: string;
+
+  beforeEach(() => {
+    _resetConfigCache();
+    origCwd = process.cwd();
+    tmpCwd = mkdtempSync(join(tmpdir(), "movehat-config-test-"));
+    process.chdir(tmpCwd);
+  });
+
+  afterEach(() => {
+    process.chdir(origCwd);
+    rmSync(tmpCwd, { recursive: true, force: true });
+  });
+
+  it("first call reads from disk", async () => {
+    writeFileSync(join(tmpCwd, "movehat.config.js"), CONFIG_A);
+
+    const config = await loadUserConfig();
+
+    expect(config.defaultNetwork).toBe("testnet");
+    expect(config.networks).toHaveProperty("testnet");
+  });
+
+  it("second call returns the same parsed object (cache hit)", async () => {
+    writeFileSync(join(tmpCwd, "movehat.config.js"), CONFIG_A);
+
+    const first = await loadUserConfig();
+    const second = await loadUserConfig();
+
+    // Reference equality proves we returned the cached object rather
+    // than re-importing and getting a structurally-equal copy.
+    expect(second).toBe(first);
+  });
+
+  it("mtime change invalidates the cache", async () => {
+    const path = join(tmpCwd, "movehat.config.js");
+    writeFileSync(path, CONFIG_A);
+
+    const first = await loadUserConfig();
+    expect(first.defaultNetwork).toBe("testnet");
+
+    // Rewrite + force an mtime far in the future so we don't depend on
+    // filesystem mtime resolution.
+    writeFileSync(path, CONFIG_B);
+    const future = new Date(Date.now() + 60_000);
+    utimesSync(path, future, future);
+
+    const second = await loadUserConfig();
+
+    expect(second).not.toBe(first);
+    expect(second.defaultNetwork).toBe("mainnet");
+    expect(second.networks).toHaveProperty("mainnet");
+  });
+
+  it("different cwds keep separate cache entries", async () => {
+    writeFileSync(join(tmpCwd, "movehat.config.js"), CONFIG_A);
+    const fromA = await loadUserConfig();
+    expect(fromA.defaultNetwork).toBe("testnet");
+
+    const tmpCwdB = mkdtempSync(join(tmpdir(), "movehat-config-test-b-"));
+    try {
+      process.chdir(tmpCwdB);
+      writeFileSync(join(tmpCwdB, "movehat.config.js"), CONFIG_B);
+      const fromB = await loadUserConfig();
+      expect(fromB.defaultNetwork).toBe("mainnet");
+
+      // Switching back to A returns A's cached entry, not B's — proves
+      // the cache is keyed by absolute path, not by something process-
+      // scoped like "the last value loaded".
+      process.chdir(tmpCwd);
+      const fromAagain = await loadUserConfig();
+      expect(fromAagain).toBe(fromA);
+      expect(fromAagain.defaultNetwork).toBe("testnet");
+    } finally {
+      process.chdir(tmpCwd);
+      rmSync(tmpCwdB, { recursive: true, force: true });
+    }
+  });
+
+  it("source file no longer contains the `?t=` cache-bust (#62 regression guard)", () => {
+    const configSrc = readFileSync(join(__dirname, "..", "config.ts"), "utf-8");
+
+    expect(configSrc).not.toMatch(/\?t=['"]\s*\+\s*Date\.now/);
+  });
+
+  // Note: there's no direct behavioral test for `_resetConfigCache()`.
+  // The function is exercised in `beforeEach` above — if it didn't
+  // actually clear the in-memory map, tests 3 and 4 would leak state
+  // between each other and start failing. Its "test" is therefore the
+  // rest of this suite continuing to pass.
+
+  it("throws when no movehat.config.{ts,js} is present", async () => {
+    // tmpCwd is empty (no config written) — should reject with the
+    // 'Configuration file not found' message.
+    await expect(loadUserConfig()).rejects.toThrow(/Configuration file not found/);
+  });
+
+  it("rejects a config with empty `networks`", async () => {
+    writeFileSync(
+      join(tmpCwd, "movehat.config.js"),
+      `export default { networks: {} };
+`
+    );
+    await expect(loadUserConfig()).rejects.toThrow(/No networks defined/);
+  });
+});
+
+const TEST_KEY =
+  "0x0000000000000000000000000000000000000000000000000000000000000001";
+
+const baseUserConfig = (networks: MovehatUserConfig["networks"]): MovehatUserConfig => ({
+  networks,
+});
+
+describe("resolveNetworkConfig", () => {
+  const envSnapshot: Record<string, string | undefined> = {};
+
+  beforeEach(() => {
+    envSnapshot.PRIVATE_KEY = process.env.PRIVATE_KEY;
+    envSnapshot.MH_CLI_NETWORK = process.env.MH_CLI_NETWORK;
+    envSnapshot.MH_DEFAULT_NETWORK = process.env.MH_DEFAULT_NETWORK;
+    delete process.env.PRIVATE_KEY;
+    delete process.env.MH_CLI_NETWORK;
+    delete process.env.MH_DEFAULT_NETWORK;
+  });
+
+  afterEach(() => {
+    for (const [key, value] of Object.entries(envSnapshot)) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  });
+
+  it("uses the network passed as the argument over defaultNetwork", async () => {
+    const user = baseUserConfig({
+      a: { url: "https://a.example.com/v1", chainId: "a", accounts: [TEST_KEY] },
+      b: { url: "https://b.example.com/v1", chainId: "b", accounts: [TEST_KEY] },
+    });
+    user.defaultNetwork = "a";
+    const resolved = await resolveNetworkConfig(user, "b");
+    expect(resolved.network).toBe("b");
+    expect(resolved.rpc).toBe("https://b.example.com/v1");
+  });
+
+  it("MH_CLI_NETWORK env var overrides defaultNetwork when no arg is passed", async () => {
+    process.env.MH_CLI_NETWORK = "b";
+    const user = baseUserConfig({
+      a: { url: "https://a.example.com/v1", chainId: "a", accounts: [TEST_KEY] },
+      b: { url: "https://b.example.com/v1", chainId: "b", accounts: [TEST_KEY] },
+    });
+    user.defaultNetwork = "a";
+    const resolved = await resolveNetworkConfig(user);
+    expect(resolved.network).toBe("b");
+  });
+
+  it("MH_DEFAULT_NETWORK env var is the next-lower priority after MH_CLI_NETWORK", async () => {
+    process.env.MH_DEFAULT_NETWORK = "b";
+    const user = baseUserConfig({
+      a: { url: "https://a.example.com/v1", chainId: "a", accounts: [TEST_KEY] },
+      b: { url: "https://b.example.com/v1", chainId: "b", accounts: [TEST_KEY] },
+    });
+    user.defaultNetwork = "a";
+    const resolved = await resolveNetworkConfig(user);
+    expect(resolved.network).toBe("b");
+  });
+
+  it("auto-generates a testnet config when 'testnet' is missing from user networks", async () => {
+    const logSpy = vi.spyOn(console, "log").mockImplementation(() => undefined);
+    const user = baseUserConfig({
+      a: { url: "https://a.example.com/v1", chainId: "a", accounts: [TEST_KEY] },
+    });
+    const resolved = await resolveNetworkConfig(user, "testnet");
+    expect(resolved.network).toBe("testnet");
+    expect(resolved.rpc).toBe("https://testnet.movementnetwork.xyz/v1");
+    logSpy.mockRestore();
+  });
+
+  it("auto-generates a local config when 'local' is missing from user networks", async () => {
+    const logSpy = vi.spyOn(console, "log").mockImplementation(() => undefined);
+    const user = baseUserConfig({
+      a: { url: "https://a.example.com/v1", chainId: "a", accounts: [TEST_KEY] },
+    });
+    const resolved = await resolveNetworkConfig(user, "local");
+    expect(resolved.network).toBe("local");
+    expect(resolved.rpc).toBe("http://localhost:8080/v1");
+    logSpy.mockRestore();
+  });
+
+  it("throws on a completely unknown network with a clear list of available ones", async () => {
+    const user = baseUserConfig({
+      a: { url: "https://a.example.com/v1", chainId: "a", accounts: [TEST_KEY] },
+    });
+    await expect(resolveNetworkConfig(user, "nonexistent")).rejects.toThrow(
+      /Network 'nonexistent' not found/
+    );
+  });
+
+  it("falls back to PRIVATE_KEY env var when no accounts are configured anywhere", async () => {
+    process.env.PRIVATE_KEY = TEST_KEY;
+    const user = baseUserConfig({
+      a: { url: "https://a.example.com/v1", chainId: "a" },
+    });
+    const resolved = await resolveNetworkConfig(user, "a");
+    expect(resolved.privateKey).toBe(TEST_KEY);
+    expect(resolved.allAccounts).toEqual([TEST_KEY]);
+  });
+
+  it("auto-generates a deterministic test key for testnet when no accounts are anywhere", async () => {
+    const logSpy = vi.spyOn(console, "log").mockImplementation(() => undefined);
+    const user = baseUserConfig({
+      testnet: { url: "https://testnet.movementnetwork.xyz/v1", chainId: "testnet" },
+    });
+    const resolved = await resolveNetworkConfig(user, "testnet");
+    // The auto-generated key is the canonical Hardhat-style test key.
+    expect(resolved.privateKey).toBe(
+      "0x0000000000000000000000000000000000000000000000000000000000000001"
+    );
+    logSpy.mockRestore();
+  });
+
+  it("rejects a non-testnet/local network with no accounts (security gate)", async () => {
+    const user = baseUserConfig({
+      mainnet: { url: "https://mainnet.movementnetwork.xyz/v1", chainId: "mainnet" },
+    });
+    await expect(resolveNetworkConfig(user, "mainnet")).rejects.toThrow(
+      /requires explicit account configuration/
+    );
+  });
+
+  it("prefers network-specific accounts over global ones", async () => {
+    const user: MovehatUserConfig = {
+      accounts: ["0xglobal"],
+      networks: {
+        a: {
+          url: "https://a.example.com/v1",
+          chainId: "a",
+          accounts: [TEST_KEY],
+        },
+      },
+    };
+    const resolved = await resolveNetworkConfig(user, "a");
+    expect(resolved.privateKey).toBe(TEST_KEY);
+  });
+
+  it("falls back to global accounts when network has none", async () => {
+    const user: MovehatUserConfig = {
+      accounts: [TEST_KEY],
+      networks: {
+        a: { url: "https://a.example.com/v1", chainId: "a" },
+      },
+    };
+    const resolved = await resolveNetworkConfig(user, "a");
+    expect(resolved.privateKey).toBe(TEST_KEY);
+  });
+
+  it("merges named addresses, with network-specific overriding global", async () => {
+    const user: MovehatUserConfig = {
+      namedAddresses: { foo: "0xglobal", shared: "0xglobal" },
+      networks: {
+        a: {
+          url: "https://a.example.com/v1",
+          chainId: "a",
+          accounts: [TEST_KEY],
+          namedAddresses: { bar: "0xnet", shared: "0xnet" },
+        },
+      },
+    };
+    const resolved = await resolveNetworkConfig(user, "a");
+    expect(resolved.namedAddresses).toEqual({
+      foo: "0xglobal",
+      bar: "0xnet",
+      shared: "0xnet",
+    });
+  });
+
+  it("derives the on-chain account address from the resolved key", async () => {
+    const user = baseUserConfig({
+      a: { url: "https://a.example.com/v1", chainId: "a", accounts: [TEST_KEY] },
+    });
+    const resolved = await resolveNetworkConfig(user, "a");
+    // The canonical Hardhat-style 0x...01 key derives to a well-known address.
+    expect(resolved.account).toMatch(/^0x[a-f0-9]+$/i);
+    expect(resolved.account.length).toBeGreaterThan(2);
+  });
+
+  it("returns account='' and warns when the configured key is malformed", async () => {
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => undefined);
+    const user = baseUserConfig({
+      a: { url: "https://a.example.com/v1", chainId: "a", accounts: ["not-a-real-key"] },
+    });
+    const resolved = await resolveNetworkConfig(user, "a");
+    expect(resolved.account).toBe("");
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringMatching(/Could not derive account address/)
+    );
+    warnSpy.mockRestore();
+  });
+
+  it("strips the 'ed25519-priv-' prefix when deriving the account address", async () => {
+    const user = baseUserConfig({
+      a: {
+        url: "https://a.example.com/v1",
+        chainId: "a",
+        accounts: [`ed25519-priv-${TEST_KEY}`],
+      },
+    });
+    const resolved = await resolveNetworkConfig(user, "a");
+    // Same key, prefixed and unprefixed, should derive the same address.
+    const bareResolved = await resolveNetworkConfig(
+      baseUserConfig({
+        a: { url: "https://a.example.com/v1", chainId: "a", accounts: [TEST_KEY] },
+      }),
+      "a"
+    );
+    expect(resolved.account).toBe(bareResolved.account);
+  });
+
+  it("uses profile='default' when networkConfig has no profile", async () => {
+    const user = baseUserConfig({
+      a: { url: "https://a.example.com/v1", chainId: "a", accounts: [TEST_KEY] },
+    });
+    const resolved = await resolveNetworkConfig(user, "a");
+    expect(resolved.profile).toBe("default");
+  });
+
+  it("respects networkConfig.profile when set", async () => {
+    const user: MovehatUserConfig = {
+      networks: {
+        a: {
+          url: "https://a.example.com/v1",
+          chainId: "a",
+          accounts: [TEST_KEY],
+          profile: "custom-profile",
+        },
+      },
+    };
+    const resolved = await resolveNetworkConfig(user, "a");
+    expect(resolved.profile).toBe("custom-profile");
+  });
+});