@aixyz/cli 0.8.0 → 0.10.0

package/register/update.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, test } from "bun:test";
+import { CHAIN_ID, getIdentityRegistryAddress } from "@aixyz/erc-8004";
+import { deriveAgentUri } from "./utils/prompt";
+
+describe("update command chain configuration", () => {
+  test("sepolia chain ID is correct", () => {
+    expect(CHAIN_ID.SEPOLIA).toStrictEqual(11155111);
+  });
+
+  test("base-sepolia chain ID is correct", () => {
+    expect(CHAIN_ID.BASE_SEPOLIA).toStrictEqual(84532);
+  });
+
+  test("identity registry address is returned for sepolia", () => {
+    const address = getIdentityRegistryAddress(CHAIN_ID.SEPOLIA);
+    expect(address).toMatch(/^0x[a-fA-F0-9]{40}$/);
+  });
+
+  test("identity registry address is returned for base-sepolia", () => {
+    const address = getIdentityRegistryAddress(CHAIN_ID.BASE_SEPOLIA);
+    expect(address).toMatch(/^0x[a-fA-F0-9]{40}$/);
+  });
+
+  test("throws for unsupported chain ID", () => {
+    expect(() => getIdentityRegistryAddress(999999)).toThrow("Unsupported chain ID");
+  });
+});
+
+describe("deriveAgentUri", () => {
+  test("appends /_aixyz/erc-8004.json to base URL", () => {
+    expect(deriveAgentUri("https://my-agent.example.com")).toBe("https://my-agent.example.com/_aixyz/erc-8004.json");
+  });
+
+  test("strips trailing slash before appending", () => {
+    expect(deriveAgentUri("https://my-agent.example.com/")).toBe("https://my-agent.example.com/_aixyz/erc-8004.json");
+  });
+
+  test("strips multiple trailing slashes", () => {
+    expect(deriveAgentUri("https://my-agent.example.com///")).toBe("https://my-agent.example.com/_aixyz/erc-8004.json");
+  });
+
+  test("preserves path segments", () => {
+    expect(deriveAgentUri("https://example.com/agents/my-agent")).toBe(
+      "https://example.com/agents/my-agent/_aixyz/erc-8004.json",
+    );
+  });
+});

package/register/{set-agent-uri.ts → update.ts}

@@ -2,66 +2,59 @@ import { encodeFunctionData, formatEther, parseEventLogs, type Chain, type Log }
 import { IdentityRegistryAbi } from "@aixyz/erc-8004";
 import { selectWalletMethod } from "./wallet";
 import { signTransaction } from "./wallet/sign";
-import { CliError, resolveUri } from "./utils";
-import {
-  resolveChainConfig,
-  selectChain,
-  resolveRegistryAddress,
-  validateBrowserRpcConflict,
-  getExplorerUrl,
-} from "./utils/chain";
+import { resolveChainConfig, validateBrowserRpcConflict, getExplorerUrl, CHAINS } from "./utils/chain";
 import { writeResultJson } from "./utils/result";
 import { label, truncateUri, broadcastAndConfirm, logSignResult } from "./utils/transaction";
-import { confirm, input } from "@inquirer/prompts";
+import { promptAgentUrl, promptSelectRegistration, deriveAgentUri } from "./utils/prompt";
+import { readRegistrations } from "./utils/erc8004-file";
+import { confirm } from "@inquirer/prompts";
 import chalk from "chalk";
 import boxen from "boxen";
 import type { BaseOptions } from "./index";
-import { promptAgentId, promptUri } from "./utils/prompt";
 
