@aixyz/cli 0.7.0 → 0.9.0

package/register/wallet/index.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, test, beforeEach, afterEach } from "bun:test";
+import { sepolia } from "viem/chains";
+import { selectWalletMethod, createWalletFromMethod, type WalletOptions } from "./index";
+
+// Valid test private key (do not use in production!)
+const TEST_PRIVATE_KEY = "0x0000000000000000000000000000000000000000000000000000000000000001";
+
+describe("selectWalletMethod", () => {
+  let originalEnv: string | undefined;
+
+  beforeEach(() => {
+    originalEnv = process.env.PRIVATE_KEY;
+    delete process.env.PRIVATE_KEY;
+  });
+
+  afterEach(() => {
+    if (originalEnv !== undefined) {
+      process.env.PRIVATE_KEY = originalEnv;
+    } else {
+      delete process.env.PRIVATE_KEY;
+    }
+  });
+
+  test("returns keystore method when keystore option provided", async () => {
+    const options: WalletOptions = { keystore: "/path/to/keystore" };
+    const result = await selectWalletMethod(options);
+    expect(result).toEqual({ type: "keystore", path: "/path/to/keystore" });
+  });
+
+  test("returns browser method when browser option provided", async () => {
+    const options: WalletOptions = { browser: true };
+    const result = await selectWalletMethod(options);
+    expect(result).toEqual({ type: "browser" });
+  });
+
+  test("returns privatekey method when PRIVATE_KEY env var set", async () => {
+    process.env.PRIVATE_KEY = TEST_PRIVATE_KEY;
+    const options: WalletOptions = {};
+    const result = await selectWalletMethod(options);
+    expect(result.type).toBe("privatekey");
+    expect(result.type === "privatekey" && (await result.resolveKey())).toBe(TEST_PRIVATE_KEY);
+    expect(process.env.PRIVATE_KEY).toBeUndefined();
+  });
+
+  test("keystore option takes precedence over env var", async () => {
+    process.env.PRIVATE_KEY = TEST_PRIVATE_KEY;
+    const options: WalletOptions = { keystore: "/path/to/keystore" };
+    const result = await selectWalletMethod(options);
+    expect(result).toEqual({ type: "keystore", path: "/path/to/keystore" });
+  });
+
+  test("browser option takes precedence over env var", async () => {
+    process.env.PRIVATE_KEY = TEST_PRIVATE_KEY;
+    const options: WalletOptions = { browser: true };
+    const result = await selectWalletMethod(options);
+    expect(result).toEqual({ type: "browser" });
+  });
+});
+
+describe("createWalletFromMethod", () => {
+  test("creates wallet for privatekey method", async () => {
+    const method = { type: "privatekey" as const, resolveKey: () => Promise.resolve(TEST_PRIVATE_KEY) };
+    const wallet = await createWalletFromMethod(method, sepolia);
+    expect(wallet).toBeDefined();
+    expect(wallet.account).toBeDefined();
+    expect(wallet.account?.address).toStrictEqual("0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf");
+  });
+
+  test("throws for missing keystore file", async () => {
+    const method = { type: "keystore" as const, path: "/path/to/keystore" };
+    await expect(createWalletFromMethod(method, sepolia)).rejects.toThrow("Keystore file not found");
+  });
+
+  test("throws for browser method (should use registerWithBrowser)", async () => {
+    const method = { type: "browser" as const };
+    await expect(createWalletFromMethod(method, sepolia)).rejects.toThrow(
+      "Browser wallets should use registerWithBrowser",
+    );
+  });
+});

package/register/wallet/index.ts

