@macwlt/cli 0.0.1-alpha

package/dist/index.js

@@ -0,0 +1,2520 @@
+#!/usr/bin/env bun
+
+// src/result.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+
+// src/base64.ts
+function bytesToBase64(bytes) {
+  return Buffer.from(bytes).toString("base64");
+}
+function base64ToBytes(input) {
+  if (input.length === 0) return err({ kind: "empty" });
+  const normalized = input.trim();
+  if (normalized.length === 0) return err({ kind: "empty" });
+  const decoded = Buffer.from(normalized, "base64");
+  if (decoded.length === 0 || Buffer.from(decoded).toString("base64").replace(/=+$/, "") !== normalized.replace(/=+$/, "")) {
+    return err({ kind: "invalid", value: input });
+  }
+  return ok(new Uint8Array(decoded));
+}
+
+// src/command.ts
+import { z as z8 } from "zod";
+
+// src/config/GlobalConfig.ts
+import { homedir } from "os";
+
+// src/config/fileConfigStorage.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname } from "path";
+var fileConfigStorage = {
+  async read(path) {
+    try {
+      return await readFile(path, "utf8");
+    } catch (caught) {
+      if (isNotFoundError(caught)) return void 0;
+      throw caught;
+    }
+  },
+  async write(path, contents2) {
+    await mkdir(dirname(path), { recursive: true, mode: 448 });
+    await writeFile(path, contents2, { encoding: "utf8", mode: 384 });
+  }
+};
+function isNotFoundError(caught) {
+  return caught instanceof Error && "code" in caught && caught.code === "ENOENT";
+}
+
+// src/config/parseGlobalConfigData.ts
+import { z as z2 } from "zod";
+
+// src/config/parseJsonValue.ts
+import { z } from "zod";
+var jsonValueSchema = z.lazy(
+  () => z.union([
+    z.null(),
+    z.boolean(),
+    z.number().finite(),
+    z.string(),
+    z.array(jsonValueSchema),
+    z.record(jsonValueSchema)
+  ])
+);
+function parseJsonValue(input) {
+  const parsed = jsonValueSchema.safeParse(input);
+  if (!parsed.success) {
+    return err({
+      kind: "invalid-config",
+      message: parsed.error.issues.map((issue) => `${issue.path.join(".") || "value"}: ${issue.message}`).join("; ")
+    });
+  }
+  return ok(parsed.data);
+}
+
+// src/config/parseGlobalConfigData.ts
+var globalConfigDataSchema = z2.record(z2.unknown());
+function parseGlobalConfigData(input) {
+  const parsed = globalConfigDataSchema.safeParse(input);
+  if (!parsed.success) {
+    return err({
+      kind: "invalid-config",
+      message: parsed.error.issues.map((issue) => `${issue.path.join(".") || "config"}: ${issue.message}`).join("; ")
+    });
+  }
+  const data = {};
+  for (const [key, inputValue] of Object.entries(parsed.data)) {
+    const value = parseJsonValue(inputValue);
+    if (!value.ok) {
+      return err({
+        kind: "invalid-config",
+        message: `${key}: ${value.error.message}`
+      });
+    }
+    data[key] = value.value;
+  }
+  return ok(data);
+}
+
+// src/config/globalConfigPath.ts
+import { join } from "path";
+function globalConfigPath(homeDirectory) {
+  return join(homeDirectory, ".config", "macwlt", "config.json");
+}
+
+// src/config/GlobalConfig.ts
+var GlobalConfig = class _GlobalConfig {
+  #path;
+  #storage;
+  #data;
+  #dirty = false;
+  constructor(path, storage, data) {
+    this.#path = path;
+    this.#storage = storage;
+    this.#data = data;
+  }
+  static async load(options = {}) {
+    const path = globalConfigPath(options.homeDirectory ?? homedir());
+    const storage = options.storage ?? fileConfigStorage;
+    let contents2;
+    try {
+      contents2 = await storage.read(path);
+    } catch (cause) {
+      return err({ kind: "read-failed", path, cause });
+    }
+    if (contents2 === void 0) {
+      return ok(new _GlobalConfig(path, storage, {}));
+    }
+    let input;
+    try {
+      input = JSON.parse(contents2);
+    } catch (caught) {
+      return err({
+        kind: "invalid-json",
+        path,
+        message: caught instanceof Error ? caught.message : String(caught)
+      });
+    }
+    const parsed = parseGlobalConfigData(input);
+    if (!parsed.ok) return err({ ...parsed.error, path });
+    return ok(new _GlobalConfig(path, storage, parsed.value));
+  }
+  get path() {
+    return this.#path;
+  }
+  get dirty() {
+    return this.#dirty;
+  }
+  get data() {
+    return cloneData(this.#data);
+  }
+  get(key) {
+    if (!Object.hasOwn(this.#data, key)) return void 0;
+    const value = this.#data[key];
+    return value === void 0 ? void 0 : cloneValue(value);
+  }
+  set(key, input) {
+    if (key.length === 0) {
+      return err({ kind: "invalid-config", message: "config key must not be empty" });
+    }
+    const value = parseJsonValue(input);
+    if (!value.ok) return value;
+    this.#data = { ...this.#data, [key]: value.value };
+    this.#dirty = true;
+    return ok(void 0);
+  }
+  delete(key) {
+    if (!Object.hasOwn(this.#data, key)) return;
+    const { [key]: removed, ...remaining } = this.#data;
+    void removed;
+    this.#data = remaining;
+    this.#dirty = true;
+  }
+  replace(input) {
+    const data = parseGlobalConfigData(input);
+    if (!data.ok) return data;
+    this.#data = data.value;
+    this.#dirty = true;
+    return ok(void 0);
+  }
+  async save() {
+    const contents2 = `${JSON.stringify(this.#data, null, 2)}
+`;
+    try {
+      await this.#storage.write(this.#path, contents2);
+    } catch (cause) {
+      return err({ kind: "write-failed", path: this.#path, cause });
+    }
+    this.#dirty = false;
+    return ok(void 0);
+  }
+};
+function cloneData(data) {
+  return structuredClone(data);
+}
+function cloneValue(value) {
+  return structuredClone(value);
+}
+
+// src/config/createFileIfAbsent.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname2 } from "path";
+async function createFileIfAbsent(path, contents2) {
+  await mkdir2(dirname2(path), { recursive: true, mode: 448 });
+  try {
+    await writeFile2(path, contents2, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 384
+    });
+    return "created";
+  } catch (caught) {
+    if (isAlreadyExistsError(caught)) return "already-exists";
+    throw caught;
+  }
+}
+function isAlreadyExistsError(caught) {
+  return caught instanceof Error && "code" in caught && caught.code === "EEXIST";
+}
+
+// config.default.json
+var config_default_default = {
+  ethereum: {
+    chains: {
+      "1": {
+        name: "Ethereum Mainnet",
+        rpcUrl: "https://ethereum-rpc.publicnode.com",
+        nativeAsset: {
+          symbol: "ETH"
+        },
+        assets: [
+          {
+            symbol: "USDC",
+            address: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
+          },
+          {
+            symbol: "USDT",
+            address: "0xdac17f958d2ee523a2206206994597c13d831ec7"
+          },
+          {
+            symbol: "WETH",
+            address: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
+          }
+        ]
+      },
+      "42161": {
+        name: "Arbitrum One",
+        rpcUrl: "https://arbitrum-one-rpc.publicnode.com",
+        nativeAsset: {
+          symbol: "ETH"
+        },
+        assets: [
+          {
+            symbol: "USDC",
+            address: "0xaf88d065e77c8cc2239327c5edb3a432268e5831"
+          },
+          {
+            symbol: "USDT",
+            address: "0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9"
+          },
+          {
+            symbol: "WETH",
+            address: "0x82af49447d8a07e3bd95bd0d56f35241523fbab1"
+          }
+        ]
+      },
+      "8453": {
+        name: "Base",
+        rpcUrl: "https://base-rpc.publicnode.com",
+        nativeAsset: {
+          symbol: "ETH"
+        },
+        assets: [
+          {
+            symbol: "USDC",
+            address: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913"
+          },
+          {
+            symbol: "WETH",
+            address: "0x4200000000000000000000000000000000000006"
+          }
+        ]
+      },
+      "10": {
+        name: "OP Mainnet",
+        rpcUrl: "https://optimism-rpc.publicnode.com",
+        nativeAsset: {
+          symbol: "ETH"
+        },
+        assets: [
+          {
+            symbol: "USDC",
+            address: "0x0b2c639c533813f4aa9d7837caf62653d097ff85"
+          },
+          {
+            symbol: "USDT",
+            address: "0x94b008aa00579c1307b0ef2c499ad98a8ce58e58"
+          },
+          {
+            symbol: "WETH",
+            address: "0x4200000000000000000000000000000000000006"
+          }
+        ]
+      },
+      "137": {
+        name: "Polygon PoS",
+        rpcUrl: "https://polygon-bor-rpc.publicnode.com",
+        nativeAsset: {
+          symbol: "POL"
+        },
+        assets: [
+          {
+            symbol: "USDC",
+            address: "0x3c499c542cef5e3811e1192ce70d8cc03d5c3359"
+          },
+          {
+            symbol: "USDT",
+            address: "0xc2132d05d31c914a87c6611c10748aeb04b58e8f"
+          },
+          {
+            symbol: "WETH",
+            address: "0x7ceb23fd6bc0add59e62ac25578270cff1b9f619"
+          }
+        ]
+      },
+      "56": {
+        name: "BNB Smart Chain",
+        rpcUrl: "https://bsc-rpc.publicnode.com",
+        nativeAsset: {
+          symbol: "BNB"
+        },
+        assets: [
+          {
+            symbol: "USDC",
+            address: "0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d"
+          },
+          {
+            symbol: "USDT",
+            address: "0x55d398326f99059ff775485246999027b3197955"
+          },
+          {
+            symbol: "WBNB",
+            address: "0xbb4cdb9cbd36b01bd1cbaebf2de08d9173bc095c"
+          }
+        ]
+      },
+      "43114": {
+        name: "Avalanche C-Chain",
+        rpcUrl: "https://avalanche-c-chain-rpc.publicnode.com",
+        nativeAsset: {
+          symbol: "AVAX"
+        },
+        assets: [
+          {
+            symbol: "USDC",
+            address: "0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e"
+          },
+          {
+            symbol: "USDT",
+            address: "0x9702230a8ea53601f5cd2dc00fdbc13d4df4a8c7"
+          },
+          {
+            symbol: "WAVAX",
+            address: "0xb31f66aa3c1e785363f0875a1b74e27b85fd66c7"
+          }
+        ]
+      }
+    }
+  }
+};
+
+// src/config/defaultGlobalConfigContents.ts
+var parsedDefaultConfig = parseGlobalConfigData(config_default_default);
+if (!parsedDefaultConfig.ok) {
+  throw new Error(
+    `invalid config.default.json: ${parsedDefaultConfig.error.message}`
+  );
+}
+var contents = `${JSON.stringify(parsedDefaultConfig.value, null, 2)}
+`;
+function defaultGlobalConfigContents() {
+  return contents;
+}
+
+// src/config/ensureGlobalConfig.ts
+import { homedir as homedir2 } from "os";
+async function ensureGlobalConfig(options = {}) {
+  const path = globalConfigPath(options.homeDirectory ?? homedir2());
+  const createFile = options.createFile ?? createFileIfAbsent;
+  try {
+    const creation = await createFile(
+      path,
+      defaultGlobalConfigContents()
+    );
+    return ok({ path, created: creation === "created" });
+  } catch (cause) {
+    return err({ kind: "write-failed", path, cause });
+  }
+}
+
+// src/config/resetGlobalConfig.ts
+import { homedir as homedir3 } from "os";
+async function resetGlobalConfig(options = {}) {
+  const path = globalConfigPath(options.homeDirectory ?? homedir3());
+  const storage = options.storage ?? fileConfigStorage;
+  try {
+    await storage.write(path, defaultGlobalConfigContents());
+    return ok(path);
+  } catch (cause) {
+    return err({ kind: "write-failed", path, cause });
+  }
+}
+
+// src/native.ts
+import { dlopen, ptr, read } from "bun:ffi";
+import { existsSync } from "fs";
+import { join as join2, resolve } from "path";
+var MACWLT_SUCCESS = 0;
+var MACWLT_ERR_BUFFER_TOO_SMALL = 5;
+var nativeSymbols = {
+  macwlt_wallet_create: { args: ["ptr"], returns: "int" },
+  macwlt_wallet_free: { args: ["ptr"], returns: "void" },
+  macwlt_last_error: { args: ["ptr"], returns: "int" },
+  macwlt_last_error_message: { args: ["ptr"], returns: "cstring" },
+  macwlt_reset_wallet: { args: ["ptr"], returns: "int" },
+  macwlt_bootstrap_wallet: { args: ["ptr", "ptr", "ptr"], returns: "int" },
+  macwlt_sign_psbt: { args: ["ptr", "ptr", "usize", "ptr", "ptr"], returns: "int" },
+  macwlt_sign_eth_tx: { args: ["ptr", "ptr", "usize", "ptr", "ptr"], returns: "int" },
+  macwlt_export_pubkey: { args: ["ptr", "cstring", "ptr", "ptr"], returns: "int" },
+  macwlt_export_address: { args: ["ptr", "cstring", "int", "ptr", "ptr"], returns: "int" }
+};
+function defaultLibraryPath(envPath) {
+  if (envPath && envPath.length > 0) return resolve(envPath);
+  const candidates = [
+    resolve(join2(import.meta.dir, "../native/libmacwlt.dylib")),
+    resolve(join2(process.cwd(), "build/libmacwlt.dylib")),
+    resolve(join2(process.cwd(), "../build/libmacwlt.dylib")),
+    resolve(join2(import.meta.dir, "../../build/libmacwlt.dylib")),
+    resolve(join2(import.meta.dir, "../../../build/libmacwlt.dylib"))
+  ];
+  return candidates.find((candidate) => existsSync(candidate)) ?? candidates[0] ?? resolve("build/libmacwlt.dylib");
+}
+function openNativeClient(libraryPath) {
+  if (!existsSync(libraryPath)) return err({ kind: "missing-library", libraryPath });
+  let library;
+  try {
+    library = dlopen(libraryPath, nativeSymbols);
+  } catch (caught) {
+    return err({ kind: "load", libraryPath, message: messageFromUnknown(caught) });
+  }
+  const client = {
+    libraryPath,
+    close: () => library.close(),
+    withWallet: (body) => {
+      const walletResult = createWallet(library.symbols);
+      if (!walletResult.ok) return walletResult;
+      try {
+        return body(walletResult.value);
+      } finally {
+        walletResult.value.close();
+      }
+    }
+  };
+  return ok(client);
+}
+function createWallet(symbols) {
+  const walletSlot = new BigUint64Array(1);
+  const createStatus = symbols.macwlt_wallet_create(ptr(walletSlot));
+  const walletAddress = read.ptr(ptr(walletSlot));
+  if (createStatus !== MACWLT_SUCCESS || walletAddress === 0) {
+    return err({ kind: "wallet-create", message: "macwlt_wallet_create failed" });
+  }
+  const walletPointer = walletAddress;
+  const wallet = {
+    close: () => {
+      symbols.macwlt_wallet_free(walletPointer);
+    },
+    reset: () => {
+      const status = symbols.macwlt_reset_wallet(walletPointer);
+      if (status !== MACWLT_SUCCESS) {
+        return err(nativeError(symbols, walletPointer, "reset wallet", symbols.macwlt_last_error(walletPointer)));
+      }
+      return ok(void 0);
+    },
+    bootstrap: () => outputBytes(
+      symbols,
+      walletPointer,
+      "bootstrap",
+      33,
+      (output, length) => symbols.macwlt_bootstrap_wallet(walletPointer, output, length)
+    ),
+    exportPubkey: (derivationPath) => outputBytes(
+      symbols,
+      walletPointer,
+      "export pubkey",
+      33,
+      (output, length) => symbols.macwlt_export_pubkey(walletPointer, cString(derivationPath), output, length)
+    ),
+    exportAddress: (derivationPath, addressType) => {
+      const result = outputBytes(
+        symbols,
+        walletPointer,
+        "export address",
+        96,
+        (output, length) => symbols.macwlt_export_address(walletPointer, cString(derivationPath), nativeAddressType(addressType), output, length)
+      );
+      if (!result.ok) return result;
+      const terminator = result.value.indexOf(0);
+      const addressBytes = terminator >= 0 ? result.value.slice(0, terminator) : result.value;
+      return ok(new TextDecoder().decode(addressBytes));
+    },
+    signEthereumTransaction: (transaction) => outputBytes(
+      symbols,
+      walletPointer,
+      "sign ethereum transaction",
+      65,
+      (output, length) => symbols.macwlt_sign_eth_tx(walletPointer, ptr(transaction), transaction.length, output, length)
+    ),
+    signPsbt: (psbt) => outputBytes(
+      symbols,
+      walletPointer,
+      "sign psbt",
+      Math.max(psbt.length + 1024, 1024),
+      (output, length) => symbols.macwlt_sign_psbt(walletPointer, ptr(psbt), psbt.length, output, length)
+    )
+  };
+  return ok(wallet);
+}
+function outputBytes(symbols, walletPointer, operation, initialCapacity, call) {
+  const firstLength = new BigUint64Array([BigInt(initialCapacity)]);
+  const firstBuffer = initialCapacity > 0 ? new Uint8Array(initialCapacity) : null;
+  const firstStatus = call(firstBuffer ? ptr(firstBuffer) : null, ptr(firstLength));
+  if (firstStatus === MACWLT_SUCCESS && firstBuffer) {
+    const lengthResult = sizeFromSlot(operation, firstLength);
+    if (!lengthResult.ok) return lengthResult;
+    return ok(firstBuffer.slice(0, lengthResult.value));
+  }
+  const firstError = symbols.macwlt_last_error(walletPointer);
+  if (firstError !== MACWLT_ERR_BUFFER_TOO_SMALL) {
+    return err(nativeError(symbols, walletPointer, operation, firstError));
+  }
+  const requiredLength = sizeFromSlot(operation, firstLength);
+  if (!requiredLength.ok) return requiredLength;
+  const retryLength = new BigUint64Array([BigInt(requiredLength.value)]);
+  const retryBuffer = new Uint8Array(requiredLength.value);
+  const retryStatus = call(ptr(retryBuffer), ptr(retryLength));
+  if (retryStatus !== MACWLT_SUCCESS) {
+    return err(nativeError(symbols, walletPointer, operation, symbols.macwlt_last_error(walletPointer)));
+  }
+  const finalLength = sizeFromSlot(operation, retryLength);
+  if (!finalLength.ok) return finalLength;
+  return ok(retryBuffer.slice(0, finalLength.value));
+}
+function sizeFromSlot(operation, slot) {
+  const size = slot[0] ?? 0n;
+  if (size > BigInt(Number.MAX_SAFE_INTEGER)) {
+    return err({ kind: "oversized-output", operation, size });
+  }
+  return ok(Number(size));
+}
+function cString(value) {
+  const encoded = new TextEncoder().encode(value);
+  const output = new Uint8Array(encoded.length + 1);
+  output.set(encoded);
+  return output;
+}
+function nativeAddressType(addressType) {
+  switch (addressType) {
+    case "bitcoin":
+      return 1;
+    case "bitcoin-testnet":
+      return 2;
+    case "ethereum":
+      return 3;
+    case "bitcoin-taproot":
+      return 4;
+    case "bitcoin-taproot-testnet":
+      return 5;
+  }
+}
+function nativeError(symbols, walletPointer, operation, code) {
+  const nativeMessage = symbols.macwlt_last_error_message(walletPointer);
+  const message = nativeMessage ? nativeMessage.toString() : messageForNativeCode(code);
+  return { kind: "native", operation, code, message };
+}
+function messageForNativeCode(code) {
+  switch (code) {
+    case 1:
+      return "invalid argument";
+    case 2:
+      return "wallet data is unavailable";
+    case 3:
+      return "authentication is required";
+    case 4:
+      return "authentication failed";
+    case 5:
+      return "output buffer is too small";
+    case 6:
+      return "operation is unsupported";
+    case 7:
+      return "input parsing failed";
+    case 8:
+      return "signing failed";
+    case 9:
+      return "internal native error";
+    default:
+      return `unknown native error ${code}`;
+  }
+}
+function messageFromUnknown(caught) {
+  if (caught instanceof Error) return caught.message;
+  return String(caught);
+}
+
+// src/nativeError.ts
+function formatNativeError(error) {
+  switch (error.kind) {
+    case "missing-library":
+      return `native library not found at ${error.libraryPath}; reinstall @macwlt/cli, run make build in a checkout, or set MACWLT_LIB`;
+    case "load":
+      return `failed to load ${error.libraryPath}: ${error.message}`;
+    case "wallet-create":
+      return error.message;
+    case "native":
+      return `${error.operation} failed: ${error.message}`;
+    case "oversized-output":
+      return `${error.operation} produced an oversized output (${error.size.toString()} bytes)`;
+  }
+}
+function formatExecutionError(error) {
+  return typeof error === "string" ? error : formatNativeError(error);
+}
+
+// src/parseFlags.ts
+function parseFlags(args) {
+  let json = false;
+  const positionals = [];
+  const options = /* @__PURE__ */ new Map();
+  const switches = /* @__PURE__ */ new Set();
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (!arg) continue;
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    if (arg === "--reset" || arg === "--yes") {
+      switches.add(arg.slice(2));
+      continue;
+    }
+    if (!arg.startsWith("--")) {
+      positionals.push(arg);
+      continue;
+    }
+    const key = arg.slice(2);
+    if (key.length === 0) return err("empty option name");
+    const value = args[index + 1];
+    if (!value || value.startsWith("--")) return err(`missing value for --${key}`);
+    options.set(key, value);
+    index++;
+  }
+  return ok({ json, positionals, options, switches });
+}
+
+// src/withWallet.ts
+function runWithWallet(client, body) {
+  const result = client.withWallet(body);
+  if (!result.ok) return err(formatExecutionError(result.error));
+  return ok(result.value);
+}
+
+// src/hex.ts
+function bytesToHex(bytes) {
+  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function hexToBytes(input) {
+  const normalized = input.startsWith("0x") || input.startsWith("0X") ? input.slice(2) : input;
+  if (normalized.length === 0) return err({ kind: "empty" });
+  if (normalized.length % 2 !== 0 || !/^[0-9a-fA-F]+$/.test(normalized)) {
+    return err({ kind: "invalid", value: input });
+  }
+  const bytes = new Uint8Array(normalized.length / 2);
+  for (let index = 0; index < bytes.length; index++) {
+    const pair = normalized.slice(index * 2, index * 2 + 2);
+    bytes[index] = Number.parseInt(pair, 16);
+  }
+  return ok(bytes);
+}
+
+// src/walletOutput.ts
+function formatDataOutput(bytes, json, key) {
+  const hex = bytesToHex(bytes);
+  if (!json) return hex;
+  return JSON.stringify({ [key]: hex }, null, 2);
+}
+function formatPsbt(bytes, format) {
+  return format === "base64" ? bytesToBase64(bytes) : bytesToHex(bytes);
+}
+
+// src/commands/create.ts
+var createCommand = {
+  name: "create",
+  describe() {
+    return "  macwlt create [--reset] [--json]";
+  },
+  parse: parseCreate,
+  async run(ctx, args) {
+    const result = runWithWallet(ctx.client, (wallet) => {
+      if (args.reset) {
+        const reset = wallet.reset();
+        if (!reset.ok) return err(formatNativeError(reset.error));
+      }
+      const publicKey = wallet.bootstrap();
+      if (!publicKey.ok) return err(formatNativeError(publicKey.error));
+      return ok(formatDataOutput(publicKey.value, args.json, "jointPublicKey"));
+    });
+    return result;
+  }
+};
+function parseCreate(args) {
+  const flags = parseFlags(args);
+  if (!flags.ok) return flags;
+  if (flags.value.positionals.length > 0) return err("create does not accept positional arguments");
+  return ok({ reset: flags.value.switches.has("reset"), json: flags.value.json });
+}
+
+// src/terminalConfirmationPrompt.ts
+import { createInterface } from "readline/promises";
+async function terminalConfirmationPrompt(question) {
+  const readline = createInterface({
+    input: process.stdin,
+    output: process.stderr
+  });
+  try {
+    return isAffirmativeConfirmation(await readline.question(question));
+  } catch {
+    return false;
+  } finally {
+    readline.close();
+  }
+}
+function isAffirmativeConfirmation(answer) {
+  const normalized = answer.trim().toLowerCase();
+  return normalized === "y" || normalized === "yes";
+}
+
+// src/hooks/createConfirmationHook.ts
+function createConfirmationHook(prompt = terminalConfirmationPrompt) {
+  return async () => {
+    const confirmed = await prompt("Continue? [y/N] ");
+    return confirmed ? ok(void 0) : err("command cancelled");
+  };
+}
+
+// src/commands/reset.ts
+var resetCommand = {
+  name: "reset",
+  beforeRun: createConfirmationHook(),
+  describe() {
+    return "  macwlt reset --yes [--json]";
+  },
+  parse: parseReset,
+  async run(ctx, args) {
+    return runWithWallet(ctx.client, (wallet) => {
+      const reset = wallet.reset();
+      if (!reset.ok) return err(formatNativeError(reset.error));
+      if (!args.json) return ok("wallet reset");
+      return ok(JSON.stringify({ reset: true }, null, 2));
+    });
+  }
+};
+function parseReset(args) {
+  const flags = parseFlags(args);
+  if (!flags.ok) return flags;
+  if (flags.value.positionals.length > 0) return err("reset does not accept positional arguments");
+  if (!flags.value.switches.has("yes")) return err("reset requires --yes");
+  return ok({ json: flags.value.json });
+}
+
+// src/commands/resetConfig.ts
+var resetConfigCommand = {
+  name: "reset-config",
+  needsClient: false,
+  beforeRun: createConfirmationHook(),
+  describe() {
+    return "  macwlt reset-config [--json]";
+  },
+  parse: parseResetConfig,
+  async run(ctx, args) {
+    const reset = await resetGlobalConfig({
+      homeDirectory: ctx.env.HOME?.length ? ctx.env.HOME : void 0,
+      storage: ctx.configStorage
+    });
+    if (!reset.ok) {
+      return err(
+        `failed to reset config ${reset.error.path}: ${messageFromUnknown2(reset.error.cause)}`
+      );
+    }
+    if (!args.json) return ok(`config reset to defaults: ${reset.value}`);
+    return ok(JSON.stringify({
+      reset: true,
+      path: reset.value
+    }, null, 2));
+  }
+};
+function parseResetConfig(args) {
+  const flags = parseFlags(args);
+  if (!flags.ok) return flags;
+  if (flags.value.positionals.length > 0) {
+    return err("reset-config does not accept positional arguments");
+  }
+  if (flags.value.options.size > 0 || flags.value.switches.size > 0) {
+    return err("reset-config only accepts --json");
+  }
+  return ok({ json: flags.value.json });
+}
+function messageFromUnknown2(value) {
+  return value instanceof Error ? value.message : String(value);
+}
+
+// src/commands/pubkey.ts
+var pubkeyCommand = {
+  name: "pubkey",
+  describe() {
+    return "  macwlt pubkey [path] [--json]";
+  },
+  parse: parsePubkey,
+  async run(ctx, args) {
+    return runWithWallet(ctx.client, (wallet) => {
+      const bootstrapped = wallet.bootstrap();
+      if (!bootstrapped.ok) return err(formatNativeError(bootstrapped.error));
+      const publicKey = wallet.exportPubkey(args.derivationPath);
+      if (!publicKey.ok) return err(formatNativeError(publicKey.error));
+      return ok(formatDataOutput(publicKey.value, args.json, "publicKey"));
+    });
+  }
+};
+function parsePubkey(args) {
+  const flags = parseFlags(args);
+  if (!flags.ok) return flags;
+  if (flags.value.positionals.length > 1) return err("pubkey accepts at most one derivation path");
+  return ok({ derivationPath: flags.value.positionals[0] ?? "m", json: flags.value.json });
+}
+
+// src/commands/address.ts
+var addressCommand = {
+  name: "address",
+  describe() {
+    return "  macwlt address [path] --type bitcoin|bitcoin-testnet|bitcoin-taproot|bitcoin-taproot-testnet|ethereum [--json]";
+  },
+  parse: parseAddress,
+  async run(ctx, args) {
+    return runWithWallet(ctx.client, (wallet) => {
+      const bootstrapped = wallet.bootstrap();
+      if (!bootstrapped.ok) return err(formatNativeError(bootstrapped.error));
+      const address = wallet.exportAddress(args.derivationPath, args.addressType);
+      if (!address.ok) return err(formatNativeError(address.error));
+      if (!args.json) return ok(address.value);
+      return ok(JSON.stringify({ address: address.value, derivationPath: args.derivationPath, type: args.addressType }, null, 2));
+    });
+  }
+};
+function parseAddress(args) {
+  const flags = parseFlags(args);
+  if (!flags.ok) return flags;
+  if (flags.value.positionals.length > 1) return err("address accepts at most one derivation path");
+  const type = flags.value.options.get("type");
+  if (!isAddressType(type)) {
+    return err(
+      "address requires --type bitcoin|bitcoin-testnet|bitcoin-taproot|bitcoin-taproot-testnet|ethereum"
+    );
+  }
+  return ok({ derivationPath: flags.value.positionals[0] ?? "m", addressType: type, json: flags.value.json });
+}
+function isAddressType(value) {
+  return value === "bitcoin" || value === "bitcoin-testnet" || value === "bitcoin-taproot" || value === "bitcoin-taproot-testnet" || value === "ethereum";
+}
+
+// src/bytesInput.ts
+function parseBytesInput(options, allowed) {
+  const entries = allowed.flatMap((key) => {
+    const value = options.get(key);
+    return value ? [{ key, value }] : [];
+  });
+  if (entries.length !== 1) return err(`provide exactly one input option: ${allowed.map((key) => `--${key}`).join(", ")}`);
+  const input = entries[0];
+  if (!input) return err("missing input");
+  if (input.key === "hex") return ok({ kind: "hex", value: input.value });
+  if (input.key === "base64") return ok({ kind: "base64", value: input.value });
+  return ok({ kind: "file", path: input.value });
+}
+async function readInput(input) {
+  switch (input.kind) {
+    case "hex": {
+      const decoded = hexToBytes(input.value);
+      if (!decoded.ok) return err(decoded.error.kind === "empty" ? "hex input is empty" : `invalid hex input: ${decoded.error.value}`);
+      return decoded;
+    }
+    case "base64": {
+      const decoded = base64ToBytes(input.value);
+      if (!decoded.ok) return err(decoded.error.kind === "empty" ? "base64 input is empty" : "invalid base64 input");
+      return decoded;
+    }
+    case "file": {
+      try {
+        return ok(new Uint8Array(await Bun.file(input.path).arrayBuffer()));
+      } catch (caught) {
+        return err(`failed to read ${input.path}: ${caught instanceof Error ? caught.message : String(caught)}`);
+      }
+    }
+  }
+}
+
+// src/commands/signEth.ts
+var signEthCommand = {
+  name: "sign-eth",
+  describe() {
+    return "  macwlt sign-eth --hex <typed-transaction-preimage-hex> [--json]";
+  },
+  parse: parseSignEth,
+  async run(ctx, args) {
+    const transaction = await readInput(args.input);
+    if (!transaction.ok) return transaction;
+    return runWithWallet(ctx.client, (wallet) => {
+      const bootstrapped = wallet.bootstrap();
+      if (!bootstrapped.ok) return err(formatNativeError(bootstrapped.error));
+      const signature = wallet.signEthereumTransaction(transaction.value);
+      if (!signature.ok) return err(formatNativeError(signature.error));
+      return ok(formatDataOutput(signature.value, args.json, "signature"));
+    });
+  }
+};
+function parseSignEth(args) {
+  const flags = parseFlags(args);
+  if (!flags.ok) return flags;
+  if (flags.value.positionals.length > 0) return err("sign-eth does not accept positional arguments");
+  const input = parseBytesInput(flags.value.options, ["hex", "in"]);
+  if (!input.ok) return input;
+  return ok({ input: input.value, json: flags.value.json });
+}
+
+// src/commands/signPsbt.ts
+var signPsbtCommand = {
+  name: "sign-psbt",
+  describe() {
+    return [
+      "  macwlt sign-psbt --base64 <psbt> [--format base64|hex] [--json]",
+      "  macwlt sign-psbt --hex <psbt-hex> [--out <file>] [--format base64|hex|raw]",
+      "  macwlt sign-psbt --in <file> [--out <file>] [--format base64|hex|raw]"
+    ].join("\n");
+  },
+  parse: parseSignPsbt,
+  async run(ctx, args) {
+    const psbt = await readInput(args.input);
+    if (!psbt.ok) return psbt;
+    const signedResult = runWithWallet(ctx.client, (wallet) => {
+      const bootstrapped = wallet.bootstrap();
+      if (!bootstrapped.ok) return err(formatNativeError(bootstrapped.error));
+      const signedPsbt = wallet.signPsbt(psbt.value);
+      if (!signedPsbt.ok) return err(formatNativeError(signedPsbt.error));
+      return ok(signedPsbt.value);
+    });
+    if (!signedResult.ok) return signedResult;
+    if (args.output.kind === "file") {
+      const bytes = args.format === "raw" ? signedResult.value : new TextEncoder().encode(formatPsbt(signedResult.value, args.format));
+      await Bun.write(args.output.path, bytes);
+      return ok(args.json ? JSON.stringify({ output: args.output.path, format: args.format }, null, 2) : args.output.path);
+    }
+    if (args.format === "raw") return err("--format raw requires --out <file>");
+    if (args.json) return ok(JSON.stringify({ signedPsbt: formatPsbt(signedResult.value, args.format), format: args.format }, null, 2));
+    return ok(formatPsbt(signedResult.value, args.format));
+  }
+};
+function parseSignPsbt(args) {
+  const flags = parseFlags(args);
+  if (!flags.ok) return flags;
+  if (flags.value.positionals.length > 0) return err("sign-psbt does not accept positional arguments");
+  const input = parseBytesInput(flags.value.options, ["base64", "hex", "in"]);
+  if (!input.ok) return input;
+  const format = flags.value.options.get("format") ?? "base64";
+  if (!isPsbtOutputFormat(format)) return err("--format must be base64, hex, or raw");
+  const out = flags.value.options.get("out");
+  return ok({
+    input: input.value,
+    output: out ? { kind: "file", path: out } : { kind: "stdout" },
+    format,
+    json: flags.value.json
+  });
+}
+function isPsbtOutputFormat(value) {
+  return value === "base64" || value === "hex" || value === "raw";
+}
+
+// src/commands/help.ts
+var helpCommand = {
+  name: "help",
+  aliases: ["--help", "-h"],
+  needsClient: false,
+  describe() {
+    return "";
+  },
+  parse(_args) {
+    return ok({ kind: "help" });
+  },
+  async run(ctx, _args) {
+    return ok(helpText(ctx.registry));
+  }
+};
+
+// src/commands/version.ts
+var versionCommand = {
+  name: "version",
+  aliases: ["--version", "-v"],
+  needsClient: false,
+  describe() {
+    return "  macwlt version";
+  },
+  parse(_args) {
+    return ok({ kind: "version" });
+  },
+  async run(_ctx, _args) {
+    return ok(`macwlt ${cliVersion}`);
+  }
+};
+
+// src/commands/send.ts
+import { isAddress as isAddress4 } from "viem";
+
+// src/ethereum/EthereumConfig.ts
+import { z as z3 } from "zod";
+var rpcUrlSchema = z3.string().superRefine((value, context) => {
+  try {
+    const protocol = new URL(value).protocol;
+    if (protocol === "http:" || protocol === "https:") return;
+  } catch {
+  }
+  context.addIssue({ code: z3.ZodIssueCode.custom, message: "Invalid RPC URL" });
+});
+var chainIdSchema = z3.number().int().positive().safe();
+function parseEthereumConfig(input) {
+  const rpcUrl = rpcUrlSchema.safeParse(input.rpcUrl);
+  if (!rpcUrl.success) {
+    return err({ kind: "invalid-rpc-url", value: input.rpcUrl });
+  }
+  const chainId = chainIdSchema.safeParse(input.chainId);
+  if (!chainId.success) {
+    return err({ kind: "invalid-chain-id", value: input.chainId });
+  }
+  return ok({
+    rpcUrl: rpcUrl.data,
+    chainId: chainId.data
+  });
+}
+
+// src/ethereum/EvmCall.ts
+import { z as z4 } from "zod";
+var addressSchema = z4.string().regex(/^0x[0-9a-fA-F]{40}$/);
+var hexSchema = z4.string().regex(/^0x(?:[0-9a-fA-F]{2})*$/);
+var quantitySchema = z4.bigint().nonnegative();
+var blockSchema = z4.union([
+  z4.enum(["earliest", "finalized", "latest", "pending", "safe"]),
+  quantitySchema
+]);
+var evmCallRequestSchema = z4.object({
+  to: addressSchema,
+  data: hexSchema.optional(),
+  from: addressSchema.optional(),
+  gas: quantitySchema.optional(),
+  gasPrice: quantitySchema.optional(),
+  value: quantitySchema.optional(),
+  block: blockSchema.optional()
+}).strict();
+var evmCallResultSchema = z4.object({
+  data: hexSchema.optional()
+});
+function parseEvmCallRequest(input) {
+  const parsed = evmCallRequestSchema.safeParse(input);
+  if (!parsed.success) {
+    return err({ message: parsed.error.issues.map((issue) => issue.message).join("; ") });
+  }
+  return ok(parsed.data);
+}
+function parseEvmCallResult(input) {
+  const parsed = evmCallResultSchema.safeParse(input);
+  if (!parsed.success) {
+    return err({ message: parsed.error.issues.map((issue) => issue.message).join("; ") });
+  }
+  return ok(parsed.data);
+}
+
+// src/ethereum/EthereumClient.ts
+import { z as z5 } from "zod";
+var addressSchema2 = z5.string().regex(/^0x[0-9a-fA-F]{40}$/);
+var transactionRequestSchema = z5.object({
+  from: addressSchema2,
+  to: addressSchema2,
+  data: z5.string().regex(/^0x(?:[0-9a-fA-F]{2})*$/).optional(),
+  value: z5.bigint().nonnegative().optional()
+}).strict();
+var chainIdSchema2 = z5.number().int().positive().safe();
+var transactionCountSchema = z5.number().int().nonnegative().safe();
+var quantitySchema2 = z5.bigint().nonnegative();
+var transactionHashSchema = z5.custom(
+  (value) => typeof value === "string" && /^0x[0-9a-fA-F]{64}$/.test(value)
+);
+var EthereumClient = class _EthereumClient {
+  #config;
+  #transport;
+  #chainVerification;
+  constructor(config, transport) {
+    this.#config = config;
+    this.#transport = transport;
+  }
+  static create(input, createTransport) {
+    const config = parseEthereumConfig(input);
+    if (!config.ok) return config;
+    try {
+      return ok(new _EthereumClient(config.value, createTransport(config.value)));
+    } catch (cause) {
+      return err({ kind: "transport-creation-failed", cause });
+    }
+  }
+  get config() {
+    return this.#config;
+  }
+  async call(request) {
+    const parsedRequest = parseEvmCallRequest(request);
+    if (!parsedRequest.ok) {
+      return err({ kind: "invalid-request", message: parsedRequest.error.message });
+    }
+    let response;
+    try {
+      response = await this.#transport.call(parsedRequest.value);
+    } catch (cause) {
+      return err({ kind: "transport-failed", cause });
+    }
+    const parsedResponse = parseEvmCallResult(response);
+    if (!parsedResponse.ok) {
+      return err({ kind: "invalid-response", message: parsedResponse.error.message });
+    }
+    return ok(parsedResponse.value);
+  }
+  async verifyChain() {
+    this.#chainVerification ??= this.#verifyConfiguredChain();
+    return await this.#chainVerification;
+  }
+  async #verifyConfiguredChain() {
+    const chainId = await this.#performTransactionOperation(
+      "get-chain-id",
+      (transport) => transport.getChainId(),
+      chainIdSchema2
+    );
+    if (!chainId.ok) return chainId;
+    if (chainId.value !== this.#config.chainId) {
+      return err({
+        kind: "chain-mismatch",
+        expected: this.#config.chainId,
+        actual: chainId.value
+      });
+    }
+    return ok(void 0);
+  }
+  async getTransactionCount(address) {
+    if (!addressSchema2.safeParse(address).success) {
+      return err({ kind: "invalid-request", message: "invalid Ethereum address" });
+    }
+    return await this.#performTransactionOperation(
+      "get-transaction-count",
+      (transport) => transport.getTransactionCount(address),
+      transactionCountSchema
+    );
+  }
+  async estimateGas(request) {
+    const parsed = transactionRequestSchema.safeParse(request);
+    if (!parsed.success) {
+      return err({
+        kind: "invalid-request",
+        message: parsed.error.issues.map((issue) => issue.message).join("; ")
+      });
+    }
+    return await this.#performTransactionOperation(
+      "estimate-gas",
+      (transport) => transport.estimateGas(parsed.data),
+      quantitySchema2
+    );
+  }
+  async getBalance(address) {
+    if (!addressSchema2.safeParse(address).success) {
+      return err({ kind: "invalid-request", message: "invalid Ethereum address" });
+    }
+    return await this.#performTransactionOperation(
+      "get-balance",
+      (transport) => transport.getBalance(address),
+      quantitySchema2
+    );
+  }
+  async getGasPrice() {
+    return await this.#performTransactionOperation(
+      "get-gas-price",
+      (transport) => transport.getGasPrice(),
+      quantitySchema2
+    );
+  }
+  async sendRawTransaction(transaction) {
+    if (!/^0x(?:[0-9a-fA-F]{2})+$/.test(transaction)) {
+      return err({ kind: "invalid-request", message: "invalid serialized transaction" });
+    }
+    return await this.#performTransactionOperation(
+      "send-raw-transaction",
+      (transport) => transport.sendRawTransaction(transaction),
+      transactionHashSchema
+    );
+  }
+  async #performTransactionOperation(operation, perform, schema) {
+    if (!isEvmTransport(this.#transport)) {
+      return err({ kind: "unsupported-transport" });
+    }
+    let response;
+    try {
+      response = await perform(this.#transport);
+    } catch (cause) {
+      return err({ kind: "transport-failed", operation, cause });
+    }
+    const parsed = schema.safeParse(response);
+    if (!parsed.success) {
+      return err({
+        kind: "invalid-response",
+        operation,
+        message: parsed.error.issues.map((issue) => issue.message).join("; ")
+      });
+    }
+    return ok(parsed.data);
+  }
+};
+function isEvmTransport(transport) {
+  const candidate = transport;
+  return typeof candidate.getChainId === "function" && typeof candidate.getTransactionCount === "function" && typeof candidate.getBalance === "function" && typeof candidate.estimateGas === "function" && typeof candidate.getGasPrice === "function" && typeof candidate.sendRawTransaction === "function";
+}
+
+// src/ethereum/EthereumAsset.ts
+import { isAddress } from "viem";
+function parseEthereumAsset(input) {
+  if (input.toUpperCase() === "ETH") return ok({ kind: "native-eth" });
+  if (!isAddress(input)) return err("invalid-ethereum-asset");
+  return ok({ kind: "erc20", tokenAddress: input });
+}
+
+// src/ethereum/decodeErc20Decimals.ts
+import { decodeFunctionResult } from "viem";
+var decimalsAbi = [{
+  type: "function",
+  name: "decimals",
+  stateMutability: "view",
+  inputs: [],
+  outputs: [{ name: "", type: "uint8" }]
+}];
+function decodeErc20Decimals(data) {
+  try {
+    const decimals = decodeFunctionResult({
+      abi: decimalsAbi,
+      functionName: "decimals",
+      data
+    });
+    if (!Number.isSafeInteger(decimals) || decimals < 0 || decimals > 255) {
+      return err({
+        kind: "invalid-token-decimals",
+        message: "token returned decimals outside the uint8 range"
+      });
+    }
+    return ok(decimals);
+  } catch (caught) {
+    return err({
+      kind: "invalid-token-decimals",
+      message: caught instanceof Error ? caught.message : String(caught)
+    });
+  }
+}
+
+// src/ethereum/decodeErc20Balance.ts
+import { decodeFunctionResult as decodeFunctionResult2 } from "viem";
+var balanceOfAbi = [{
+  type: "function",
+  name: "balanceOf",
+  stateMutability: "view",
+  inputs: [{ name: "account", type: "address" }],
+  outputs: [{ name: "", type: "uint256" }]
+}];
+function decodeErc20Balance(data) {
+  try {
+    return ok(decodeFunctionResult2({
+      abi: balanceOfAbi,
+      functionName: "balanceOf",
+      data
+    }));
+  } catch (caught) {
+    return err({
+      kind: "invalid-token-balance",
+      message: caught instanceof Error ? caught.message : String(caught)
+    });
+  }
+}
+
+// src/ethereum/encodeErc20BalanceOf.ts
+import { encodeFunctionData } from "viem";
+var balanceOfAbi2 = [{
+  type: "function",
+  name: "balanceOf",
+  stateMutability: "view",
+  inputs: [{ name: "account", type: "address" }],
+  outputs: [{ name: "", type: "uint256" }]
+}];
+function encodeErc20BalanceOf(account) {
+  return encodeFunctionData({
+    abi: balanceOfAbi2,
+    functionName: "balanceOf",
+    args: [account]
+  });
+}
+
+// src/ethereum/encodeErc20DecimalsCall.ts
+import { encodeFunctionData as encodeFunctionData2 } from "viem";
+var decimalsAbi2 = [{
+  type: "function",
+  name: "decimals",
+  stateMutability: "view",
+  inputs: [],
+  outputs: [{ name: "", type: "uint8" }]
+}];
+function encodeErc20DecimalsCall() {
+  return encodeFunctionData2({
+    abi: decimalsAbi2,
+    functionName: "decimals"
+  });
+}
+
+// src/ethereum/encodeErc20Transfer.ts
+import { encodeFunctionData as encodeFunctionData3 } from "viem";
+var transferAbi = [{
+  type: "function",
+  name: "transfer",
+  stateMutability: "nonpayable",
+  inputs: [
+    { name: "to", type: "address" },
+    { name: "amount", type: "uint256" }
+  ],
+  outputs: [{ name: "", type: "bool" }]
+}];
+function encodeErc20Transfer(recipient, amount) {
+  return encodeFunctionData3({
+    abi: transferAbi,
+    functionName: "transfer",
+    args: [recipient, amount]
+  });
+}
+
+// src/ethereum/getEthereumAssetBalance.ts
+import { formatUnits } from "viem";
+async function getEthereumAssetBalance(client, address, asset) {
+  const verified = await client.verifyChain();
+  if (!verified.ok) {
+    return err({ kind: "chain-client", stage: "verify-chain", error: verified.error });
+  }
+  if (asset.kind === "native-eth") {
+    const balance2 = await client.getBalance(address);
+    if (!balance2.ok) {
+      return err({
+        kind: "chain-client",
+        stage: "get-native-balance",
+        error: balance2.error
+      });
+    }
+    return ok({
+      kind: "native-eth",
+      address,
+      balance: formatUnits(balance2.value, 18),
+      balanceBaseUnits: balance2.value,
+      decimals: 18
+    });
+  }
+  const [balanceCall, decimalsCall] = await Promise.all([
+    client.call({
+      to: asset.tokenAddress,
+      data: encodeErc20BalanceOf(address)
+    }),
+    client.call({
+      to: asset.tokenAddress,
+      data: encodeErc20DecimalsCall()
+    })
+  ]);
+  if (!balanceCall.ok) {
+    return err({
+      kind: "chain-client",
+      stage: "read-token-balance",
+      error: balanceCall.error
+    });
+  }
+  if (!decimalsCall.ok) {
+    return err({
+      kind: "chain-client",
+      stage: "read-token-decimals",
+      error: decimalsCall.error
+    });
+  }
+  if (balanceCall.value.data === void 0) {
+    return err({ kind: "missing-token-balance" });
+  }
+  if (decimalsCall.value.data === void 0) {
+    return err({ kind: "missing-token-decimals" });
+  }
+  const balance = decodeErc20Balance(balanceCall.value.data);
+  if (!balance.ok) return err({ kind: "token-balance", error: balance.error });
+  const decimals = decodeErc20Decimals(decimalsCall.value.data);
+  if (!decimals.ok) return err({ kind: "token-decimals", error: decimals.error });
+  return ok({
+    kind: "erc20",
+    address,
+    tokenAddress: asset.tokenAddress,
+    balance: formatUnits(balance.value, decimals.value),
+    balanceBaseUnits: balance.value,
+    decimals: decimals.value
+  });
+}
+
+// src/ethereum/getEthereumPortfolioBalances.ts
+async function getEthereumPortfolioBalances(chains, address, createTransport) {
+  return await Promise.all(
+    chains.map(async (chain) => {
+      const client = EthereumClient.create(
+        { chainId: chain.chainId, rpcUrl: chain.rpcUrl },
+        createTransport
+      );
+      if (!client.ok) {
+        return { status: "failed", chain, error: client.error };
+      }
+      const assets = [
+        {
+          symbol: chain.nativeSymbol,
+          asset: { kind: "native-eth" }
+        },
+        ...chain.assets.map((asset) => ({
+          symbol: asset.symbol,
+          asset: {
+            kind: "erc20",
+            tokenAddress: asset.address
+          }
+        }))
+      ];
+      const balances = await Promise.all(
+        assets.map(async ({ symbol, asset }) => {
+          const balance = await getEthereumAssetBalance(
+            client.value,
+            address,
+            asset
+          );
+          return balance.ok ? { status: "fulfilled", symbol, balance: balance.value } : { status: "failed", symbol, asset, error: balance.error };
+        })
+      );
+      return { status: "fulfilled", chain, assets: balances };
+    })
+  );
+}
+
+// src/ethereum/parseEthereumPortfolioConfig.ts
+import { isAddress as isAddress2 } from "viem";
+import { z as z6 } from "zod";
+var symbolSchema = z6.string().trim().min(1).max(16).regex(/^[A-Za-z0-9._-]+$/);
+var assetSchema = z6.object({
+  symbol: symbolSchema,
+  address: z6.string().refine(isAddress2, "invalid Ethereum address")
+}).strict();
+var chainSchema = z6.object({
+  name: z6.string().trim().min(1),
+  rpcUrl: z6.string(),
+  nativeAsset: z6.object({
+    symbol: symbolSchema
+  }).strict(),
+  assets: z6.array(assetSchema)
+}).strict();
+var portfolioSchema = z6.object({
+  ethereum: z6.object({
+    chains: z6.record(chainSchema)
+  }).passthrough()
+}).passthrough();
+function parseEthereumPortfolioConfig(input) {
+  const parsed = portfolioSchema.safeParse(input);
+  if (!parsed.success) {
+    return err({
+      kind: "invalid-portfolio-config",
+      message: parsed.error.issues.map((issue) => `${issue.path.join(".") || "config"}: ${issue.message}`).join("; ")
+    });
+  }
+  const chains = [];
+  for (const [chainIdValue, chain] of Object.entries(parsed.data.ethereum.chains)) {
+    const chainId = Number(chainIdValue);
+    if (!Number.isSafeInteger(chainId) || chainId <= 0) {
+      return invalid(`ethereum.chains.${chainIdValue}: invalid chain ID`);
+    }
+    const ethereumConfig = parseEthereumConfig({
+      chainId,
+      rpcUrl: chain.rpcUrl
+    });
+    if (!ethereumConfig.ok) {
+      return invalid(`ethereum.chains.${chainIdValue}.rpcUrl: invalid HTTP(S) URL`);
+    }
+    const symbols = /* @__PURE__ */ new Set();
+    const addresses = /* @__PURE__ */ new Set();
+    for (const asset of chain.assets) {
+      const symbol = asset.symbol.toUpperCase();
+      const address = asset.address.toLowerCase();
+      if (symbol === chain.nativeAsset.symbol.toUpperCase()) {
+        return invalid(
+          `ethereum.chains.${chainIdValue}.assets: ${asset.symbol} duplicates the native symbol`
+        );
+      }
+      if (symbols.has(symbol)) {
+        return invalid(
+          `ethereum.chains.${chainIdValue}.assets: duplicate symbol ${asset.symbol}`
+        );
+      }
+      if (addresses.has(address)) {
+        return invalid(
+          `ethereum.chains.${chainIdValue}.assets: duplicate address ${asset.address}`
+        );
+      }
+      symbols.add(symbol);
+      addresses.add(address);
+    }
+    chains.push({
+      chainId,
+      name: chain.name,
+      rpcUrl: ethereumConfig.value.rpcUrl,
+      nativeSymbol: chain.nativeAsset.symbol,
+      assets: chain.assets.map((asset) => ({
+        symbol: asset.symbol,
+        address: asset.address
+      }))
+    });
+  }
+  return ok(chains);
+}
+function invalid(message) {
+  return err({ kind: "invalid-portfolio-config", message });
+}
+
+// src/ethereum/parseTokenAmount.ts
+import { parseUnits } from "viem";
+function parseTokenAmount(value, decimals) {
+  if (!Number.isInteger(decimals) || decimals < 0 || decimals > 255) {
+    return err({ kind: "invalid-token-amount", value });
+  }
+  if (!/^(?:0|[1-9]\d*)(?:\.\d+)?$/.test(value)) {
+    return err({ kind: "invalid-token-amount", value });
+  }
+  const fractionalDigits = value.split(".")[1]?.length ?? 0;
+  if (fractionalDigits > decimals) {
+    return err({ kind: "invalid-token-amount", value });
+  }
+  try {
+    const amount = parseUnits(value, decimals);
+    if (amount <= 0n) return err({ kind: "zero-token-amount" });
+    if (amount >= 1n << 256n) {
+      return err({ kind: "invalid-token-amount", value });
+    }
+    return ok(amount);
+  } catch {
+    return err({ kind: "invalid-token-amount", value });
+  }
+}
+
+// src/ethereum/resolveEthereumRpcUrl.ts
+import { z as z7 } from "zod";
+var ethereumChainsSchema = z7.object({
+  ethereum: z7.object({
+    chains: z7.record(z7.object({
+      rpcUrl: z7.string()
+    }).passthrough())
+  }).passthrough()
+}).passthrough();
+function resolveEthereumRpcUrl(config, chainId) {
+  const parsed = ethereumChainsSchema.safeParse(config);
+  if (!parsed.success) {
+    return err({ kind: "missing-chain-rpc", chainId });
+  }
+  const rpcUrl = parsed.data.ethereum.chains[String(chainId)]?.rpcUrl;
+  if (!rpcUrl) return err({ kind: "missing-chain-rpc", chainId });
+  const ethereumConfig = parseEthereumConfig({ rpcUrl, chainId });
+  if (!ethereumConfig.ok) {
+    return err({ kind: "invalid-chain-rpc", chainId });
+  }
+  return ok(ethereumConfig.value.rpcUrl);
+}
+
+// src/ethereum/serializeSignedTransaction.ts
+import { serializeTransaction } from "viem";
+function serializeSignedTransaction(transaction, signature) {
+  if (signature.length !== 65) {
+    return err({
+      kind: "invalid-signature-length",
+      actual: signature.length
+    });
+  }
+  const parity = signature[64];
+  if (parity !== 0 && parity !== 1) {
+    return err({
+      kind: "invalid-signature-parity",
+      actual: parity ?? -1
+    });
+  }
+  const parsedSignature = {
+    r: `0x${bytesToHex(signature.slice(0, 32))}`,
+    s: `0x${bytesToHex(signature.slice(32, 64))}`,
+    v: 27n + BigInt(parity)
+  };
+  return ok(serializeTransaction(transaction, parsedSignature));
+}
+
+// src/ethereum/serializeUnsignedTransaction.ts
+import { serializeTransaction as serializeTransaction2 } from "viem";
+function serializeUnsignedTransaction(transaction) {
+  return serializeTransaction2(transaction);
+}
+
+// src/ethereum/sendErc20Token.ts
+async function sendErc20Token(client, signer, input) {
+  const verified = await client.verifyChain();
+  if (!verified.ok) {
+    return err({ kind: "chain-client", stage: "verify-chain", error: verified.error });
+  }
+  const decimalsCall = await client.call({
+    to: input.tokenAddress,
+    data: encodeErc20DecimalsCall()
+  });
+  if (!decimalsCall.ok) {
+    return err({
+      kind: "chain-client",
+      stage: "read-token-decimals",
+      error: decimalsCall.error
+    });
+  }
+  if (decimalsCall.value.data === void 0) {
+    return err({ kind: "missing-token-decimals" });
+  }
+  const decimals = decodeErc20Decimals(decimalsCall.value.data);
+  if (!decimals.ok) return err({ kind: "token-decimals", error: decimals.error });
+  const amount = parseTokenAmount(input.amount, decimals.value);
+  if (!amount.ok) return err({ kind: "token-amount", error: amount.error });
+  const data = encodeErc20Transfer(input.recipient, amount.value);
+  const request = {
+    from: signer.address,
+    to: input.tokenAddress,
+    data,
+    value: 0n
+  };
+  const [nonce, gas, gasPrice] = await Promise.all([
+    client.getTransactionCount(signer.address),
+    client.estimateGas(request),
+    client.getGasPrice()
+  ]);
+  if (!nonce.ok) {
+    return err({
+      kind: "chain-client",
+      stage: "get-transaction-count",
+      error: nonce.error
+    });
+  }
+  if (!gas.ok) {
+    return err({ kind: "chain-client", stage: "estimate-gas", error: gas.error });
+  }
+  if (!gasPrice.ok) {
+    return err({
+      kind: "chain-client",
+      stage: "get-gas-price",
+      error: gasPrice.error
+    });
+  }
+  const transaction = {
+    type: "legacy",
+    chainId: client.config.chainId,
+    nonce: nonce.value,
+    gas: gas.value,
+    gasPrice: gasPrice.value,
+    to: input.tokenAddress,
+    value: 0n,
+    data
+  };
+  const unsignedTransaction = serializeUnsignedTransaction(transaction);
+  const preimage = hexToBytes(unsignedTransaction);
+  if (!preimage.ok) {
+    return err({
+      kind: "signing-failed",
+      message: "could not serialize the transaction signing preimage"
+    });
+  }
+  const signature = signer.sign(preimage.value);
+  if (!signature.ok) {
+    return err({ kind: "signing-failed", message: signature.error });
+  }
+  const signedTransaction = serializeSignedTransaction(
+    transaction,
+    signature.value
+  );
+  if (!signedTransaction.ok) {
+    return err({ kind: "invalid-signature", error: signedTransaction.error });
+  }
+  const transactionHash = await client.sendRawTransaction(
+    signedTransaction.value
+  );
+  if (!transactionHash.ok) {
+    return err({
+      kind: "chain-client",
+      stage: "broadcast",
+      error: transactionHash.error
+    });
+  }
+  return ok({
+    transactionHash: transactionHash.value,
+    from: signer.address,
+    amountBaseUnits: amount.value,
+    decimals: decimals.value
+  });
+}
+
+// src/ethereum/sendNativeEth.ts
+async function sendNativeEth(client, signer, input) {
+  const verified = await client.verifyChain();
+  if (!verified.ok) {
+    return err({ kind: "chain-client", stage: "verify-chain", error: verified.error });
+  }
+  const amount = parseTokenAmount(input.amount, 18);
+  if (!amount.ok) return err({ kind: "amount", error: amount.error });
+  const request = {
+    from: signer.address,
+    to: input.recipient,
+    value: amount.value
+  };
+  const [nonce, balance, gas, gasPrice] = await Promise.all([
+    client.getTransactionCount(signer.address),
+    client.getBalance(signer.address),
+    client.estimateGas(request),
+    client.getGasPrice()
+  ]);
+  if (!nonce.ok) {
+    return err({
+      kind: "chain-client",
+      stage: "get-transaction-count",
+      error: nonce.error
+    });
+  }
+  if (!balance.ok) {
+    return err({ kind: "chain-client", stage: "get-balance", error: balance.error });
+  }
+  if (!gas.ok) {
+    return err({ kind: "chain-client", stage: "estimate-gas", error: gas.error });
+  }
+  if (!gasPrice.ok) {
+    return err({
+      kind: "chain-client",
+      stage: "get-gas-price",
+      error: gasPrice.error
+    });
+  }
+  const feeWei = gas.value * gasPrice.value;
+  const requiredWei = amount.value + feeWei;
+  if (balance.value < requiredWei) {
+    return err({
+      kind: "insufficient-funds",
+      balanceWei: balance.value,
+      requiredWei
+    });
+  }
+  const transaction = {
+    type: "legacy",
+    chainId: client.config.chainId,
+    nonce: nonce.value,
+    gas: gas.value,
+    gasPrice: gasPrice.value,
+    to: input.recipient,
+    value: amount.value,
+    data: "0x"
+  };
+  const preimage = hexToBytes(serializeUnsignedTransaction(transaction));
+  if (!preimage.ok) {
+    return err({
+      kind: "signing-failed",
+      message: "could not serialize the transaction signing preimage"
+    });
+  }
+  const signature = signer.sign(preimage.value);
+  if (!signature.ok) {
+    return err({ kind: "signing-failed", message: signature.error });
+  }
+  const signed = serializeSignedTransaction(transaction, signature.value);
+  if (!signed.ok) {
+    return err({ kind: "invalid-signature", error: signed.error });
+  }
+  const transactionHash = await client.sendRawTransaction(signed.value);
+  if (!transactionHash.ok) {
+    return err({
+      kind: "chain-client",
+      stage: "broadcast",
+      error: transactionHash.error
+    });
+  }
+  return ok({
+    transactionHash: transactionHash.value,
+    from: signer.address,
+    amountWei: amount.value,
+    feeWei,
+    balanceWei: balance.value
+  });
+}
+
+// src/ethereum/createViemTransport.ts
+import {
+  createPublicClient,
+  defineChain,
+  http
+} from "viem";
+function createViemTransport(config, options = {}) {
+  const chain = defineChain({
+    id: config.chainId,
+    name: `Chain ${config.chainId}`,
+    nativeCurrency: { name: "Native Currency", symbol: "NATIVE", decimals: 18 },
+    rpcUrls: { default: { http: [config.rpcUrl] } }
+  });
+  const client = createPublicClient({
+    chain,
+    transport: http(config.rpcUrl, { fetchFn: options.fetchFn })
+  });
+  return {
+    async call(request) {
+      const response = await client.call(toViemCallParameters(request));
+      return { data: response.data };
+    },
+    async getChainId() {
+      return await client.getChainId();
+    },
+    async getTransactionCount(address) {
+      return await client.getTransactionCount({
+        address,
+        blockTag: "pending"
+      });
+    },
+    async getBalance(address) {
+      return await client.getBalance({
+        address,
+        blockTag: "pending"
+      });
+    },
+    async estimateGas(request) {
+      return await client.estimateGas({
+        account: request.from,
+        to: request.to,
+        data: request.data,
+        value: request.value
+      });
+    },
+    async getGasPrice() {
+      return await client.getGasPrice();
+    },
+    async sendRawTransaction(transaction) {
+      return await client.sendRawTransaction({
+        serializedTransaction: transaction
+      });
+    }
+  };
+}
+function toViemCallParameters(request) {
+  const block = typeof request.block === "bigint" ? { blockNumber: request.block } : typeof request.block === "string" ? { blockTag: request.block } : {};
+  const parameters = {
+    to: request.to,
+    data: request.data,
+    account: request.from,
+    gas: request.gas,
+    value: request.value,
+    ...block
+  };
+  return request.gasPrice === void 0 ? parameters : { ...parameters, type: "legacy", gasPrice: request.gasPrice };
+}
+
+// src/commands/ethereumWalletAddress.ts
+import { isAddress as isAddress3 } from "viem";
+function ethereumWalletAddress(client, derivationPath) {
+  const address = runWithWallet(client, (wallet) => {
+    const bootstrapped = wallet.bootstrap();
+    if (!bootstrapped.ok) return err(formatNativeError(bootstrapped.error));
+    const exported = wallet.exportAddress(derivationPath, "ethereum");
+    if (!exported.ok) return err(formatNativeError(exported.error));
+    return ok(exported.value);
+  });
+  if (!address.ok) return address;
+  if (!isAddress3(address.value)) {
+    return err("native wallet returned an invalid Ethereum address");
+  }
+  return ok(address.value);
+}
+
+// src/commands/formatEthereumClientError.ts
+function formatEthereumClientError(error) {
+  switch (error.kind) {
+    case "unsupported-transport":
+      return "configured Ethereum transport does not support transactions";
+    case "invalid-request":
+      return error.message;
+    case "transport-failed":
+      return messageFromUnknown3(error.cause);
+    case "invalid-response":
+      return error.message;
+    case "chain-mismatch":
+      return `RPC node reports chain ${error.actual}, expected ${error.expected}`;
+  }
+}
+function messageFromUnknown3(value) {
+  return value instanceof Error ? value.message : String(value);
+}
+
+// src/commands/resolveEthereumCommandRpcUrl.ts
+async function resolveEthereumCommandRpcUrl(env, chainId, explicitRpcUrl) {
+  if (explicitRpcUrl !== void 0) return ok(explicitRpcUrl);
+  const homeDirectory = env.HOME?.length ? env.HOME : void 0;
+  const loaded = await GlobalConfig.load({ homeDirectory });
+  if (!loaded.ok) return err(formatConfigLoadError(loaded.error));
+  const rpcUrl = resolveEthereumRpcUrl(loaded.value.data, chainId);
+  if (!rpcUrl.ok) {
+    const configPath = loaded.value.path;
+    return err(
+      rpcUrl.error.kind === "missing-chain-rpc" ? `no RPC configured for chain ${chainId} in ${configPath}; set ethereum.chains.${chainId}.rpcUrl or pass --rpc` : `invalid RPC configured for chain ${chainId} in ${configPath}`
+    );
+  }
+  return ok(rpcUrl.value);
+}
+function formatConfigLoadError(error) {
+  switch (error.kind) {
+    case "read-failed":
+      return `failed to read global config ${error.path}: ${messageFromUnknown4(error.cause)}`;
+    case "invalid-json":
+      return `invalid JSON in global config ${error.path}: ${error.message}`;
+    case "invalid-config":
+      return `invalid global config ${error.path}: ${error.message}`;
+  }
+}
+function messageFromUnknown4(value) {
+  return value instanceof Error ? value.message : String(value);
+}
+
+// src/commands/send.ts
+var sendCommand = {
+  name: "send",
+  describe() {
+    return "  macwlt send <amount> <token-address|ETH> <chain-id> <recipient> [--rpc <url>] [--path <derivation-path>] [--json]";
+  },
+  parse: parseSend,
+  async run(ctx, args) {
+    const rpcUrl = await resolveEthereumCommandRpcUrl(
+      ctx.env,
+      args.chainId,
+      args.rpcUrl
+    );
+    if (!rpcUrl.ok) return rpcUrl;
+    const ethereumClient = EthereumClient.create(
+      { rpcUrl: rpcUrl.value, chainId: args.chainId },
+      createViemTransport
+    );
+    if (!ethereumClient.ok) {
+      return err(`invalid Ethereum client configuration: ${ethereumClient.error.kind}`);
+    }
+    const signer = ethereumSigner(ctx, args.derivationPath);
+    if (!signer.ok) return signer;
+    if (args.asset.kind === "native-eth") {
+      const sent = await sendNativeEth(ethereumClient.value, signer.value, {
+        recipient: args.recipient,
+        amount: args.amount
+      });
+      if (!sent.ok) return err(formatNativeSendError(sent.error));
+      if (!args.json) return ok(sent.value.transactionHash);
+      return ok(JSON.stringify({
+        transactionHash: sent.value.transactionHash,
+        chainId: args.chainId,
+        asset: "ETH",
+        recipient: args.recipient,
+        from: sent.value.from,
+        amount: args.amount,
+        amountWei: sent.value.amountWei.toString(),
+        feeWei: sent.value.feeWei.toString()
+      }, null, 2));
+    } else {
+      const sent = await sendErc20Token(ethereumClient.value, signer.value, {
+        tokenAddress: args.asset.tokenAddress,
+        recipient: args.recipient,
+        amount: args.amount
+      });
+      if (!sent.ok) return err(formatSendError(sent.error));
+      if (!args.json) return ok(sent.value.transactionHash);
+      return ok(JSON.stringify({
+        transactionHash: sent.value.transactionHash,
+        chainId: args.chainId,
+        tokenAddress: args.asset.tokenAddress,
+        recipient: args.recipient,
+        from: sent.value.from,
+        amount: args.amount,
+        amountBaseUnits: sent.value.amountBaseUnits.toString(),
+        decimals: sent.value.decimals
+      }, null, 2));
+    }
+  }
+};
+function parseSend(args) {
+  const flags = parseFlags(args);
+  if (!flags.ok) return flags;
+  if (flags.value.positionals.length !== 4) {
+    return err(
+      "send requires <amount> <token-address> <chain-id> <recipient>"
+    );
+  }
+  if (flags.value.switches.size > 0) {
+    return err("send does not accept switch options");
+  }
+  for (const option of flags.value.options.keys()) {
+    if (option !== "rpc" && option !== "path") {
+      return err(`unknown send option: --${option}`);
+    }
+  }
+  const [amount, assetValue, chainIdValue, recipient] = flags.value.positionals;
+  if (!amount || !/^(?:0|[1-9]\d*)(?:\.\d+)?$/.test(amount)) {
+    return err("send amount must be a non-negative decimal number");
+  }
+  if (/^0(?:\.0+)?$/.test(amount)) {
+    return err("send amount must be greater than zero");
+  }
+  if (!assetValue) {
+    return err("send token-address must be ETH or a valid Ethereum address");
+  }
+  const asset = parseEthereumAsset(assetValue);
+  if (!asset.ok) {
+    return err("send token-address must be ETH or a valid Ethereum address");
+  }
+  if (!recipient || !isAddress4(recipient)) {
+    return err("send recipient must be a valid Ethereum address");
+  }
+  const chainId = Number(chainIdValue);
+  if (!Number.isSafeInteger(chainId) || chainId <= 0) {
+    return err("send chain-id must be a positive integer");
+  }
+  const rpcUrl = flags.value.options.get("rpc");
+  if (rpcUrl !== void 0) {
+    const config = parseEthereumConfig({ rpcUrl, chainId });
+    if (!config.ok) return err("send --rpc must be a valid HTTP(S) URL");
+  }
+  return ok({
+    amount,
+    asset: asset.value,
+    chainId,
+    recipient,
+    rpcUrl,
+    derivationPath: flags.value.options.get("path") ?? "m",
+    json: flags.value.json
+  });
+}
+function ethereumSigner(ctx, derivationPath) {
+  const address = ethereumWalletAddress(ctx.client, derivationPath);
+  if (!address.ok) return address;
+  return ok({
+    address: address.value,
+    sign(transaction) {
+      return runWithWallet(ctx.client, (wallet) => {
+        const bootstrapped = wallet.bootstrap();
+        if (!bootstrapped.ok) return err(formatNativeError(bootstrapped.error));
+        const signature = wallet.signEthereumTransaction(transaction);
+        if (!signature.ok) return err(formatNativeError(signature.error));
+        return ok(signature.value);
+      });
+    }
+  });
+}
+function formatSendError(error) {
+  switch (error.kind) {
+    case "chain-client":
+      return `${error.stage} failed: ${formatEthereumClientError(error.error)}`;
+    case "missing-token-decimals":
+      return "token decimals call returned no data";
+    case "token-decimals":
+      return `invalid token decimals response: ${error.error.message}`;
+    case "token-amount":
+      return error.error.kind === "zero-token-amount" ? "send amount must be greater than zero" : `send amount ${error.error.value} cannot be represented by this token`;
+    case "signing-failed":
+      return `transaction signing failed: ${error.message}`;
+    case "invalid-signature":
+      return error.error.kind === "invalid-signature-length" ? `native wallet returned a ${error.error.actual}-byte Ethereum signature; expected 65` : `native wallet returned invalid Ethereum recovery parity ${error.error.actual}`;
+  }
+}
+function formatNativeSendError(error) {
+  switch (error.kind) {
+    case "chain-client":
+      return `${error.stage} failed: ${formatEthereumClientError(error.error)}`;
+    case "amount":
+      return error.error.kind === "zero-token-amount" ? "send amount must be greater than zero" : "send ETH amount is invalid";
+    case "insufficient-funds":
+      return `insufficient ETH balance: have ${error.balanceWei} wei, require ${error.requiredWei} wei including gas`;
+    case "signing-failed":
+      return `transaction signing failed: ${error.message}`;
+    case "invalid-signature":
+      return error.error.kind === "invalid-signature-length" ? `native wallet returned a ${error.error.actual}-byte Ethereum signature; expected 65` : `native wallet returned invalid Ethereum recovery parity ${error.error.actual}`;
+  }
+}
+
+// src/commands/balance.ts
+var balanceCommand = {
+  name: "balance",
+  describe() {
+    return [
+      "  macwlt balance [--path <derivation-path>] [--json]",
+      "  macwlt balance <ETH|token-address> <chain-id> [--rpc <url>] [--path <derivation-path>] [--json]"
+    ].join("\n");
+  },
+  parse: parseBalance,
+  async run(ctx, args) {
+    switch (args.kind) {
+      case "portfolio":
+        return await runPortfolioBalance(ctx, args);
+      case "asset":
+        return await runAssetBalance(ctx, args);
+    }
+  }
+};
+function parseBalance(args) {
+  const flags = parseFlags(args);
+  if (!flags.ok) return flags;
+  if (flags.value.switches.size > 0) {
+    return err("balance does not accept switch options");
+  }
+  for (const option of flags.value.options.keys()) {
+    if (option !== "rpc" && option !== "path") {
+      return err(`unknown balance option: --${option}`);
+    }
+  }
+  const derivationPath = flags.value.options.get("path") ?? "m";
+  if (flags.value.positionals.length === 0) {
+    if (flags.value.options.has("rpc")) {
+      return err("balance --rpc requires <ETH|token-address> <chain-id>");
+    }
+    return ok({
+      kind: "portfolio",
+      derivationPath,
+      json: flags.value.json
+    });
+  }
+  if (flags.value.positionals.length !== 2) {
+    return err("balance accepts no positionals or requires <ETH|token-address> <chain-id>");
+  }
+  const [assetValue, chainIdValue] = flags.value.positionals;
+  if (!assetValue) {
+    return err("balance asset must be ETH or a valid Ethereum token address");
+  }
+  const asset = parseEthereumAsset(assetValue);
+  if (!asset.ok) {
+    return err("balance asset must be ETH or a valid Ethereum token address");
+  }
+  const chainId = Number(chainIdValue);
+  if (!Number.isSafeInteger(chainId) || chainId <= 0) {
+    return err("balance chain-id must be a positive integer");
+  }
+  const rpcUrl = flags.value.options.get("rpc");
+  if (rpcUrl !== void 0) {
+    const config = parseEthereumConfig({ rpcUrl, chainId });
+    if (!config.ok) return err("balance --rpc must be a valid HTTP(S) URL");
+  }
+  return ok({
+    kind: "asset",
+    asset: asset.value,
+    chainId,
+    rpcUrl,
+    derivationPath,
+    json: flags.value.json
+  });
+}
+async function runAssetBalance(ctx, args) {
+  const rpcUrl = await resolveEthereumCommandRpcUrl(
+    ctx.env,
+    args.chainId,
+    args.rpcUrl
+  );
+  if (!rpcUrl.ok) return rpcUrl;
+  const client = EthereumClient.create(
+    { rpcUrl: rpcUrl.value, chainId: args.chainId },
+    createViemTransport
+  );
+  if (!client.ok) {
+    return err(`invalid Ethereum client configuration: ${client.error.kind}`);
+  }
+  const address = ethereumWalletAddress(ctx.client, args.derivationPath);
+  if (!address.ok) return address;
+  const balance = await getEthereumAssetBalance(
+    client.value,
+    address.value,
+    args.asset
+  );
+  if (!balance.ok) return err(formatBalanceError(balance.error));
+  if (!args.json) {
+    return ok(
+      balance.value.kind === "native-eth" ? `${balance.value.balance} ETH` : balance.value.balance
+    );
+  }
+  if (balance.value.kind === "native-eth") {
+    return ok(JSON.stringify({
+      address: balance.value.address,
+      chainId: args.chainId,
+      asset: "ETH",
+      balance: balance.value.balance,
+      balanceWei: balance.value.balanceBaseUnits.toString(),
+      decimals: balance.value.decimals
+    }, null, 2));
+  }
+  return ok(JSON.stringify({
+    address: balance.value.address,
+    chainId: args.chainId,
+    tokenAddress: balance.value.tokenAddress,
+    balance: balance.value.balance,
+    balanceBaseUnits: balance.value.balanceBaseUnits.toString(),
+    decimals: balance.value.decimals
+  }, null, 2));
+}
+async function runPortfolioBalance(ctx, args) {
+  const homeDirectory = ctx.env.HOME?.length ? ctx.env.HOME : void 0;
+  const loaded = await GlobalConfig.load({
+    homeDirectory,
+    storage: ctx.configStorage
+  });
+  if (!loaded.ok) return err(formatConfigLoadError2(loaded.error));
+  const config = parseEthereumPortfolioConfig(loaded.value.data);
+  if (!config.ok) {
+    return err(`invalid EVM portfolio config ${loaded.value.path}: ${config.error.message}`);
+  }
+  if (config.value.length === 0) {
+    return err(`no EVM chains configured in ${loaded.value.path}`);
+  }
+  const address = ethereumWalletAddress(ctx.client, args.derivationPath);
+  if (!address.ok) return address;
+  const portfolio = await getEthereumPortfolioBalances(
+    config.value,
+    address.value,
+    createViemTransport
+  );
+  return ok(
+    args.json ? formatPortfolioJson(address.value, portfolio) : formatPortfolioText(address.value, portfolio)
+  );
+}
+function formatPortfolioJson(address, portfolio) {
+  return JSON.stringify({
+    address,
+    chains: portfolio.map((chain) => {
+      if (chain.status === "failed") {
+        return {
+          chainId: chain.chain.chainId,
+          name: chain.chain.name,
+          status: "failed",
+          error: formatClientCreationError(chain.error)
+        };
+      }
+      return {
+        chainId: chain.chain.chainId,
+        name: chain.chain.name,
+        status: "ok",
+        assets: chain.assets.filter(isHeldAsset).map(formatPortfolioAssetJson),
+        errors: chain.assets.filter(isFailedAsset).map((asset) => ({
+          symbol: asset.symbol,
+          kind: asset.asset.kind === "native-eth" ? "native" : "erc20",
+          ...asset.asset.kind === "erc20" ? { tokenAddress: asset.asset.tokenAddress } : {},
+          error: formatBalanceError(asset.error)
+        }))
+      };
+    })
+  }, null, 2);
+}
+function formatPortfolioText(address, portfolio) {
+  const lines = [`Wallet ${address}`];
+  let heldAssetCount = 0;
+  for (const chain of portfolio) {
+    if (chain.status === "failed") {
+      lines.push(
+        `${chain.chain.name} (${chain.chain.chainId}): unavailable: ${formatClientCreationError(chain.error)}`
+      );
+      continue;
+    }
+    const heldAssets = chain.assets.filter(isHeldAsset);
+    const failedAssets = chain.assets.filter(isFailedAsset);
+    if (heldAssets.length === 0 && failedAssets.length === 0) continue;
+    lines.push(`${chain.chain.name} (${chain.chain.chainId})`);
+    for (const asset of heldAssets) {
+      heldAssetCount++;
+      lines.push(`  ${asset.symbol}: ${asset.balance.balance}`);
+    }
+    for (const asset of failedAssets) {
+      lines.push(`  ${asset.symbol}: unavailable: ${formatBalanceError(asset.error)}`);
+    }
+  }
+  if (heldAssetCount === 0) lines.push("No configured assets held.");
+  return lines.join("\n");
+}
+function formatPortfolioAssetJson(asset) {
+  const balance = asset.balance;
+  return {
+    symbol: asset.symbol,
+    kind: balance.kind === "native-eth" ? "native" : "erc20",
+    ...balance.kind === "erc20" ? { tokenAddress: balance.tokenAddress } : {},
+    balance: balance.balance,
+    balanceBaseUnits: balance.balanceBaseUnits.toString(),
+    decimals: balance.decimals
+  };
+}
+function isHeldAsset(asset) {
+  return asset.status === "fulfilled" && asset.balance.balanceBaseUnits > 0n;
+}
+function isFailedAsset(asset) {
+  return asset.status === "failed";
+}
+function formatBalanceError(error) {
+  switch (error.kind) {
+    case "chain-client":
+      return `${error.stage} failed: ${formatEthereumClientError(error.error)}`;
+    case "missing-token-balance":
+      return "token balance call returned no data";
+    case "missing-token-decimals":
+      return "token decimals call returned no data";
+    case "token-balance":
+      return `invalid token balance response: ${error.error.message}`;
+    case "token-decimals":
+      return `invalid token decimals response: ${error.error.message}`;
+  }
+}
+function formatClientCreationError(error) {
+  switch (error.kind) {
+    case "invalid-rpc-url":
+      return `invalid RPC URL ${error.value}`;
+    case "invalid-chain-id":
+      return `invalid chain ID ${error.value}`;
+    case "transport-creation-failed":
+      return messageFromUnknown5(error.cause);
+  }
+}
+function formatConfigLoadError2(error) {
+  switch (error.kind) {
+    case "read-failed":
+      return `failed to read global config ${error.path}: ${messageFromUnknown5(error.cause)}`;
+    case "invalid-json":
+      return `invalid JSON in global config ${error.path}: ${error.message}`;
+    case "invalid-config":
+      return `invalid global config ${error.path}: ${error.message}`;
+  }
+}
+function messageFromUnknown5(value) {
+  return value instanceof Error ? value.message : String(value);
+}
+
+// src/commands.ts
+var commands = [
+  createCommand,
+  resetCommand,
+  resetConfigCommand,
+  pubkeyCommand,
+  addressCommand,
+  balanceCommand,
+  signEthCommand,
+  signPsbtCommand,
+  sendCommand,
+  helpCommand,
+  versionCommand
+];
+
+// src/command.ts
+function parsedEnv(value) {
+  return value;
+}
+var cliInputSchema = z8.object({
+  args: z8.array(z8.string()),
+  env: z8.object({
+    HOME: z8.string().optional(),
+    MACWLT_LIB: z8.string().optional()
+  }).passthrough()
+});
+var cliVersion = "0.1.0";
+async function runCli(args, env = process.env, registry = commands, options = {}) {
+  const input = cliInputSchema.safeParse({ args: [...args], env });
+  if (!input.success) return failure("invalid process input");
+  const processEnv = parsedEnv(input.data.env);
+  const configStorage = options.configStorage ?? fileConfigStorage;
+  const initialized = await ensureGlobalConfig({
+    homeDirectory: processEnv.HOME?.length ? processEnv.HOME : void 0,
+    createFile: options.createConfigFile
+  });
+  if (!initialized.ok) {
+    return failure(
+      `failed to initialize config ${initialized.error.path}: ${messageFromUnknown6(initialized.error.cause)}`
+    );
+  }
+  const [name, ...rest] = input.data.args;
+  if (!name) return success(helpText(registry));
+  const command = registry.find((c) => c.name === name || c.aliases?.includes(name));
+  if (!command) return failure(`unknown command: ${name}
+
+${helpText(registry)}`);
+  const parsed = command.parse(rest);
+  if (!parsed.ok) return failure(parsed.error);
+  if (command.needsClient === false) {
+    const ctx = {
+      env: processEnv,
+      client: neverClient(),
+      registry,
+      configStorage
+    };
+    return await runCommand(command, ctx, parsed.value);
+  }
+  const clientResult = openNativeClient(defaultLibraryPath(input.data.env.MACWLT_LIB));
+  if (!clientResult.ok) return failure(formatNativeError(clientResult.error));
+  const client = clientResult.value;
+  try {
+    const ctx = {
+      env: processEnv,
+      client,
+      registry,
+      configStorage
+    };
+    return await runCommand(command, ctx, parsed.value);
+  } finally {
+    client.close();
+  }
+}
+async function runCommand(command, ctx, parsed) {
+  if (command.beforeRun !== void 0) {
+    const beforeRun = await command.beforeRun();
+    if (!beforeRun.ok) return failure(beforeRun.error);
+  }
+  const result = await command.run(ctx, parsed);
+  if (!result.ok) return failure(result.error);
+  return success(result.value);
+}
+function helpText(registry) {
+  return [
+    "Usage:",
+    ...registry.map((c) => c.describe()).filter((line) => line.length > 0),
+    "",
+    "Environment:",
+    "  MACWLT_LIB  Override the bundled or checkout libmacwlt.dylib path"
+  ].join("\n");
+}
+function neverClient() {
+  return {
+    libraryPath: "",
+    close: () => {
+    },
+    withWallet: (_body) => err({ kind: "missing-library", libraryPath: "" })
+  };
+}
+function success(stdout) {
+  return { exitCode: 0, stdout: `${stdout}
+`, stderr: "" };
+}
+function failure(stderr) {
+  return { exitCode: 1, stdout: "", stderr: `${stderr}
+` };
+}
+function messageFromUnknown6(value) {
+  return value instanceof Error ? value.message : String(value);
+}
+export {
+  EthereumClient,
+  GlobalConfig,
+  base64ToBytes,
+  bytesToBase64,
+  bytesToHex,
+  cliVersion,
+  commands,
+  createConfirmationHook,
+  createFileIfAbsent,
+  createViemTransport,
+  decodeErc20Balance,
+  decodeErc20Decimals,
+  defaultGlobalConfigContents,
+  defaultLibraryPath,
+  encodeErc20BalanceOf,
+  encodeErc20DecimalsCall,
+  encodeErc20Transfer,
+  ensureGlobalConfig,
+  err,
+  fileConfigStorage,
+  formatDataOutput,
+  formatExecutionError,
+  formatNativeError,
+  formatPsbt,
+  getEthereumAssetBalance,
+  getEthereumPortfolioBalances,
+  globalConfigPath,
+  helpText,
+  hexToBytes,
+  ok,
+  openNativeClient,
+  parseBytesInput,
+  parseEthereumAsset,
+  parseEthereumConfig,
+  parseEthereumPortfolioConfig,
+  parseEvmCallRequest,
+  parseEvmCallResult,
+  parseFlags,
+  parseGlobalConfigData,
+  parseJsonValue,
+  parseTokenAmount,
+  readInput,
+  resetGlobalConfig,
+  resolveEthereumRpcUrl,
+  runCli,
+  runWithWallet,
+  sendErc20Token,
+  sendNativeEth,
+  serializeSignedTransaction,
+  serializeUnsignedTransaction,
+  terminalConfirmationPrompt
+};
+//# sourceMappingURL=index.js.map