@aixyz/cli 0.8.0 → 0.9.0

package/register/utils/erc8004-file.ts

@@ -0,0 +1,65 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import type { RegistrationEntry } from "@aixyz/erc-8004/schemas/registration";
+
+function getFilePath(cwd: string = process.cwd()): string {
+  return resolve(cwd, "app/erc-8004.ts");
+}
+
+export function hasErc8004File(cwd?: string): boolean {
+  return existsSync(getFilePath(cwd));
+}
+
+export function createErc8004File(supportedTrust: string[], cwd?: string): void {
+  const filePath = getFilePath(cwd);
+  const trustArray = supportedTrust.map((t) => `"${t}"`).join(", ");
+
+  const content = `import type { ERC8004Registration } from "aixyz/erc-8004";
+
+const metadata: ERC8004Registration = {
+  registrations: [],
+  supportedTrust: [${trustArray}],
+};
+
+export default metadata;
+`;
+
+  writeFileSync(filePath, content, "utf-8");
+}
+
+export async function readRegistrations(cwd?: string): Promise<RegistrationEntry[]> {
+  const filePath = getFilePath(cwd);
+
+  if (!existsSync(filePath)) {
+    throw new Error(`No app/erc-8004.ts found. Run \`aixyz erc-8004 register\` first.`);
+  }
+
+  const mod = await import(filePath);
+  const data = mod.default;
+
+  if (!data || !Array.isArray(data.registrations)) {
+    return [];
+  }
+
+  return data.registrations;
+}
+
+export function writeRegistrationEntry(entry: { agentId: number; agentRegistry: string }, cwd?: string): void {
+  const filePath = getFilePath(cwd);
+  const content = readFileSync(filePath, "utf-8");
+  const entryStr = `{ agentId: ${entry.agentId}, agentRegistry: "${entry.agentRegistry}" }`;
+
+  // Try to find `registrations: [...]` and insert the entry
+  const match = content.match(/registrations:\s*\[([^\]]*)\]/s);
+  if (match) {
+    const existing = match[1]!.trim();
+    const newEntries = existing ? `${existing}, ${entryStr}` : entryStr;
+    const updated = content.replace(/registrations:\s*\[([^\]]*)\]/s, `registrations: [${newEntries}]`);
+    writeFileSync(filePath, updated, "utf-8");
+    return;
+  }
+
+  // Fallback: append as comment
+  const comment = `\n// Registration added by \`aixyz erc-8004 register\`:\n// ${entryStr}\n`;
+  writeFileSync(filePath, content + comment, "utf-8");
+}

package/register/utils/prompt.ts