@@ -0,0 +1,83 @@
+import { homedir } from "node:os";
+import type { Chain, WalletClient } from "viem";
+import { select, input, password } from "@inquirer/prompts";
+import { createPrivateKeyWallet } from "./privatekey";
+import { createKeystoreWallet } from "./keystore";
+
+export interface WalletOptions {
+  keystore?: string;
+  browser?: boolean;
+  broadcast?: boolean;
+}
+
+export type WalletMethod =
+  | { type: "keystore"; path: string }
+  | { type: "browser" }
+  | { type: "privatekey"; resolveKey: () => Promise<string> };
+
+export async function selectWalletMethod(options: WalletOptions): Promise<WalletMethod> {
+  // Check explicit options first
+  if (options.keystore) {
+    return { type: "keystore", path: options.keystore };
+  }
+  if (options.browser) {
+    return { type: "browser" };
+  }
+
+  // Check for PRIVATE_KEY environment variable
+  const envPrivateKey = process.env.PRIVATE_KEY;
+  if (envPrivateKey) {
+    delete process.env.PRIVATE_KEY;
+    console.warn("Warning: Using PRIVATE_KEY from environment variable");
+    return { type: "privatekey", resolveKey: () => Promise.resolve(envPrivateKey) };
+  }
+
+  // Interactive: prompt user to choose
+  const method = await select({
+    message: "Select signing method:",
+    choices: [
+      { name: "Keystore file", value: "keystore" },
+      { name: "Browser wallet (any EIP-6963 compatible wallets)", value: "browser" },
+      { name: "Private key (not recommended)", value: "privatekey" },
+    ],
+  });
+
+  switch (method) {
+    case "keystore": {
+      const keystorePath = await input({
+        message: "Enter keystore path:",
+        default: `${homedir()}/.foundry/keystores/default`,
+      });
+      return { type: "keystore", path: keystorePath };
+    }
+    case "browser":
+      return { type: "browser" };
+    case "privatekey": {
+      const key = await password({
+        message: "Enter private key:",
+        mask: "*",
+      });
+      console.warn("Warning: Using raw private key is not recommended for production");
+      return { type: "privatekey", resolveKey: () => Promise.resolve(key) };
+    }
+    default:
+      throw new Error("No wallet method selected");
+  }
+}
+
+export async function createWalletFromMethod(
+  method: WalletMethod,
+  chain: Chain,
+  rpcUrl?: string,
+): Promise<WalletClient> {
+  switch (method.type) {
+    case "privatekey":
+      return createPrivateKeyWallet(await method.resolveKey(), chain, rpcUrl);
+    case "keystore":
+      return createKeystoreWallet(method.path, chain, rpcUrl);
+    case "browser":
+      throw new Error("Browser wallets should use registerWithBrowser, not createWalletFromMethod");
+  }
+}
+
+export { createPrivateKeyWallet } from "./privatekey";

package/register/wallet/keystore.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, test, mock, beforeAll, afterAll } from "bun:test";
+import { encryptKeystoreJsonSync } from "ethers";
+import { sepolia } from "viem/chains";
+import { mkdirSync, writeFileSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+const TEST_PRIVATE_KEY = "0x0000000000000000000000000000000000000000000000000000000000000001";
+const TEST_ADDRESS = "0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf";
+const TEST_PASSWORD = "testpassword";
+
+const testDir = join(tmpdir(), "aixyz-cli-keystore-test");
+const testKeystorePath = join(testDir, "test-keystore.json");
+
+// Mock the password prompt to return TEST_PASSWORD
+mock.module("@inquirer/prompts", () => ({
+  password: () => Promise.resolve(TEST_PASSWORD),
+}));
+
+// Import after mocking
+const { decryptKeystore, createKeystoreWallet } = await import("./keystore.js");
+
+beforeAll(() => {
+  const json = encryptKeystoreJsonSync({ address: TEST_ADDRESS, privateKey: TEST_PRIVATE_KEY }, TEST_PASSWORD, {
+    scrypt: { N: 2, r: 1, p: 1 },
+  });
+  mkdirSync(testDir, { recursive: true });
+  writeFileSync(testKeystorePath, json);
+});
+
+afterAll(() => {
+  rmSync(testDir, { recursive: true, force: true });
+});
+
+describe("decryptKeystore", () => {
+  test("returns private key from keystore file", async () => {
+    const key = await decryptKeystore(testKeystorePath);
+    expect(key).toBe(TEST_PRIVATE_KEY);
+  });
+
+  test("throws for missing file", async () => {
+    await expect(decryptKeystore("/nonexistent/keystore.json")).rejects.toThrow("Keystore file not found");
+  });
+
+  test("throws for invalid keystore JSON", async () => {
+    const invalidPath = join(testDir, "invalid-keystore.json");
+    writeFileSync(invalidPath, JSON.stringify({ not: "a keystore" }));
+    await expect(decryptKeystore(invalidPath)).rejects.toThrow("Invalid keystore file");
+  });
+});
+
+describe("createKeystoreWallet", () => {
+  test("creates wallet with correct account", async () => {
+    const wallet = await createKeystoreWallet(testKeystorePath, sepolia);
+    expect(wallet.account).toBeDefined();
+    expect(wallet.account?.address).toBe(TEST_ADDRESS);
+  });
+
+  test("creates wallet with chain configured", async () => {
+    const wallet = await createKeystoreWallet(testKeystorePath, sepolia);
+    expect(wallet.chain).toStrictEqual(sepolia);
+  });
+});

package/register/wallet/keystore.ts

@@ -0,0 +1,32 @@
+// ethers is used solely for V3 keystore decryption — viem does not support this.
+import { decryptKeystoreJson, isKeystoreJson } from "ethers";
+import { createWalletClient, http, type Chain, type WalletClient } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { password } from "@inquirer/prompts";
+
+export async function decryptKeystore(keystorePath: string): Promise<`0x${string}`> {
+  const file = Bun.file(keystorePath);
+  if (!(await file.exists())) {
+    throw new Error(`Keystore file not found: ${keystorePath}`);
+  }
+
+  const json = await file.text();
+  if (!isKeystoreJson(json)) {
+    throw new Error(`Invalid keystore file: ${keystorePath}`);
+  }
+  const pass = await password({ message: "Enter keystore password:", mask: "*" });
+  const account = await decryptKeystoreJson(json, pass);
+
+  return account.privateKey as `0x${string}`;
+}
+
+export async function createKeystoreWallet(keystorePath: string, chain: Chain, rpcUrl?: string): Promise<WalletClient> {
+  const privateKey = await decryptKeystore(keystorePath);
+  const account = privateKeyToAccount(privateKey);
+
+  return createWalletClient({
+    account,
+    chain,
+    transport: http(rpcUrl),
+  });
+}

package/register/wallet/privatekey.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, test } from "bun:test";
+import { sepolia } from "viem/chains";
+import { createPrivateKeyWallet } from "./privatekey";
+
+// Valid test private key (do not use in production!)
+const TEST_PRIVATE_KEY = "0x0000000000000000000000000000000000000000000000000000000000000001";
+
+describe("createPrivateKeyWallet", () => {
+  test("creates wallet with correct address", () => {
+    const wallet = createPrivateKeyWallet(TEST_PRIVATE_KEY, sepolia);
+    expect(wallet.account).toBeDefined();
+    // Private key 1 corresponds to this address
+    expect(wallet.account?.address).toStrictEqual("0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf");
+  });
+
+  test("creates wallet with chain configured", () => {
+    const wallet = createPrivateKeyWallet(TEST_PRIVATE_KEY, sepolia);
+    expect(wallet.chain).toStrictEqual(sepolia);
+  });
+
+  test("throws for invalid private key", () => {
+    expect(() => createPrivateKeyWallet("invalid", sepolia)).toThrow("Invalid private key format");
+  });
+
+  test("accepts key without 0x prefix", () => {
+    const keyWithoutPrefix = "0000000000000000000000000000000000000000000000000000000000000001";
+    const wallet = createPrivateKeyWallet(keyWithoutPrefix, sepolia);
+    expect(wallet.account?.address).toStrictEqual("0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf");
+  });
+});