-export interface SetAgentUriOptions extends BaseOptions {
-  agentId?: string;
-  uri?: string;
+export interface UpdateOptions extends BaseOptions {
+  url?: string;
 }
 
-async function confirmEmptyUri(): Promise<void> {
-  const yes = await confirm({
-    message: "URI is empty. This will clear the agent's metadata URI. Are you sure?",
-    default: false,
-  });
-  if (!yes) {
-    throw new CliError("Aborted.");
+export async function update(options: UpdateOptions): Promise<void> {
+  // Step 1: Read registrations from app/erc-8004.ts
+  const registrations = await readRegistrations();
+
+  if (registrations.length === 0) {
+    throw new Error("No registrations found in app/erc-8004.ts. Run `aixyz erc-8004 register` first.");
   }
-}
 
-export function validateAgentId(agentId: string): void {
-  const n = Number(agentId);
-  if (agentId.trim() === "" || !Number.isInteger(n) || n < 0) {
-    throw new CliError(`Invalid agent ID: ${agentId}. Must be a non-negative integer.`);
+  // Step 2: Select which registration to update
+  const selected = await promptSelectRegistration(registrations);
+
+  // Step 3: Derive chain info from agentRegistry (eip155:<chainId>:<address>)
+  const parts = selected.agentRegistry.split(":");
+  if (parts.length < 3 || parts[0] !== "eip155") {
+    throw new Error(`Invalid agentRegistry format: ${selected.agentRegistry}. Expected eip155:<chainId>:<address>`);
   }
-}
 
-export async function setAgentUri(options: SetAgentUriOptions): Promise<void> {
-  const chainName = options.chain ?? (await selectChain());
+  const chainId = Number(parts[1]);
+  const registryAddress = parts.slice(2).join(":") as `0x${string}`;
+  const chainName = Object.entries(CHAINS).find(([, config]) => config.chainId === chainId)?.[0] ?? `chain-${chainId}`;
   const chainConfig = resolveChainConfig(chainName);
 
-  const agentId = options.agentId ?? (await promptAgentId());
-  validateAgentId(agentId);
+  // Step 4: Get new agent URL and derive URI
+  const agentUrl = options.url ?? (await promptAgentUrl());
+  const resolvedUri = deriveAgentUri(agentUrl);
 
-  const uri = options.uri ?? (await promptUri());
-  if (uri === "") {
-    await confirmEmptyUri();
-  }
-  const resolvedUri = uri === "" ? "" : resolveUri(uri);
-  if (resolvedUri !== uri) {
-    console.log(`Resolved ${uri} to data URI (${resolvedUri.length} chars)`);
+  const yes = await confirm({
+    message: `Will update URI to: ${chalk.cyan(resolvedUri)} — confirm?`,
+    default: true,
+  });
+  if (!yes) {
+    throw new Error("Aborted.");
   }
 
-  const registryAddress = resolveRegistryAddress(chainName, chainConfig.chainId, options.registry);
-
+  // Step 5: Encode transaction
   const data = encodeFunctionData({
     abi: IdentityRegistryAbi,
     functionName: "setAgentURI",
-    args: [BigInt(agentId), resolvedUri],
+    args: [BigInt(selected.agentId), resolvedUri],
   });
 
   const printTxDetails = (header: string) => {
@@ -71,7 +64,7 @@ export async function setAgentUri(options: SetAgentUriOptions): Promise<void> {
     console.log(`  ${label("Data")}${data.slice(0, 10)}${chalk.dim("\u2026" + (data.length - 2) / 2 + " bytes")}`);
     console.log(`  ${label("Chain")}${chainName}`);
     console.log(`  ${label("Function")}setAgentURI(uint256 agentId, string calldata newURI)`);
-    console.log(`  ${label("Agent ID")}${agentId}`);
+    console.log(`  ${label("Agent ID")}${selected.agentId}`);
     console.log(`  ${label("URI")}${truncateUri(resolvedUri)}`);
     console.log("");
   };
@@ -98,7 +91,7 @@ export async function setAgentUri(options: SetAgentUriOptions): Promise<void> {
     chain: chainConfig.chain,
     rpcUrl: options.rpcUrl,
     options: {
-      browser: { chainId: chainConfig.chainId, chainName, uri: resolvedUri },
+      browser: { chainId: chainConfig.chainId, chainName, uri: resolvedUri, mode: "update" },
     },
   });
   logSignResult(walletMethod.type, result);
@@ -112,11 +105,11 @@ export async function setAgentUri(options: SetAgentUriOptions): Promise<void> {
   const resultData = printResult(receipt, timestamp, chainConfig.chain, chainConfig.chainId, hash);
 
   if (options.outDir) {
-    writeResultJson(options.outDir, "set-agent-uri", resultData);
+    writeResultJson(options.outDir, "update", resultData);
   }
 }
 
-interface SetAgentUriResult {
+interface UpdateResult {
   agentId?: string;
   newUri?: string;
   updatedBy?: `0x${string}`;
@@ -135,12 +128,12 @@ function printResult(
   chain: Chain,
   chainId: number,
   hash: `0x${string}`,
-): SetAgentUriResult {
+): UpdateResult {
   const events = parseEventLogs({ abi: IdentityRegistryAbi, logs: receipt.logs as Log[] });
   const uriUpdated = events.find((e) => e.eventName === "URIUpdated");
 
   const lines: string[] = [];
-  const result: SetAgentUriResult = {
+  const result: UpdateResult = {
     chainId,
     block: receipt.blockNumber.toString(),
     timestamp: new Date(Number(timestamp) * 1000).toUTCString(),

package/register/utils/chain.ts

@@ -2,7 +2,6 @@ import { isAddress, type Chain } from "viem";
 import { mainnet, sepolia, baseSepolia, foundry } from "viem/chains";
 import { CHAIN_ID, getIdentityRegistryAddress } from "@aixyz/erc-8004";
 import { select } from "@inquirer/prompts";
-import { CliError } from "../utils";
 
 export interface ChainConfig {
   chain: Chain;
@@ -19,7 +18,7 @@ export const CHAINS: Record<string, ChainConfig> = {
 export function resolveChainConfig(chainName: string): ChainConfig {
   const config = CHAINS[chainName];
   if (!config) {
-    throw new CliError(`Unsupported chain: ${chainName}. Supported chains: ${Object.keys(CHAINS).join(", ")}`);
+    throw new Error(`Unsupported chain: ${chainName}. Supported chains: ${Object.keys(CHAINS).join(", ")}`);
   }
   return config;
 }
@@ -34,19 +33,19 @@ export async function selectChain(): Promise<string> {
 export function resolveRegistryAddress(chainName: string, chainId: number, registry?: string): `0x${string}` {
   if (registry) {
     if (!isAddress(registry)) {
-      throw new CliError(`Invalid registry address: ${registry}`);
+      throw new Error(`Invalid registry address: ${registry}`);
     }
     return registry as `0x${string}`;
   }
   if (chainName === "localhost") {
-    throw new CliError("--registry is required for localhost (no default contract deployment)");
+    throw new Error("--registry is required for localhost (no default contract deployment)");
   }
   return getIdentityRegistryAddress(chainId) as `0x${string}`;
 }
 
 export function validateBrowserRpcConflict(browser: boolean | undefined, rpcUrl: string | undefined): void {
   if (browser && rpcUrl) {
-    throw new CliError("--rpc-url cannot be used with browser wallet. The browser wallet uses its own RPC endpoint.");
+    throw new Error("--rpc-url cannot be used with browser wallet. The browser wallet uses its own RPC endpoint.");
   }
 }
 

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,18 +1,61 @@
-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> {
+export async function promptAgentUrl(): Promise<string> {
   return input({
-    message: "Agent ID (token ID) to update:",
+    message: "Agent deployment URL (e.g., https://my-agent.example.com):",
     validate: (value) => {
-      const n = Number(value);
-      if (value.trim() === "" || !Number.isInteger(n) || n < 0) return "Must be a non-negative integer";
-      return true;
+      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 promptUri(): Promise<string> {
-  return input({
-    message: "New agent metadata URI or path to .json file (leave empty to clear):",
+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/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({