@@ -1,4 +1,5 @@
-import { input } from "@inquirer/prompts";
+import { checkbox, confirm, input, select } from "@inquirer/prompts";
+import type { RegistrationEntry } from "@aixyz/erc-8004/schemas/registration";
 
 export async function promptAgentId(): Promise<string> {
   return input({
@@ -16,3 +17,62 @@ export async function promptUri(): Promise<string> {
     message: "New agent metadata URI or path to .json file (leave empty to clear):",
   });
 }
+
+export async function promptAgentUrl(): Promise<string> {
+  return input({
+    message: "Agent deployment URL (e.g., https://my-agent.example.com):",
+    validate: (value) => {
+      try {
+        const url = new URL(value);
+        if (url.protocol !== "https:" && url.protocol !== "http:") {
+          return "URL must start with https:// or http://";
+        }
+        return true;
+      } catch {
+        return "Must be a valid URL (e.g., https://my-agent.example.com)";
+      }
+    },
+  });
+}
+
+export async function promptSupportedTrust(): Promise<string[]> {
+  return checkbox({
+    message: "Select supported trust mechanisms:",
+    choices: [
+      { name: "reputation", value: "reputation", checked: true },
+      { name: "crypto-economic", value: "crypto-economic" },
+      { name: "tee-attestation", value: "tee-attestation" },
+      { name: "social", value: "social" },
+      { name: "governance", value: "governance" },
+    ],
+    required: true,
+  });
+}
+
+export async function promptSelectRegistration(registrations: RegistrationEntry[]): Promise<RegistrationEntry> {
+  if (registrations.length === 1) {
+    const reg = registrations[0]!;
+    const yes = await confirm({
+      message: `Update this registration? (agentId: ${reg.agentId}, registry: ${reg.agentRegistry})`,
+      default: true,
+    });
+    if (!yes) {
+      throw new Error("Aborted.");
+    }
+    return reg;
+  }
+
+  return select({
+    message: "Select registration to update:",
+    choices: registrations.map((reg) => ({
+      name: `agentId: ${reg.agentId} — ${reg.agentRegistry}`,
+      value: reg,
+    })),
+  });
+}
+
+export function deriveAgentUri(url: string): string {
+  // Ensure no trailing slash before appending path
+  const base = url.replace(/\/+$/, "");
+  return `${base}/_aixyz/erc-8004.json`;
+}

package/register/utils.test.ts

@@ -1,82 +1,9 @@
 import { describe, expect, test, afterAll, beforeAll } from "bun:test";
 import { rmSync } from "fs";
 import { mkdir } from "node:fs/promises";
-import { validatePrivateKey, CliError, resolveUri } from "./utils";
+import { resolveUri } from "./utils";
 import { join } from "path";
 
-describe("validatePrivateKey", () => {
-  test("accepts valid 64-char hex key with 0x prefix", () => {
-    const key = "0x0000000000000000000000000000000000000000000000000000000000000001";
-    const result = validatePrivateKey(key);
-    expect(result).toStrictEqual(key);
-  });
-
-  test("accepts valid 64-char hex key without 0x prefix", () => {
-    const key = "0000000000000000000000000000000000000000000000000000000000000001";
-    const result = validatePrivateKey(key);
-    expect(result).toStrictEqual(`0x${key}`);
-  });
-
-  test("accepts mixed case hex characters", () => {
-    const key = "0xaAbBcCdDeEfF0000000000000000000000000000000000000000000000000001";
-    const result = validatePrivateKey(key);
-    expect(result).toStrictEqual(key);
-  });
-
-  test("rejects key that is too short", () => {
-    const key = "0x1234";
-    expect(() => validatePrivateKey(key)).toThrow(CliError);
-    expect(() => validatePrivateKey(key)).toThrow("Invalid private key format");
-  });
-
-  test("rejects key that is too long", () => {
-    const key = "0x00000000000000000000000000000000000000000000000000000000000000001";
-    expect(() => validatePrivateKey(key)).toThrow(CliError);
-  });
-
-  test("rejects key with invalid characters", () => {
-    const key = "0xGGGG000000000000000000000000000000000000000000000000000000000001";
-    expect(() => validatePrivateKey(key)).toThrow(CliError);
-  });
-
-  test("rejects empty string", () => {
-    expect(() => validatePrivateKey("")).toThrow(CliError);
-  });
-
-  test("rejects random string", () => {
-    expect(() => validatePrivateKey("not-a-key")).toThrow(CliError);
-  });
-});
-
-describe("CliError", () => {
-  test("is an instance of Error", () => {
-    const error = new CliError("test message");
-    expect(error).toBeInstanceOf(Error);
-  });
-
-  test("has correct name property", () => {
-    const error = new CliError("test message");
-    expect(error.name).toStrictEqual("CliError");
-  });
-
-  test("has correct message property", () => {
-    const error = new CliError("test message");
-    expect(error.message).toStrictEqual("test message");
-  });
-
-  test("can be caught as Error", () => {
-    let caught = false;
-    try {
-      throw new CliError("test");
-    } catch (e) {
-      if (e instanceof Error) {
-        caught = true;
-      }
-    }
-    expect(caught).toStrictEqual(true);
-  });
-});
-
 describe("resolveUri", () => {
   const testDir = join(import.meta.dir, "__test_fixtures__");
   const testJsonPath = join(testDir, "test-metadata.json");
@@ -129,7 +56,7 @@ describe("resolveUri", () => {
     await mkdir(dirWithJsonSuffix, { recursive: true });
 
     try {
-      expect(() => resolveUri(dirWithJsonSuffix)).toThrow(CliError);
+      expect(() => resolveUri(dirWithJsonSuffix)).toThrow(Error);
       expect(() => resolveUri(dirWithJsonSuffix)).toThrow("Not a file");
     } finally {
       rmSync(dirWithJsonSuffix, { recursive: true, force: true });
@@ -137,7 +64,7 @@ describe("resolveUri", () => {
   });
 
   test("throws for non-existent .json file", () => {
-    expect(() => resolveUri("./non-existent.json")).toThrow(CliError);
+    expect(() => resolveUri("./non-existent.json")).toThrow(Error);
     expect(() => resolveUri("./non-existent.json")).toThrow("File not found");
   });
 
@@ -145,7 +72,7 @@ describe("resolveUri", () => {
     await Bun.write(testJsonPath, "not valid json {{{");
 
     try {
-      expect(() => resolveUri(testJsonPath)).toThrow(CliError);
+      expect(() => resolveUri(testJsonPath)).toThrow(Error);
       expect(() => resolveUri(testJsonPath)).toThrow("Invalid JSON");
     } finally {
       await Bun.file(testJsonPath).unlink();

package/register/utils.ts

@@ -12,11 +12,11 @@ export function resolveUri(uri: string): string {
     const filePath = resolve(uri);
 
     if (!existsSync(filePath)) {
-      throw new CliError(`File not found: ${filePath}`);
+      throw new Error(`File not found: ${filePath}`);
     }
 
     if (!statSync(filePath).isFile()) {
-      throw new CliError(`Not a file: ${filePath}`);
+      throw new Error(`Not a file: ${filePath}`);
     }
 
     const content = readFileSync(filePath, "utf-8");
@@ -25,7 +25,7 @@ export function resolveUri(uri: string): string {
     try {
       JSON.parse(content);
     } catch {
-      throw new CliError(`Invalid JSON in file: ${filePath}`);
+      throw new Error(`Invalid JSON in file: ${filePath}`);
     }
 
     // Convert to base64 data URI
@@ -36,20 +36,3 @@ export function resolveUri(uri: string): string {
   // Return as-is for other URIs
   return uri;
 }
-
-export function validatePrivateKey(key: string): `0x${string}` {
-  const normalizedKey = key.startsWith("0x") ? key : `0x${key}`;
-
-  if (!/^0x[0-9a-fA-F]{64}$/.test(normalizedKey)) {
-    throw new CliError("Invalid private key format. Expected 64 hex characters (with or without 0x prefix).");
-  }
-
-  return normalizedKey as `0x${string}`;
-}
-
-export class CliError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "CliError";
-  }
-}

package/register/wallet/browser.test.ts

@@ -103,4 +103,22 @@ describe("buildHtml", () => {
     expect(html).not.toContain('<script>alert("xss")</script>');
     expect(html).toContain("&lt;script&gt;");
   });
+
+  test("shows 'Register Agent' by default (no mode)", () => {
+    const html = buildHtml(baseParams);
+    expect(html).toContain("Register Agent");
+    expect(html).not.toContain("Update Agent");
+  });
+
+  test("shows 'Register Agent' when mode is 'register'", () => {
+    const html = buildHtml({ ...baseParams, mode: "register" });
+    expect(html).toContain("Register Agent");
+    expect(html).not.toContain("Update Agent");
+  });
+
+  test("shows 'Update Agent' when mode is 'update'", () => {
+    const html = buildHtml({ ...baseParams, mode: "update" });
+    expect(html).toContain("Update Agent");
+    expect(html).not.toContain("Register Agent");
+  });
 });

package/register/wallet/browser.ts

@@ -7,15 +7,16 @@ export interface BrowserSignParams {
   chainName: string;
   uri?: string;
   gas?: bigint;
+  mode?: "register" | "update";
 }
 
 const TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
 
 export async function signWithBrowser(params: BrowserSignParams): Promise<{ txHash: string }> {
-  const { registryAddress, calldata, chainId, chainName, uri, gas } = params;
+  const { registryAddress, calldata, chainId, chainName, uri, gas, mode } = params;
 
   const nonce = crypto.randomUUID();
-  const html = buildHtml({ registryAddress, calldata, chainId, chainName, uri, gas, nonce });
+  const html = buildHtml({ registryAddress, calldata, chainId, chainName, uri, gas, nonce, mode });
 
   const { promise: resultPromise, resolve, reject } = Promise.withResolvers<{ txHash: string }>();
   let settled = false;
@@ -134,8 +135,11 @@ export function buildHtml(params: {
   uri?: string;
   gas?: bigint;
   nonce: string;
+  mode?: "register" | "update";
 }): string {
-  const { registryAddress, calldata, chainId, chainName, uri, gas, nonce } = params;
+  const { registryAddress, calldata, chainId, chainName, uri, gas, nonce, mode } = params;
+  const isUpdate = mode === "update";
+  const actionLabel = isUpdate ? "Update Agent" : "Register Agent";
   const chainIdHex = `0x${chainId.toString(16)}`;
 
   const displayUri = uri && uri.length > 80 ? uri.slice(0, 80) + "..." : (uri ?? "");
@@ -145,7 +149,7 @@ export function buildHtml(params: {
 <head>
 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>agently-cli – Register Agent</title>
+<title>aixyz.sh – ERC-8004 ${actionLabel}</title>
 <link rel="preconnect" href="https://fonts.googleapis.com">
 <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
 <link href="https://fonts.googleapis.com/css2?family=DM+Mono:wght@300;400;500&family=DM+Sans:wght@400;500;600&display=swap" rel="stylesheet">
@@ -475,8 +479,8 @@ export function buildHtml(params: {
 <body>
 <div class="container">
   <div class="header">
-    <div class="brand">agently-cli</div>
-    <h1>Register Agent</h1>
+    <div class="brand">aixyz erc-8004</div>
+    <h1>${actionLabel}</h1>
   </div>
 
   <div class="details" id="details">
@@ -513,7 +517,7 @@ export function buildHtml(params: {
     <div id="walletList"></div>
   </div>
 
-  <button id="registerBtn" disabled>Register Agent</button>
+  <button id="registerBtn" disabled>${actionLabel}</button>
 
   <div class="status" id="status"></div>
 </div>
@@ -524,6 +528,7 @@ export function buildHtml(params: {
   const CHAIN_ID_HEX = ${safeJsonEmbed(chainIdHex)};
   const CHAIN_ID = ${chainId};
   const GAS = ${gas ? safeJsonEmbed(`0x${gas.toString(16)}`) : "undefined"};
+  const ACTION_LABEL = ${safeJsonEmbed(actionLabel)};
 
   const registerBtn = document.getElementById("registerBtn");
   const statusEl = document.getElementById("status");
@@ -543,7 +548,7 @@ export function buildHtml(params: {
     walletInfo.style.display = "none";
     registerBtn.style.display = "none";
     registerBtn.disabled = true;
-    registerBtn.textContent = "Register Agent";
+    registerBtn.textContent = ACTION_LABEL;
     walletSectionEl.style.display = "";
     statusEl.className = "status";
     if (discoveredWallets.size > 0) {
@@ -663,7 +668,7 @@ export function buildHtml(params: {
       walletSectionEl.style.display = "none";
       registerBtn.style.display = "block";
       registerBtn.disabled = false;
-      setStatus("Wallet connected. Ready to register.", "success");
+      setStatus("Wallet connected. Ready to ${isUpdate ? "update" : "register"}.", "success");
 
       // Listen for account/chain changes on the selected provider
       if (selectedProvider.on) {
@@ -739,7 +744,7 @@ export function buildHtml(params: {
         setStatus("Failed: " + err.message + " — You can try again.", "error");
       }
       registerBtn.disabled = false;
-      registerBtn.textContent = "Register Agent";
+      registerBtn.textContent = ACTION_LABEL;
     }
   });
 </script>

package/register/wallet/index.ts

@@ -3,7 +3,6 @@ import type { Chain, WalletClient } from "viem";
 import { select, input, password } from "@inquirer/prompts";
 import { createPrivateKeyWallet } from "./privatekey";
 import { createKeystoreWallet } from "./keystore";
-import { CliError } from "../utils";
 
 export interface WalletOptions {
   keystore?: string;
@@ -62,7 +61,7 @@ export async function selectWalletMethod(options: WalletOptions): Promise<Wallet
       return { type: "privatekey", resolveKey: () => Promise.resolve(key) };
     }
     default:
-      throw new CliError("No wallet method selected");
+      throw new Error("No wallet method selected");
   }
 }
 
@@ -77,7 +76,7 @@ export async function createWalletFromMethod(
     case "keystore":
       return createKeystoreWallet(method.path, chain, rpcUrl);
     case "browser":
-      throw new CliError("Browser wallets should use registerWithBrowser, not createWalletFromMethod");
+      throw new Error("Browser wallets should use registerWithBrowser, not createWalletFromMethod");
   }
 }
 

package/register/wallet/keystore.test.ts

@@ -9,7 +9,7 @@ const TEST_PRIVATE_KEY = "0x0000000000000000000000000000000000000000000000000000
 const TEST_ADDRESS = "0x7E5F4552091A69125d5DfCb7b8C2659029395Bdf";
 const TEST_PASSWORD = "testpassword";
 
-const testDir = join(tmpdir(), "agently-cli-keystore-test");
+const testDir = join(tmpdir(), "aixyz-cli-keystore-test");
 const testKeystorePath = join(testDir, "test-keystore.json");
 
 // Mock the password prompt to return TEST_PASSWORD

package/register/wallet/keystore.ts

@@ -3,17 +3,16 @@ import { decryptKeystoreJson, isKeystoreJson } from "ethers";
 import { createWalletClient, http, type Chain, type WalletClient } from "viem";
 import { privateKeyToAccount } from "viem/accounts";
 import { password } from "@inquirer/prompts";
-import { CliError } from "../utils";
 
 export async function decryptKeystore(keystorePath: string): Promise<`0x${string}`> {
   const file = Bun.file(keystorePath);
   if (!(await file.exists())) {
-    throw new CliError(`Keystore file not found: ${keystorePath}`);
+    throw new Error(`Keystore file not found: ${keystorePath}`);
   }
 
   const json = await file.text();
   if (!isKeystoreJson(json)) {
-    throw new CliError(`Invalid keystore file: ${keystorePath}`);
+    throw new Error(`Invalid keystore file: ${keystorePath}`);
   }
   const pass = await password({ message: "Enter keystore password:", mask: "*" });
   const account = await decryptKeystoreJson(json, pass);

package/register/wallet/privatekey.ts

@@ -1,10 +1,15 @@
 import { createWalletClient, http, type Chain, type WalletClient } from "viem";
 import { privateKeyToAccount } from "viem/accounts";
-import { validatePrivateKey } from "../utils";
 
 export function createPrivateKeyWallet(privateKey: string, chain: Chain, rpcUrl?: string): WalletClient {
-  const key = validatePrivateKey(privateKey);
-  const account = privateKeyToAccount(key);
+  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,

package/register/wallet/sign.ts

@@ -1,7 +1,6 @@
 import type { Chain } from "viem";
 import { signWithBrowser } from "./browser";
 import { createWalletFromMethod, type WalletMethod } from "./index";
-import { CliError } from "../utils";
 
 export interface TxRequest {
   to: `0x${string}`;
@@ -10,7 +9,7 @@ export interface TxRequest {
 }
 
 export interface SignOptions {
-  browser?: { chainId: number; chainName: string; uri?: string };
+  browser?: { chainId: number; chainName: string; uri?: string; mode?: "register" | "update" };
 }
 
 export type SignTransactionResult =
@@ -35,13 +34,14 @@ export async function signTransaction({
   switch (walletMethod.type) {
     case "browser": {
       if (!options?.browser) {
-        throw new CliError("Browser wallet requires chainId and chainName parameters");
+        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: {
@@ -56,11 +56,13 @@ async function signViaBrowser({
   chainId,
   chainName,
   uri,
+  mode,
 }: {
   tx: TxRequest;
   chainId: number;
   chainName: string;
   uri?: string;
+  mode?: "register" | "update";
 }): Promise<SignTransactionResult> {
   const { txHash } = await signWithBrowser({
     registryAddress: tx.to,
@@ -69,10 +71,11 @@ async function signViaBrowser({
     chainName,
     uri,
     gas: tx.gas,
+    mode,
   });
 
   if (typeof txHash !== "string" || !/^0x[0-9a-f]{64}$/i.test(txHash)) {
-    throw new CliError(`Invalid transaction hash received from browser wallet: ${txHash}`);
+    throw new Error(`Invalid transaction hash received from browser wallet: ${txHash}`);
   }
 
   return { kind: "sent", txHash: txHash as `0x${string}` };
@@ -93,7 +96,7 @@ async function signWithWalletClient({
 
   const account = walletClient.account;
   if (!account) {
-    throw new CliError("Wallet client does not have an account configured");
+    throw new Error("Wallet client does not have an account configured");
   }
 
   const request = await walletClient.prepareTransactionRequest({

package/register/README.md

@@ -1,101 +0,0 @@
-# ERC-8004 Registry Commands
-
-CLI commands for registering agents to the [ERC-8004](https://eips.ethereum.org/EIPS/eip-8004) IdentityRegistry.
-
-These commands are part of the `aixyz` CLI under the `erc8004` subcommand.
-
-## Usage
-
-### Register an Agent
-
-Register a new agent to the IdentityRegistry with multiple wallet options:
-
-#### Using Keystore (Recommended)
-
-Sign with an Ethereum keystore (V3) JSON file:
-
-```bash
-aixyz erc8004 register --uri "./metadata.json" --chain sepolia --keystore ~/.foundry/keystores/default --broadcast
-```
-
-#### Using Browser Wallet
-
-Opens a localhost page to sign with any browser extension wallet (MetaMask, Rabby, etc.) that are `EIP-6963` compliant:
-
-```bash
-aixyz erc8004 register --uri "ipfs://Qm..." --chain sepolia --browser --broadcast
-```
-
-> **Note:** `--rpc-url` cannot be used with `--browser`. The browser wallet uses its own RPC endpoint.
-
-#### Using Private Key Env (Not Recommended)
-
-For scripting and CI:
-
-```bash
-# Not recommended for interactive use
-PRIVATE_KEY=0x... aixyz erc8004 register --uri "ipfs://Qm..." --chain sepolia --broadcast
-```
-
-#### Interactive Mode
-
-If no wallet option is provided, you'll be prompted to choose:
-
-```bash
-aixyz erc8004 register --uri "ipfs://Qm..." --chain sepolia --broadcast
-```
-
-#### Local Development
-
-Register against a local Foundry/Anvil node:
-
-```bash
-aixyz erc8004 register \
-  --chain localhost \
-  --registry 0x5FbDB2315678afecb367f032d93F642f64180aa3 \
-  --rpc-url http://localhost:8545 \
-  --uri "./metadata.json" \
-  --keystore ~/.foundry/keystores/default \
-  --broadcast
-```
-
-### Set Agent URI
-
-Update the metadata URI of a registered agent:
-
-```bash
-aixyz erc8004 set-agent-uri \
-  --agent-id 1 \
-  --uri "https://my-agent.vercel.app/.well-known/agent-card.json" \
-  --chain sepolia \
-  --keystore ~/.foundry/keystores/default \
-  --broadcast
-```
-
-### Options
-
-| Option                 | Description                                                                          |
-| ---------------------- | ------------------------------------------------------------------------------------ |
-| `--uri <uri>`          | Agent metadata URI or path to `.json` file (converts to base64 data URI)             |
-| `--chain <chain>`      | Target chain: `mainnet`, `sepolia`, `base-sepolia`, `localhost` (default: `sepolia`) |
-| `--rpc-url <url>`      | Custom RPC URL (cannot be used with `--browser`)                                     |
-| `--registry <address>` | IdentityRegistry contract address (required for `localhost`)                         |
-| `--keystore <path>`    | Path to Ethereum keystore (V3) JSON file                                             |
-| `--browser`            | Use browser extension wallet                                                         |
-| `--broadcast`          | Sign and broadcast the transaction (default: dry-run)                                |
-| `--out-dir <path>`     | Write deployment result as JSON to the given directory                               |
-
-### Environment Variables
-
-| Variable      | Description                           |
-| ------------- | ------------------------------------- |
-| `PRIVATE_KEY` | Private key for signing (use caution) |
-
-### Supported Chains
-
-| Chain          | Chain ID | Network                  |
-| -------------- | -------- | ------------------------ |
-| `mainnet`      | 1        | Ethereum mainnet         |
-| `sepolia`      | 11155111 | Ethereum Sepolia testnet |
-| `base-sepolia` | 84532    | Base Sepolia testnet     |
-| `localhost`    | 31337    | Local Foundry/Anvil node |