package/register/wallet/privatekey.ts

@@ -0,0 +1,19 @@
+import { createWalletClient, http, type Chain, type WalletClient } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+
+export function createPrivateKeyWallet(privateKey: string, chain: Chain, rpcUrl?: string): WalletClient {
+  const key = (privateKey.startsWith("0x") ? privateKey : `0x${privateKey}`) as `0x${string}`;
+
+  let account;
+  try {
+    account = privateKeyToAccount(key);
+  } catch {
+    throw new Error("Invalid private key format. Expected 64 hex characters (with or without 0x prefix).");
+  }
+
+  return createWalletClient({
+    account,
+    chain,
+    transport: http(rpcUrl),
+  });
+}

package/register/wallet/sign.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, test, mock } from "bun:test";
+import { sepolia } from "viem/chains";
+
+const FAKE_TX_HASH = "0x" + "ab".repeat(32);
+const FAKE_RAW = "0x02deadbeef" as `0x${string}`;
+const FAKE_ADDRESS = "0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf" as `0x${string}`;
+
+mock.module("./browser.js", () => ({
+  signWithBrowser: () => Promise.resolve({ txHash: FAKE_TX_HASH }),
+}));
+
+mock.module("./index.js", () => ({
+  createWalletFromMethod: () =>
+    Promise.resolve({
+      account: { address: FAKE_ADDRESS },
+      prepareTransactionRequest: () => Promise.resolve({ to: "0x1234", data: "0x" }),
+      signTransaction: () => Promise.resolve(FAKE_RAW),
+    }),
+  selectWalletMethod: () => Promise.resolve({ type: "browser" }),
+}));
+
+const { signTransaction } = await import("./sign.js");
+
+const baseTx = {
+  to: "0x1234567890abcdef1234567890abcdef12345678" as `0x${string}`,
+  data: "0xdeadbeef" as `0x${string}`,
+};
+
+describe("signTransaction", () => {
+  test("browser method routes to signViaBrowser and returns sent result", async () => {
+    const result = await signTransaction({
+      walletMethod: { type: "browser" },
+      tx: baseTx,
+      chain: sepolia,
+      options: { browser: { chainId: 11155111, chainName: "sepolia" } },
+    });
+    expect(result.kind).toBe("sent");
+    if (result.kind === "sent") {
+      expect(result.txHash).toBe(FAKE_TX_HASH);
+    }
+  });
+
+  test("browser method throws without browser options", async () => {
+    await expect(
+      signTransaction({
+        walletMethod: { type: "browser" },
+        tx: baseTx,
+        chain: sepolia,
+      }),
+    ).rejects.toThrow("Browser wallet requires chainId and chainName parameters");
+  });
+
+  test("privatekey method routes to wallet client and returns signed result", async () => {
+    const result = await signTransaction({
+      walletMethod: { type: "privatekey", resolveKey: () => Promise.resolve("0x01") },
+      tx: baseTx,
+      chain: sepolia,
+    });
+    expect(result.kind).toBe("signed");
+    if (result.kind === "signed") {
+      expect(result.raw).toBe(FAKE_RAW);
+      expect(result.address).toBe(FAKE_ADDRESS);
+    }
+  });
+
+  test("keystore method routes to wallet client and returns signed result", async () => {
+    const result = await signTransaction({
+      walletMethod: { type: "keystore", path: "/fake/keystore.json" },
+      tx: baseTx,
+      chain: sepolia,
+    });
+    expect(result.kind).toBe("signed");
+    if (result.kind === "signed") {
+      expect(result.raw).toBe(FAKE_RAW);
+      expect(result.address).toBe(FAKE_ADDRESS);
+    }
+  });
+});

package/register/wallet/sign.ts

@@ -0,0 +1,112 @@
+import type { Chain } from "viem";
+import { signWithBrowser } from "./browser";
+import { createWalletFromMethod, type WalletMethod } from "./index";
+
+export interface TxRequest {
+  to: `0x${string}`;
+  data: `0x${string}`;
+  gas?: bigint;
+}
+
+export interface SignOptions {
+  browser?: { chainId: number; chainName: string; uri?: string; mode?: "register" | "update" };
+}
+
+export type SignTransactionResult =
+  | { kind: "signed"; raw: `0x${string}`; address: `0x${string}` }
+  | { kind: "sent"; txHash: `0x${string}` };
+
+export interface SignTransactionParams {
+  walletMethod: WalletMethod;
+  tx: TxRequest;
+  chain: Chain;
+  rpcUrl?: string;
+  options?: SignOptions;
+}
+
+export async function signTransaction({
+  walletMethod,
+  tx,
+  chain,
+  rpcUrl,
+  options,
+}: SignTransactionParams): Promise<SignTransactionResult> {
+  switch (walletMethod.type) {
+    case "browser": {
+      if (!options?.browser) {
+        throw new Error("Browser wallet requires chainId and chainName parameters");
+      }
+      return signViaBrowser({
+        tx,
+        chainId: options.browser.chainId,
+        chainName: options.browser.chainName,
+        uri: options.browser.uri,
+        mode: options.browser.mode,
+      });
+    }
+    default: {
+      const { raw, address } = await signWithWalletClient({ method: walletMethod, tx, chain, rpcUrl });
+      return { kind: "signed", raw, address };
+    }
+  }
+}
+
+async function signViaBrowser({
+  tx,
+  chainId,
+  chainName,
+  uri,
+  mode,
+}: {
+  tx: TxRequest;
+  chainId: number;
+  chainName: string;
+  uri?: string;
+  mode?: "register" | "update";
+}): Promise<SignTransactionResult> {
+  const { txHash } = await signWithBrowser({
+    registryAddress: tx.to,
+    calldata: tx.data,
+    chainId,
+    chainName,
+    uri,
+    gas: tx.gas,
+    mode,
+  });
+
+  if (typeof txHash !== "string" || !/^0x[0-9a-f]{64}$/i.test(txHash)) {
+    throw new Error(`Invalid transaction hash received from browser wallet: ${txHash}`);
+  }
+
+  return { kind: "sent", txHash: txHash as `0x${string}` };
+}
+
+async function signWithWalletClient({
+  method,
+  tx,
+  chain,
+  rpcUrl,
+}: {
+  method: WalletMethod;
+  tx: TxRequest;
+  chain: Chain;
+  rpcUrl?: string;
+}): Promise<{ raw: `0x${string}`; address: `0x${string}` }> {
+  const walletClient = await createWalletFromMethod(method, chain, rpcUrl);
+
+  const account = walletClient.account;
+  if (!account) {
+    throw new Error("Wallet client does not have an account configured");
+  }
+
+  const request = await walletClient.prepareTransactionRequest({
+    to: tx.to,
+    data: tx.data,
+    chain,
+    account,
+    ...(tx.gas ? { gas: tx.gas } : {}),
+  });
+
+  const raw = await walletClient.signTransaction(request);
+  return { raw, address: account.address };
+}