@siphoyawe/mina-cli 1.0.0

package/dist/index.js

@@ -0,0 +1,3229 @@
+#!/usr/bin/env node
+
+// src/index.tsx
+import { Command } from "commander";
+import chalk from "chalk";
+import React11 from "react";
+import { render } from "ink";
+
+// src/commands/wizard.tsx
+import { useState, useEffect, useCallback } from "react";
+import { Box as Box7, Text as Text7, useApp, useInput } from "ink";
+import {
+  getChains,
+  getBridgeableTokens,
+  HYPEREVM_CHAIN_ID
+} from "@siphoyawe/mina-sdk";
+
+// src/ui/theme.ts
+var theme = {
+  // Primary colors
+  primary: "#7DD3FC",
+  // Sky blue - main accent
+  secondary: "#A1A1AA",
+  // Gray - supporting text
+  muted: "#71717A",
+  // Dark gray - disabled/placeholder
+  // Status colors
+  success: "#0ECC83",
+  // Green - completed/success
+  error: "#F87171",
+  // Red - error/failed
+  warning: "#FBBF24",
+  // Yellow - warning/pending
+  // UI elements
+  border: "#3F3F46",
+  // Border gray
+  background: "#18181B",
+  // Dark background
+  // Additional colors for variety
+  accent: "#E879F9",
+  // Purple accent
+  info: "#38BDF8"
+  // Light blue info
+};
+var borders = {
+  // Single line box
+  topLeft: "\u250C",
+  topRight: "\u2510",
+  bottomLeft: "\u2514",
+  bottomRight: "\u2518",
+  horizontal: "\u2500",
+  vertical: "\u2502",
+  // Junctions
+  leftT: "\u251C",
+  rightT: "\u2524",
+  topT: "\u252C",
+  bottomT: "\u2534",
+  cross: "\u253C",
+  // Double line (for emphasis)
+  doubleHorizontal: "\u2550",
+  doubleVertical: "\u2551",
+  doubleTopLeft: "\u2554",
+  doubleTopRight: "\u2557",
+  doubleBottomLeft: "\u255A",
+  doubleBottomRight: "\u255D"
+};
+var symbols = {
+  pending: "\u25CB",
+  active: "\u2192",
+  completed: "\u2713",
+  failed: "\u2717",
+  spinner: "\u25D0",
+  bullet: "\u2022",
+  arrow: "\u203A",
+  check: "\u2714",
+  cross: "\u2718"
+};
+var MINA_LOGO = `
+  __  __ ___ _   _    _
+ |  \\/  |_ _| \\ | |  / \\
+ | |\\/| || ||  \\| | / _ \\
+ | |  | || || |\\  |/ ___ \\
+ |_|  |_|___|_| \\_/_/   \\_\\
+`;
+var TAGLINE = "Cross-chain bridge to Hyperliquid";
+
+// src/ui/Box.tsx
+import { Box as InkBox, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function Box({
+  title,
+  borderColor = theme.border,
+  bordered = true,
+  padding = 1,
+  children,
+  ...props
+}) {
+  if (!bordered) {
+    return /* @__PURE__ */ jsx(InkBox, { padding, ...props, children });
+  }
+  return /* @__PURE__ */ jsxs(
+    InkBox,
+    {
+      flexDirection: "column",
+      borderStyle: "round",
+      borderColor,
+      paddingX: padding,
+      paddingY: padding > 0 ? 1 : 0,
+      ...props,
+      children: [
+        title && /* @__PURE__ */ jsx(InkBox, { marginBottom: 1, children: /* @__PURE__ */ jsx(Text, { color: theme.primary, bold: true, children: title }) }),
+        children
+      ]
+    }
+  );
+}
+function Divider({
+  width = 40,
+  color = theme.border,
+  char = borders.horizontal
+}) {
+  return /* @__PURE__ */ jsx(Text, { color, children: char.repeat(width) });
+}
+
+// src/ui/Header.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function Header({
+  showTagline = true,
+  tagline = TAGLINE,
+  compact = false
+}) {
+  if (compact) {
+    return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx2(Text2, { color: theme.primary, bold: true, children: "MINA" }),
+      showTagline && /* @__PURE__ */ jsx2(Text2, { color: theme.secondary, dimColor: true, children: tagline })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx2(Text2, { color: theme.primary, bold: true, children: MINA_LOGO }),
+    showTagline && /* @__PURE__ */ jsx2(Box2, { justifyContent: "center", children: /* @__PURE__ */ jsx2(Text2, { color: theme.secondary, dimColor: true, children: tagline }) })
+  ] });
+}
+
+// src/ui/Select.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import InkSelectInput from "ink-select-input";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function Select({
+  items,
+  onSelect,
+  onHighlight,
+  initialIndex = 0,
+  disabled = false,
+  label,
+  limit
+}) {
+  const inkItems = items.map((item) => ({
+    label: item.label,
+    value: item
+  }));
+  const handleSelect = (item) => {
+    if (!item.value.disabled) {
+      onSelect(item.value);
+    }
+  };
+  const handleHighlight = (item) => {
+    onHighlight?.(item.value);
+  };
+  const itemComponent = ({ isSelected, label: label2 }) => {
+    const item = items.find((i) => i.label === label2);
+    const isDisabled = item?.disabled;
+    return /* @__PURE__ */ jsxs3(Box3, { children: [
+      /* @__PURE__ */ jsxs3(Text3, { color: isSelected ? theme.primary : isDisabled ? theme.muted : theme.secondary, children: [
+        isSelected ? symbols.arrow : " ",
+        " ",
+        label2
+      ] }),
+      item?.description && /* @__PURE__ */ jsxs3(Text3, { color: theme.muted, dimColor: true, children: [
+        " ",
+        "\u2014 ",
+        item.description
+      ] })
+    ] });
+  };
+  const indicatorComponent = ({ isSelected }) => /* @__PURE__ */ jsx3(Text3, { color: theme.primary, children: isSelected ? symbols.arrow : " " });
+  if (disabled) {
+    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+      label && /* @__PURE__ */ jsx3(Text3, { color: theme.muted, dimColor: true, children: label }),
+      /* @__PURE__ */ jsx3(Text3, { color: theme.muted, dimColor: true, children: "(disabled)" })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    label && /* @__PURE__ */ jsx3(Box3, { marginBottom: 1, children: /* @__PURE__ */ jsx3(Text3, { color: theme.secondary, children: label }) }),
+    /* @__PURE__ */ jsx3(
+      InkSelectInput,
+      {
+        items: inkItems,
+        onSelect: handleSelect,
+        onHighlight: handleHighlight,
+        initialIndex,
+        itemComponent,
+        indicatorComponent,
+        limit
+      }
+    )
+  ] });
+}
+function ChainSelect({
+  chains,
+  onSelect,
+  label = "Select Chain:"
+}) {
+  return /* @__PURE__ */ jsx3(
+    Select,
+    {
+      items: chains,
+      onSelect: (item) => onSelect(item),
+      label
+    }
+  );
+}
+function TokenSelect({
+  tokens,
+  onSelect,
+  label = "Select Token:"
+}) {
+  return /* @__PURE__ */ jsx3(
+    Select,
+    {
+      items: tokens,
+      onSelect: (item) => onSelect(item),
+      label
+    }
+  );
+}
+
+// src/ui/ProgressSteps.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import InkSpinner from "ink-spinner";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function getStatusIndicator(status) {
+  switch (status) {
+    case "pending":
+      return /* @__PURE__ */ jsx4(Text4, { color: theme.muted, children: symbols.pending });
+    case "active":
+      return /* @__PURE__ */ jsx4(Text4, { color: theme.primary, children: /* @__PURE__ */ jsx4(InkSpinner, { type: "dots" }) });
+    case "completed":
+      return /* @__PURE__ */ jsx4(Text4, { color: theme.success, children: symbols.completed });
+    case "failed":
+      return /* @__PURE__ */ jsx4(Text4, { color: theme.error, children: symbols.failed });
+  }
+}
+function getStatusColor(status) {
+  switch (status) {
+    case "pending":
+      return theme.muted;
+    case "active":
+      return theme.primary;
+    case "completed":
+      return theme.success;
+    case "failed":
+      return theme.error;
+  }
+}
+function StepItem({
+  step,
+  index,
+  showNumber,
+  showTimestamp,
+  isLast
+}) {
+  const color = getStatusColor(step.status);
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs4(Box4, { children: [
+      /* @__PURE__ */ jsx4(Box4, { width: 3, children: getStatusIndicator(step.status) }),
+      showNumber && /* @__PURE__ */ jsx4(Box4, { width: 4, children: /* @__PURE__ */ jsxs4(Text4, { color, dimColor: step.status === "pending", children: [
+        index + 1,
+        "."
+      ] }) }),
+      /* @__PURE__ */ jsx4(Box4, { flexGrow: 1, children: /* @__PURE__ */ jsx4(
+        Text4,
+        {
+          color,
+          bold: step.status === "active",
+          dimColor: step.status === "pending",
+          children: step.label
+        }
+      ) }),
+      showTimestamp && step.timestamp && /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, children: /* @__PURE__ */ jsx4(Text4, { color: theme.muted, dimColor: true, children: step.timestamp }) })
+    ] }),
+    step.description && /* @__PURE__ */ jsx4(Box4, { marginLeft: showNumber ? 7 : 3, children: /* @__PURE__ */ jsx4(Text4, { color: theme.muted, dimColor: true, children: step.description }) }),
+    !isLast && step.status !== "pending" && /* @__PURE__ */ jsx4(Box4, { marginLeft: 1, children: /* @__PURE__ */ jsx4(Text4, { color: theme.border, children: "\u2502" }) })
+  ] });
+}
+function ProgressSteps({
+  steps,
+  showNumbers = true,
+  showTimestamps = false,
+  title
+}) {
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    title && /* @__PURE__ */ jsx4(Box4, { marginBottom: 1, children: /* @__PURE__ */ jsx4(Text4, { color: theme.secondary, bold: true, children: title }) }),
+    steps.map((step, index) => /* @__PURE__ */ jsx4(
+      StepItem,
+      {
+        step,
+        index,
+        showNumber: showNumbers,
+        showTimestamp: showTimestamps,
+        isLast: index === steps.length - 1
+      },
+      index
+    ))
+  ] });
+}
+
+// src/ui/Spinner.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import InkSpinner2 from "ink-spinner";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function Spinner({
+  text,
+  type = "dots",
+  color = theme.primary,
+  textColor = theme.secondary,
+  rightAlign = false
+}) {
+  const spinnerElement = /* @__PURE__ */ jsx5(Text5, { color, children: /* @__PURE__ */ jsx5(InkSpinner2, { type }) });
+  if (!text) {
+    return spinnerElement;
+  }
+  return /* @__PURE__ */ jsxs5(Box5, { children: [
+    !rightAlign && spinnerElement,
+    /* @__PURE__ */ jsxs5(Text5, { color: textColor, children: [
+      rightAlign ? "" : " ",
+      text,
+      rightAlign ? " " : ""
+    ] }),
+    rightAlign && spinnerElement
+  ] });
+}
+
+// src/ui/Table.tsx
+import React from "react";
+import { Box as Box6, Text as Text6 } from "ink";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function getCellValue(row, accessor) {
+  if (typeof accessor === "function") {
+    return String(accessor(row));
+  }
+  return String(row[accessor] ?? "");
+}
+function calculateColumnWidths(data, columns, maxWidth) {
+  const widths = columns.map((col) => {
+    const headerWidth = col.header.length;
+    const dataWidths = data.map((row) => getCellValue(row, col.accessor).length);
+    const maxContentWidth = Math.max(headerWidth, ...dataWidths);
+    return col.width ?? Math.min(maxContentWidth, 30);
+  });
+  if (maxWidth) {
+    const totalWidth = widths.reduce((a, b) => a + b, 0) + columns.length * 3 + 1;
+    if (totalWidth > maxWidth) {
+      const scale = maxWidth / totalWidth;
+      return widths.map((w) => Math.floor(w * scale));
+    }
+  }
+  return widths;
+}
+function padText(text, width, align = "left") {
+  const truncated = text.length > width ? text.slice(0, width - 1) + "\u2026" : text;
+  const padding = width - truncated.length;
+  switch (align) {
+    case "right":
+      return " ".repeat(padding) + truncated;
+    case "center":
+      const leftPad = Math.floor(padding / 2);
+      const rightPad = padding - leftPad;
+      return " ".repeat(leftPad) + truncated + " ".repeat(rightPad);
+    default:
+      return truncated + " ".repeat(padding);
+  }
+}
+function BorderLine({
+  widths,
+  position,
+  color
+}) {
+  const chars = {
+    top: { left: borders.topLeft, right: borders.topRight, junction: borders.topT },
+    middle: { left: borders.leftT, right: borders.rightT, junction: borders.cross },
+    bottom: { left: borders.bottomLeft, right: borders.bottomRight, junction: borders.bottomT }
+  };
+  const { left, right, junction } = chars[position];
+  const segments = widths.map((w) => borders.horizontal.repeat(w + 2));
+  const line = left + segments.join(junction) + right;
+  return /* @__PURE__ */ jsx6(Text6, { color, children: line });
+}
+function TableRow({
+  row,
+  columns,
+  widths,
+  bordered,
+  borderColor,
+  isEven,
+  striped
+}) {
+  return /* @__PURE__ */ jsxs6(Box6, { children: [
+    bordered && /* @__PURE__ */ jsx6(Text6, { color: borderColor, children: borders.vertical }),
+    columns.map((col, i) => {
+      const value = getCellValue(row, col.accessor);
+      const colWidth = widths[i] ?? col.header.length;
+      const paddedValue = padText(value, colWidth, col.align);
+      let cellColor = theme.secondary;
+      if (col.cellColor) {
+        cellColor = typeof col.cellColor === "function" ? col.cellColor(value, row) : col.cellColor;
+      }
+      return /* @__PURE__ */ jsxs6(React.Fragment, { children: [
+        /* @__PURE__ */ jsx6(Text6, { children: " " }),
+        /* @__PURE__ */ jsx6(Text6, { color: cellColor, dimColor: striped && isEven, children: paddedValue }),
+        /* @__PURE__ */ jsx6(Text6, { children: " " }),
+        bordered && /* @__PURE__ */ jsx6(Text6, { color: borderColor, children: borders.vertical })
+      ] }, i);
+    })
+  ] });
+}
+function Table({
+  data,
+  columns,
+  bordered = true,
+  borderColor = theme.border,
+  headerBold = true,
+  striped = false,
+  maxWidth
+}) {
+  const widths = calculateColumnWidths(data, columns, maxWidth);
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+    bordered && /* @__PURE__ */ jsx6(BorderLine, { widths, position: "top", color: borderColor }),
+    /* @__PURE__ */ jsxs6(Box6, { children: [
+      bordered && /* @__PURE__ */ jsx6(Text6, { color: borderColor, children: borders.vertical }),
+      columns.map((col, i) => {
+        const colWidth = widths[i] ?? col.header.length;
+        return /* @__PURE__ */ jsxs6(React.Fragment, { children: [
+          /* @__PURE__ */ jsx6(Text6, { children: " " }),
+          /* @__PURE__ */ jsx6(Text6, { color: col.headerColor ?? theme.primary, bold: headerBold, children: padText(col.header, colWidth, col.align) }),
+          /* @__PURE__ */ jsx6(Text6, { children: " " }),
+          bordered && /* @__PURE__ */ jsx6(Text6, { color: borderColor, children: borders.vertical })
+        ] }, i);
+      })
+    ] }),
+    bordered && /* @__PURE__ */ jsx6(BorderLine, { widths, position: "middle", color: borderColor }),
+    data.map((row, rowIndex) => /* @__PURE__ */ jsx6(
+      TableRow,
+      {
+        row,
+        columns,
+        widths,
+        bordered,
+        borderColor,
+        isEven: rowIndex % 2 === 0,
+        striped
+      },
+      rowIndex
+    )),
+    bordered && /* @__PURE__ */ jsx6(BorderLine, { widths, position: "bottom", color: borderColor })
+  ] });
+}
+function KeyValue({
+  items,
+  keyColor = theme.muted,
+  valueColor = theme.secondary,
+  separator = ":"
+}) {
+  const maxKeyWidth = Math.max(...items.map((item) => item.key.length));
+  return /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", children: items.map((item, index) => /* @__PURE__ */ jsxs6(Box6, { children: [
+    /* @__PURE__ */ jsx6(Text6, { color: keyColor, children: item.key.padEnd(maxKeyWidth) }),
+    /* @__PURE__ */ jsxs6(Text6, { color: theme.muted, children: [
+      " ",
+      separator,
+      " "
+    ] }),
+    /* @__PURE__ */ jsx6(Text6, { color: valueColor, children: item.value })
+  ] }, index)) });
+}
+
+// src/commands/wizard.tsx
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+var initialState = {
+  step: "chain",
+  chain: null,
+  token: null,
+  amount: "",
+  quote: null,
+  error: null
+};
+function NavigationHints({ step }) {
+  const hints = {
+    chain: "up/down Select  Enter Confirm  q Quit",
+    token: "up/down Select  Enter Confirm  b Back  q Quit",
+    amount: "Enter Confirm  b Back  q Quit",
+    confirm: "Enter Execute  b Back  q Quit",
+    execute: "Please wait..."
+  };
+  return /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx7(Text7, { color: theme.muted, dimColor: true, children: hints[step] }) });
+}
+function StepIndicator({ currentStep }) {
+  const steps = ["chain", "token", "amount", "confirm", "execute"];
+  const stepLabels = {
+    chain: "Chain",
+    token: "Token",
+    amount: "Amount",
+    confirm: "Confirm",
+    execute: "Execute"
+  };
+  const currentIndex = steps.indexOf(currentStep);
+  return /* @__PURE__ */ jsx7(Box7, { marginBottom: 1, children: steps.map((step, index) => {
+    const isActive = index === currentIndex;
+    const isCompleted = index < currentIndex;
+    const separator = index < steps.length - 1 ? " > " : "";
+    return /* @__PURE__ */ jsxs7(Text7, { children: [
+      /* @__PURE__ */ jsxs7(
+        Text7,
+        {
+          color: isActive ? theme.primary : isCompleted ? theme.success : theme.muted,
+          bold: isActive,
+          dimColor: !isActive && !isCompleted,
+          children: [
+            isCompleted ? symbols.check : isActive ? symbols.arrow : symbols.pending,
+            " ",
+            stepLabels[step]
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx7(Text7, { color: theme.muted, dimColor: true, children: separator })
+    ] }, step);
+  }) });
+}
+function ChainSelectionStep({
+  onSelect,
+  selectedChain
+}) {
+  const [chains, setChains] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    async function loadChains() {
+      try {
+        setLoading(true);
+        setError(null);
+        const response = await getChains();
+        const originChains = response.chains.filter((c) => c.id !== HYPEREVM_CHAIN_ID);
+        setChains(originChains);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Failed to load chains");
+      } finally {
+        setLoading(false);
+      }
+    }
+    loadChains();
+  }, []);
+  if (loading) {
+    return /* @__PURE__ */ jsx7(Spinner, { text: "Loading available chains..." });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs7(Text7, { color: theme.error, children: [
+        symbols.failed,
+        " Error: ",
+        error
+      ] }),
+      /* @__PURE__ */ jsx7(Text7, { color: theme.muted, children: "Press q to quit and try again" })
+    ] });
+  }
+  const chainItems = chains.map((chain) => ({
+    label: chain.name,
+    value: chain.id,
+    chainId: chain.id,
+    type: "origin",
+    description: `Chain ID: ${chain.id}`
+  }));
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx7(Box7, { marginBottom: 1, children: /* @__PURE__ */ jsx7(Text7, { color: theme.secondary, bold: true, children: "Select source chain to bridge from:" }) }),
+    /* @__PURE__ */ jsx7(
+      ChainSelect,
+      {
+        chains: chainItems,
+        onSelect: (item) => {
+          const chain = chains.find((c) => c.id === item.chainId);
+          if (chain) onSelect(chain);
+        },
+        label: ""
+      }
+    ),
+    /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsxs7(Text7, { color: theme.muted, dimColor: true, children: [
+      "Destination: HyperEVM (Chain ID: ",
+      HYPEREVM_CHAIN_ID,
+      ")"
+    ] }) })
+  ] });
+}
+function TokenSelectionStep({
+  chain,
+  onSelect,
+  selectedToken
+}) {
+  const [tokens, setTokens] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    async function loadTokens() {
+      try {
+        setLoading(true);
+        setError(null);
+        const response = await getBridgeableTokens(chain.id);
+        setTokens(response.tokens);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Failed to load tokens");
+      } finally {
+        setLoading(false);
+      }
+    }
+    loadTokens();
+  }, [chain.id]);
+  if (loading) {
+    return /* @__PURE__ */ jsx7(Spinner, { text: `Loading bridgeable tokens for ${chain.name}...` });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs7(Text7, { color: theme.error, children: [
+        symbols.failed,
+        " Error: ",
+        error
+      ] }),
+      /* @__PURE__ */ jsx7(Text7, { color: theme.muted, children: "Press b to go back or q to quit" })
+    ] });
+  }
+  if (tokens.length === 0) {
+    return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs7(Text7, { color: theme.warning, children: [
+        symbols.pending,
+        " No bridgeable tokens found for ",
+        chain.name
+      ] }),
+      /* @__PURE__ */ jsx7(Text7, { color: theme.muted, children: "Press b to go back and select another chain" })
+    ] });
+  }
+  const tokenItems = tokens.map((token) => ({
+    label: token.symbol,
+    value: token.address,
+    symbol: token.symbol,
+    description: token.name
+  }));
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx7(Box7, { marginBottom: 1, children: /* @__PURE__ */ jsxs7(Text7, { color: theme.secondary, bold: true, children: [
+      "Select token to bridge from ",
+      chain.name,
+      ":"
+    ] }) }),
+    /* @__PURE__ */ jsx7(
+      TokenSelect,
+      {
+        tokens: tokenItems,
+        onSelect: (item) => {
+          const token = tokens.find((t) => t.address === item.value);
+          if (token) onSelect(token);
+        },
+        label: ""
+      }
+    )
+  ] });
+}
+function AmountInputStep({
+  token,
+  chain,
+  amount,
+  onAmountChange,
+  onConfirm,
+  error
+}) {
+  const [cursorVisible, setCursorVisible] = useState(true);
+  useEffect(() => {
+    const interval = setInterval(() => {
+      setCursorVisible((v) => !v);
+    }, 530);
+    return () => clearInterval(interval);
+  }, []);
+  useInput((input, key) => {
+    if (key.return && amount.length > 0) {
+      onConfirm();
+      return;
+    }
+    if (key.backspace || key.delete) {
+      onAmountChange(amount.slice(0, -1));
+      return;
+    }
+    if (/^[0-9.]$/.test(input)) {
+      if (input === "." && amount.includes(".")) return;
+      if (input === "0" && amount === "0") return;
+      onAmountChange(amount + input);
+    }
+  });
+  const cursor = cursorVisible ? "|" : " ";
+  const displayAmount = amount || "0";
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx7(Box7, { marginBottom: 1, children: /* @__PURE__ */ jsxs7(Text7, { color: theme.secondary, bold: true, children: [
+      "Enter amount of ",
+      token.symbol,
+      " to bridge:"
+    ] }) }),
+    /* @__PURE__ */ jsx7(Box, { bordered: true, padding: 1, children: /* @__PURE__ */ jsxs7(Box7, { children: [
+      /* @__PURE__ */ jsx7(Text7, { color: theme.primary, bold: true, children: displayAmount }),
+      /* @__PURE__ */ jsx7(Text7, { color: theme.primary, children: cursor }),
+      /* @__PURE__ */ jsxs7(Text7, { color: theme.muted, children: [
+        " ",
+        token.symbol
+      ] })
+    ] }) }),
+    error && /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsxs7(Text7, { color: theme.error, children: [
+      symbols.failed,
+      " ",
+      error
+    ] }) }),
+    /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsxs7(Text7, { color: theme.muted, dimColor: true, children: [
+      "From: ",
+      chain.name,
+      " (",
+      token.symbol,
+      ")"
+    ] }) }),
+    /* @__PURE__ */ jsx7(Box7, { children: /* @__PURE__ */ jsx7(Text7, { color: theme.muted, dimColor: true, children: "To: HyperEVM (USDC)" }) })
+  ] });
+}
+function ConfirmationStep({
+  chain,
+  token,
+  amount,
+  onConfirm
+}) {
+  useInput((_input, key) => {
+    if (key.return) {
+      onConfirm();
+    }
+  });
+  const estimatedFees = "$1.50 - $3.00";
+  const estimatedTime = "2-5 minutes";
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx7(Box7, { marginBottom: 1, children: /* @__PURE__ */ jsx7(Text7, { color: theme.secondary, bold: true, children: "Review your bridge transaction:" }) }),
+    /* @__PURE__ */ jsxs7(Box, { bordered: true, title: "Transaction Summary", padding: 1, children: [
+      /* @__PURE__ */ jsx7(
+        KeyValue,
+        {
+          items: [
+            { key: "From Chain", value: chain.name },
+            { key: "Token", value: token.symbol },
+            { key: "Amount", value: `${amount} ${token.symbol}` },
+            { key: "To Chain", value: "HyperEVM" },
+            { key: "Receive", value: "USDC" }
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsx7(Box7, { marginTop: 1, marginBottom: 1, children: /* @__PURE__ */ jsx7(Divider, { width: 40 }) }),
+      /* @__PURE__ */ jsx7(
+        KeyValue,
+        {
+          items: [
+            { key: "Est. Fees", value: estimatedFees },
+            { key: "Est. Time", value: estimatedTime }
+          ],
+          keyColor: theme.muted,
+          valueColor: theme.warning
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsxs7(Text7, { color: theme.success, bold: true, children: [
+      symbols.arrow,
+      " Press Enter to execute the bridge"
+    ] }) }),
+    /* @__PURE__ */ jsx7(Box7, { children: /* @__PURE__ */ jsx7(Text7, { color: theme.muted, dimColor: true, children: "Press b to go back and edit" }) })
+  ] });
+}
+function ExecutionStep({
+  chain,
+  token,
+  amount
+}) {
+  const [currentStep, setCurrentStep] = useState(0);
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setCurrentStep((prev) => {
+        if (prev >= 4) {
+          clearInterval(timer);
+          return prev;
+        }
+        return prev + 1;
+      });
+    }, 2e3);
+    return () => clearInterval(timer);
+  }, []);
+  const steps = [
+    {
+      label: "Connecting wallet",
+      status: currentStep > 0 ? "completed" : currentStep === 0 ? "active" : "pending"
+    },
+    {
+      label: "Fetching quote",
+      status: currentStep > 1 ? "completed" : currentStep === 1 ? "active" : "pending"
+    },
+    {
+      label: "Approving token",
+      status: currentStep > 2 ? "completed" : currentStep === 2 ? "active" : "pending"
+    },
+    {
+      label: "Executing bridge",
+      status: currentStep > 3 ? "completed" : currentStep === 3 ? "active" : "pending"
+    },
+    {
+      label: "Confirming on destination",
+      status: currentStep > 4 ? "completed" : currentStep === 4 ? "active" : "pending"
+    }
+  ];
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx7(Box7, { marginBottom: 1, children: /* @__PURE__ */ jsxs7(Text7, { color: theme.secondary, bold: true, children: [
+      "Bridging ",
+      amount,
+      " ",
+      token.symbol,
+      " from ",
+      chain.name,
+      " to HyperEVM"
+    ] }) }),
+    /* @__PURE__ */ jsx7(ProgressSteps, { steps, title: "Bridge Progress", showNumbers: true }),
+    currentStep >= 4 && /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsxs7(Text7, { color: theme.success, bold: true, children: [
+      symbols.check,
+      " Bridge transaction submitted! Waiting for confirmation..."
+    ] }) }),
+    /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx7(Text7, { color: theme.muted, dimColor: true, children: "(Demo mode - actual execution will be implemented in Story 12.5)" }) })
+  ] });
+}
+function Wizard() {
+  const { exit } = useApp();
+  const [state, setState] = useState(initialState);
+  useInput((input, key) => {
+    if (input === "q" && state.step !== "execute") {
+      exit();
+      return;
+    }
+    if (input === "b" && state.step !== "chain" && state.step !== "execute" && state.step !== "amount") {
+      goBack();
+      return;
+    }
+    if (input === "b" && state.step === "amount") {
+      goBack();
+      return;
+    }
+  });
+  const goBack = useCallback(() => {
+    setState((prev) => {
+      switch (prev.step) {
+        case "token":
+          return { ...prev, step: "chain", token: null, error: null };
+        case "amount":
+          return { ...prev, step: "token", amount: "", error: null };
+        case "confirm":
+          return { ...prev, step: "amount", error: null };
+        default:
+          return prev;
+      }
+    });
+  }, []);
+  const handleChainSelect = useCallback((chain) => {
+    setState((prev) => ({ ...prev, chain, step: "token", error: null }));
+  }, []);
+  const handleTokenSelect = useCallback((token) => {
+    setState((prev) => ({ ...prev, token, step: "amount", error: null }));
+  }, []);
+  const handleAmountChange = useCallback((amount) => {
+    setState((prev) => ({ ...prev, amount, error: null }));
+  }, []);
+  const handleAmountConfirm = useCallback(() => {
+    const numAmount = parseFloat(state.amount);
+    if (isNaN(numAmount) || numAmount <= 0) {
+      setState((prev) => ({ ...prev, error: "Please enter a valid positive amount" }));
+      return;
+    }
+    setState((prev) => ({ ...prev, step: "confirm", error: null }));
+  }, [state.amount]);
+  const handleConfirm = useCallback(() => {
+    setState((prev) => ({ ...prev, step: "execute", error: null }));
+  }, []);
+  const renderStepContent = () => {
+    switch (state.step) {
+      case "chain":
+        return /* @__PURE__ */ jsx7(
+          ChainSelectionStep,
+          {
+            onSelect: handleChainSelect,
+            selectedChain: state.chain
+          }
+        );
+      case "token":
+        if (!state.chain) return null;
+        return /* @__PURE__ */ jsx7(
+          TokenSelectionStep,
+          {
+            chain: state.chain,
+            onSelect: handleTokenSelect,
+            selectedToken: state.token
+          }
+        );
+      case "amount":
+        if (!state.chain || !state.token) return null;
+        return /* @__PURE__ */ jsx7(
+          AmountInputStep,
+          {
+            chain: state.chain,
+            token: state.token,
+            amount: state.amount,
+            onAmountChange: handleAmountChange,
+            onConfirm: handleAmountConfirm,
+            error: state.error
+          }
+        );
+      case "confirm":
+        if (!state.chain || !state.token) return null;
+        return /* @__PURE__ */ jsx7(
+          ConfirmationStep,
+          {
+            chain: state.chain,
+            token: state.token,
+            amount: state.amount,
+            onConfirm: handleConfirm
+          }
+        );
+      case "execute":
+        if (!state.chain || !state.token) return null;
+        return /* @__PURE__ */ jsx7(
+          ExecutionStep,
+          {
+            chain: state.chain,
+            token: state.token,
+            amount: state.amount
+          }
+        );
+      default:
+        return null;
+    }
+  };
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx7(Header, { showTagline: true, tagline: "Cross-chain bridge to Hyperliquid" }),
+    /* @__PURE__ */ jsx7(StepIndicator, { currentStep: state.step }),
+    /* @__PURE__ */ jsx7(Box7, { flexDirection: "column", marginY: 1, children: renderStepContent() }),
+    /* @__PURE__ */ jsx7(NavigationHints, { step: state.step })
+  ] });
+}
+
+// src/commands/quote.tsx
+import { useState as useState2, useEffect as useEffect2 } from "react";
+import { Box as Box8, Text as Text8, useApp as useApp2 } from "ink";
+import {
+  Mina,
+  getChains as getChains2,
+  getTokens,
+  HYPEREVM_CHAIN_ID as HYPEREVM_CHAIN_ID2,
+  HYPEREVM_USDC_ADDRESS
+} from "@siphoyawe/mina-sdk";
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+function parseAmount(amount, decimals) {
+  const [whole, fraction = ""] = amount.split(".");
+  const paddedFraction = fraction.padEnd(decimals, "0").slice(0, decimals);
+  return (whole || "0") + paddedFraction;
+}
+function formatAmount(amount, decimals) {
+  const padded = amount.padStart(decimals + 1, "0");
+  const integerPart = padded.slice(0, -decimals) || "0";
+  const decimalPart = padded.slice(-decimals);
+  const trimmedDecimal = decimalPart.replace(/0+$/, "");
+  return trimmedDecimal ? `${integerPart}.${trimmedDecimal}` : integerPart;
+}
+function formatTime(seconds) {
+  if (seconds < 60) {
+    return `~${seconds} seconds`;
+  }
+  const minutes = Math.ceil(seconds / 60);
+  return `~${minutes} minute${minutes > 1 ? "s" : ""}`;
+}
+function formatUsd(amount) {
+  return `$${amount.toFixed(2)}`;
+}
+function getRouteDescription(quote) {
+  const stepTools = quote.steps.map((step) => step.tool);
+  const uniqueTools = [...new Set(stepTools)];
+  return uniqueTools.join(" -> ");
+}
+function QuoteBox({
+  quote,
+  fromChain,
+  toChain,
+  sourceToken,
+  destToken
+}) {
+  const inputAmount = formatAmount(quote.fromAmount, sourceToken.decimals);
+  const outputAmount = formatAmount(quote.toAmount, destToken.decimals);
+  const routeDescription = getRouteDescription(quote);
+  const estimatedTime = formatTime(quote.estimatedTime);
+  const totalFees = formatUsd(quote.fees.totalUsd);
+  const gasFees = formatUsd(quote.fees.gasUsd);
+  const bridgeFees = formatUsd(quote.fees.bridgeFeeUsd);
+  const protocolFees = formatUsd(quote.fees.protocolFeeUsd);
+  return /* @__PURE__ */ jsx8(Box8, { flexDirection: "column", children: /* @__PURE__ */ jsxs8(Box, { bordered: true, title: "Bridge Quote", padding: 1, children: [
+    /* @__PURE__ */ jsx8(
+      KeyValue,
+      {
+        items: [
+          { key: "From", value: `${inputAmount} ${sourceToken.symbol} (${fromChain.name})` },
+          { key: "To", value: `~${outputAmount} ${destToken.symbol} (${toChain})` }
+        ],
+        keyColor: theme.muted,
+        valueColor: theme.primary
+      }
+    ),
+    /* @__PURE__ */ jsx8(Box8, { marginY: 1, children: /* @__PURE__ */ jsx8(Divider, { width: 45 }) }),
+    /* @__PURE__ */ jsx8(
+      KeyValue,
+      {
+        items: [
+          { key: "Route", value: routeDescription },
+          { key: "Time", value: estimatedTime },
+          { key: "Fees", value: totalFees }
+        ],
+        keyColor: theme.muted,
+        valueColor: theme.secondary
+      }
+    ),
+    /* @__PURE__ */ jsx8(Box8, { marginY: 1, children: /* @__PURE__ */ jsx8(Divider, { width: 45 }) }),
+    /* @__PURE__ */ jsx8(Box8, { marginBottom: 1, children: /* @__PURE__ */ jsx8(Text8, { color: theme.muted, bold: true, children: "Fee Breakdown:" }) }),
+    /* @__PURE__ */ jsx8(
+      KeyValue,
+      {
+        items: [
+          { key: "  Gas", value: gasFees },
+          { key: "  Bridge", value: bridgeFees },
+          { key: "  Protocol", value: protocolFees },
+          { key: "  Total", value: totalFees }
+        ],
+        keyColor: theme.muted,
+        valueColor: theme.warning
+      }
+    ),
+    quote.highImpact && /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsxs8(Text8, { color: theme.warning, children: [
+      symbols.pending,
+      " High price impact: ",
+      (quote.priceImpact * 100).toFixed(2),
+      "%"
+    ] }) }),
+    /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsxs8(Text8, { color: theme.muted, children: [
+      "Min. received: ",
+      quote.minimumReceivedFormatted,
+      " ",
+      destToken.symbol
+    ] }) })
+  ] }) });
+}
+function JsonOutput({ quote, fromChain, sourceToken }) {
+  const jsonData = {
+    quote: {
+      id: quote.id,
+      from: {
+        chain: fromChain.name,
+        chainId: fromChain.id,
+        token: sourceToken.symbol,
+        amount: formatAmount(quote.fromAmount, sourceToken.decimals),
+        amountRaw: quote.fromAmount
+      },
+      to: {
+        chain: "Hyperliquid",
+        chainId: HYPEREVM_CHAIN_ID2,
+        token: quote.toToken.symbol,
+        amount: formatAmount(quote.toAmount, quote.toToken.decimals),
+        amountRaw: quote.toAmount
+      },
+      route: {
+        steps: quote.steps.map((step) => ({
+          type: step.type,
+          tool: step.tool,
+          fromChain: step.fromChainId,
+          toChain: step.toChainId,
+          estimatedTime: step.estimatedTime
+        })),
+        totalSteps: quote.steps.length
+      },
+      fees: {
+        total: quote.fees.totalUsd,
+        gas: quote.fees.gasUsd,
+        bridge: quote.fees.bridgeFeeUsd,
+        protocol: quote.fees.protocolFeeUsd
+      },
+      estimatedTime: quote.estimatedTime,
+      priceImpact: quote.priceImpact,
+      highImpact: quote.highImpact,
+      slippageTolerance: quote.slippageTolerance,
+      minimumReceived: quote.minimumReceivedFormatted,
+      expiresAt: quote.expiresAt
+    }
+  };
+  return /* @__PURE__ */ jsx8(Text8, { children: JSON.stringify(jsonData, null, 2) });
+}
+function ErrorDisplay({ message }) {
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx8(Box8, { children: /* @__PURE__ */ jsxs8(Text8, { color: theme.error, bold: true, children: [
+      symbols.failed,
+      " Error: ",
+      message
+    ] }) }),
+    /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text8, { color: theme.muted, children: "Usage: npx mina quote --from <chain> --token <symbol> --amount <number>" }) }),
+    /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text8, { color: theme.muted, children: "Example: npx mina quote --from arbitrum --token USDC --amount 100" }) })
+  ] });
+}
+function QuoteDisplay({
+  fromChain,
+  toChain,
+  token,
+  amount,
+  jsonOutput
+}) {
+  const { exit } = useApp2();
+  const [loading, setLoading] = useState2(true);
+  const [error, setError] = useState2(null);
+  const [quote, setQuote] = useState2(null);
+  const [sourceChain, setSourceChain] = useState2(null);
+  const [sourceToken, setSourceToken] = useState2(null);
+  const [destToken, setDestToken] = useState2(null);
+  useEffect2(() => {
+    async function fetchQuote() {
+      try {
+        setLoading(true);
+        setError(null);
+        const numAmount = parseFloat(amount);
+        if (isNaN(numAmount) || numAmount <= 0) {
+          throw new Error("Invalid amount. Please provide a positive number.");
+        }
+        const chainsResponse = await getChains2();
+        const chain = chainsResponse.chains.find(
+          (c) => c.name.toLowerCase() === fromChain.toLowerCase() || c.key.toLowerCase() === fromChain.toLowerCase()
+        );
+        if (!chain) {
+          const availableChains = chainsResponse.chains.map((c) => c.name).join(", ");
+          throw new Error(
+            `Unknown chain: "${fromChain}". Available chains: ${availableChains}`
+          );
+        }
+        setSourceChain(chain);
+        const tokensResponse = await getTokens(chain.id);
+        const foundToken = tokensResponse.tokens.find(
+          (t) => t.symbol.toLowerCase() === token.toLowerCase()
+        );
+        if (!foundToken) {
+          const availableTokens = tokensResponse.tokens.slice(0, 10).map((t) => t.symbol).join(", ");
+          throw new Error(
+            `Token "${token}" not found on ${chain.name}. Available tokens include: ${availableTokens}...`
+          );
+        }
+        setSourceToken(foundToken);
+        const destinationToken = {
+          address: HYPEREVM_USDC_ADDRESS,
+          symbol: "USDC",
+          name: "USD Coin",
+          decimals: 6,
+          logoUrl: "",
+          chainId: HYPEREVM_CHAIN_ID2
+        };
+        setDestToken(destinationToken);
+        const mina = new Mina({ integrator: "mina-cli" });
+        const quoteResult = await mina.getQuote({
+          fromChainId: chain.id,
+          toChainId: HYPEREVM_CHAIN_ID2,
+          fromToken: foundToken.address,
+          toToken: HYPEREVM_USDC_ADDRESS,
+          fromAmount: parseAmount(amount, foundToken.decimals),
+          fromAddress: "0x0000000000000000000000000000000000000000"
+          // Placeholder for quote
+        });
+        setQuote(quoteResult);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Failed to fetch quote";
+        setError(message);
+      } finally {
+        setLoading(false);
+      }
+    }
+    fetchQuote();
+  }, [fromChain, token, amount]);
+  useEffect2(() => {
+    if (!loading && jsonOutput) {
+      const timer = setTimeout(() => exit(), 100);
+      return () => clearTimeout(timer);
+    }
+  }, [loading, jsonOutput, exit]);
+  if (loading) {
+    return /* @__PURE__ */ jsx8(Box8, { padding: 1, children: /* @__PURE__ */ jsx8(Spinner, { text: `Fetching quote for ${amount} ${token} from ${fromChain}...` }) });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx8(ErrorDisplay, { message: error });
+  }
+  if (!quote || !sourceChain || !sourceToken || !destToken) {
+    return /* @__PURE__ */ jsx8(ErrorDisplay, { message: "Failed to fetch quote data" });
+  }
+  if (jsonOutput) {
+    return /* @__PURE__ */ jsx8(JsonOutput, { quote, fromChain: sourceChain, sourceToken });
+  }
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx8(
+      QuoteBox,
+      {
+        quote,
+        fromChain: sourceChain,
+        toChain: toChain === "hyperliquid" ? "Hyperliquid" : toChain,
+        sourceToken,
+        destToken
+      }
+    ),
+    /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsxs8(Text8, { color: theme.muted, children: [
+      "Quote valid until: ",
+      new Date(quote.expiresAt).toLocaleTimeString()
+    ] }) })
+  ] });
+}
+
+// src/commands/chains.tsx
+import { useState as useState3, useEffect as useEffect3 } from "react";
+import { Box as Box9, Text as Text9, useApp as useApp3 } from "ink";
+import {
+  getChains as getChains3,
+  HYPEREVM_CHAIN_ID as HYPEREVM_CHAIN_ID3
+} from "@siphoyawe/mina-sdk";
+import { jsx as jsx9, jsxs as jsxs9 } from "react/jsx-runtime";
+function ChainsCommand({ json = false }) {
+  const { exit } = useApp3();
+  const [chains, setChains] = useState3([]);
+  const [loading, setLoading] = useState3(true);
+  const [error, setError] = useState3(null);
+  useEffect3(() => {
+    async function loadChains() {
+      try {
+        setLoading(true);
+        setError(null);
+        const response = await getChains3();
+        const chainRows = response.chains.map((chain) => ({
+          name: chain.name,
+          id: chain.id,
+          type: "Origin"
+        }));
+        const hasHyperEvm = chainRows.some((c) => c.id === HYPEREVM_CHAIN_ID3);
+        if (!hasHyperEvm) {
+          chainRows.push({
+            name: "Hyperliquid",
+            id: HYPEREVM_CHAIN_ID3,
+            type: "Dest"
+          });
+        } else {
+          const hyperEvmChain = chainRows.find((c) => c.id === HYPEREVM_CHAIN_ID3);
+          if (hyperEvmChain) {
+            hyperEvmChain.type = "Dest";
+          }
+        }
+        chainRows.sort((a, b) => {
+          if (a.type !== b.type) {
+            return a.type === "Origin" ? -1 : 1;
+          }
+          return a.name.localeCompare(b.name);
+        });
+        setChains(chainRows);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Failed to load chains");
+      } finally {
+        setLoading(false);
+      }
+    }
+    loadChains();
+  }, []);
+  useEffect3(() => {
+    if (!loading && json) {
+      setTimeout(() => exit(), 100);
+    }
+  }, [loading, json, exit]);
+  if (json) {
+    if (loading) return null;
+    if (error) {
+      console.error(JSON.stringify({ error }, null, 2));
+      return null;
+    }
+    console.log(JSON.stringify(chains, null, 2));
+    return null;
+  }
+  if (loading) {
+    return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", padding: 1, children: [
+      /* @__PURE__ */ jsx9(Header, { compact: true, showTagline: false }),
+      /* @__PURE__ */ jsx9(Spinner, { text: "Loading supported chains..." })
+    ] });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", padding: 1, children: [
+      /* @__PURE__ */ jsx9(Header, { compact: true, showTagline: false }),
+      /* @__PURE__ */ jsx9(Box9, { children: /* @__PURE__ */ jsxs9(Text9, { color: theme.error, children: [
+        symbols.failed,
+        " Error: ",
+        error
+      ] }) })
+    ] });
+  }
+  const columns = [
+    {
+      header: "Chain",
+      accessor: "name",
+      headerColor: theme.primary,
+      cellColor: theme.secondary
+    },
+    {
+      header: "ID",
+      accessor: (row) => String(row.id),
+      align: "right",
+      headerColor: theme.primary,
+      cellColor: theme.muted
+    },
+    {
+      header: "Type",
+      accessor: "type",
+      headerColor: theme.primary,
+      cellColor: (value) => value === "Origin" ? theme.success : theme.accent
+    }
+  ];
+  return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx9(Header, { compact: true, showTagline: false }),
+    /* @__PURE__ */ jsx9(Box9, { marginBottom: 1, children: /* @__PURE__ */ jsxs9(Text9, { color: theme.secondary, children: [
+      symbols.arrow,
+      " Supported Chains (",
+      chains.length,
+      ")"
+    ] }) }),
+    /* @__PURE__ */ jsx9(
+      Table,
+      {
+        data: chains,
+        columns,
+        bordered: true,
+        borderColor: theme.border
+      }
+    ),
+    /* @__PURE__ */ jsx9(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx9(Text9, { color: theme.muted, dimColor: true, children: "Origin = Source chains for bridging | Dest = Destination chain" }) })
+  ] });
+}
+
+// src/commands/tokens.tsx
+import { useState as useState4, useEffect as useEffect4 } from "react";
+import { Box as Box10, Text as Text10, useApp as useApp4 } from "ink";
+import {
+  getChains as getChains4,
+  getBridgeableTokens as getBridgeableTokens2
+} from "@siphoyawe/mina-sdk";
+import { jsx as jsx10, jsxs as jsxs10 } from "react/jsx-runtime";
+function truncateAddress(address) {
+  if (address.length <= 14) return address;
+  return `${address.slice(0, 10)}...${address.slice(-4)}`;
+}
+async function resolveChainId(chainInput) {
+  const numericId = parseInt(chainInput, 10);
+  if (!isNaN(numericId)) {
+    const response2 = await getChains4();
+    const chain2 = response2.chains.find((c) => c.id === numericId);
+    if (chain2) {
+      return { chainId: chain2.id, chainName: chain2.name };
+    }
+    return { chainId: numericId, chainName: chainInput };
+  }
+  const response = await getChains4();
+  const chainLower = chainInput.toLowerCase();
+  const chain = response.chains.find(
+    (c) => c.name.toLowerCase() === chainLower || c.key?.toLowerCase() === chainLower
+  );
+  if (chain) {
+    return { chainId: chain.id, chainName: chain.name };
+  }
+  return null;
+}
+function TokensCommand({
+  chain,
+  json = false
+}) {
+  const { exit } = useApp4();
+  const [tokens, setTokens] = useState4([]);
+  const [loading, setLoading] = useState4(true);
+  const [error, setError] = useState4(null);
+  const [chainName, setChainName] = useState4("");
+  const [availableChains, setAvailableChains] = useState4([]);
+  useEffect4(() => {
+    async function loadTokens() {
+      try {
+        setLoading(true);
+        setError(null);
+        if (!chain) {
+          const chainsResponse = await getChains4();
+          setAvailableChains(chainsResponse.chains);
+          setError("Please specify a chain with --chain <name|id>");
+          setLoading(false);
+          return;
+        }
+        const resolved = await resolveChainId(chain);
+        if (!resolved) {
+          const chainsResponse = await getChains4();
+          setAvailableChains(chainsResponse.chains);
+          setError(`Unknown chain: "${chain}"`);
+          setLoading(false);
+          return;
+        }
+        setChainName(resolved.chainName);
+        const response = await getBridgeableTokens2(resolved.chainId);
+        const tokenRows = response.tokens.map((token) => ({
+          symbol: token.symbol,
+          address: token.address,
+          displayAddress: truncateAddress(token.address),
+          decimals: token.decimals,
+          name: token.name
+        }));
+        tokenRows.sort((a, b) => a.symbol.localeCompare(b.symbol));
+        setTokens(tokenRows);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Failed to load tokens");
+      } finally {
+        setLoading(false);
+      }
+    }
+    loadTokens();
+  }, [chain]);
+  useEffect4(() => {
+    if (!loading && json) {
+      setTimeout(() => exit(), 100);
+    }
+  }, [loading, json, exit]);
+  if (json) {
+    if (loading) return null;
+    if (error && !availableChains.length) {
+      console.error(JSON.stringify({ error }, null, 2));
+      return null;
+    }
+    if (error && availableChains.length) {
+      console.error(JSON.stringify({
+        error,
+        availableChains: availableChains.map((c) => ({ name: c.name, id: c.id }))
+      }, null, 2));
+      return null;
+    }
+    console.log(JSON.stringify(tokens.map((t) => ({
+      symbol: t.symbol,
+      address: t.address,
+      decimals: t.decimals,
+      name: t.name
+    })), null, 2));
+    return null;
+  }
+  if (loading) {
+    return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", padding: 1, children: [
+      /* @__PURE__ */ jsx10(Header, { compact: true, showTagline: false }),
+      /* @__PURE__ */ jsx10(Spinner, { text: chain ? `Loading tokens for ${chain}...` : "Loading..." })
+    ] });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", padding: 1, children: [
+      /* @__PURE__ */ jsx10(Header, { compact: true, showTagline: false }),
+      /* @__PURE__ */ jsx10(Box10, { marginBottom: 1, children: /* @__PURE__ */ jsxs10(Text10, { color: theme.error, children: [
+        symbols.failed,
+        " ",
+        error
+      ] }) }),
+      availableChains.length > 0 && /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsx10(Box10, { marginBottom: 1, children: /* @__PURE__ */ jsx10(Text10, { color: theme.secondary, children: "Available chains:" }) }),
+        availableChains.slice(0, 10).map((c, i) => /* @__PURE__ */ jsxs10(Box10, { children: [
+          /* @__PURE__ */ jsxs10(Text10, { color: theme.muted, children: [
+            "  ",
+            symbols.arrow,
+            " "
+          ] }),
+          /* @__PURE__ */ jsx10(Text10, { color: theme.primary, children: c.name }),
+          /* @__PURE__ */ jsxs10(Text10, { color: theme.muted, children: [
+            " (ID: ",
+            c.id,
+            ")"
+          ] })
+        ] }, i)),
+        availableChains.length > 10 && /* @__PURE__ */ jsx10(Box10, { marginTop: 1, children: /* @__PURE__ */ jsxs10(Text10, { color: theme.muted, dimColor: true, children: [
+          "...and ",
+          availableChains.length - 10,
+          ' more. Use "mina chains" to see all.'
+        ] }) }),
+        /* @__PURE__ */ jsx10(Box10, { marginTop: 1, children: /* @__PURE__ */ jsx10(Text10, { color: theme.muted, dimColor: true, children: "Example: mina tokens --chain arbitrum" }) })
+      ] })
+    ] });
+  }
+  if (tokens.length === 0) {
+    return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", padding: 1, children: [
+      /* @__PURE__ */ jsx10(Header, { compact: true, showTagline: false }),
+      /* @__PURE__ */ jsx10(Box10, { children: /* @__PURE__ */ jsxs10(Text10, { color: theme.warning, children: [
+        symbols.pending,
+        " No bridgeable tokens found for ",
+        chainName
+      ] }) })
+    ] });
+  }
+  const columns = [
+    {
+      header: "Symbol",
+      accessor: "symbol",
+      headerColor: theme.primary,
+      cellColor: theme.success
+    },
+    {
+      header: "Address",
+      accessor: "displayAddress",
+      headerColor: theme.primary,
+      cellColor: theme.muted,
+      width: 20
+    },
+    {
+      header: "Decimals",
+      accessor: (row) => String(row.decimals),
+      align: "right",
+      headerColor: theme.primary,
+      cellColor: theme.secondary
+    }
+  ];
+  return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx10(Header, { compact: true, showTagline: false }),
+    /* @__PURE__ */ jsxs10(Box10, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsxs10(Text10, { color: theme.secondary, children: [
+        symbols.arrow,
+        " Bridgeable Tokens on",
+        " "
+      ] }),
+      /* @__PURE__ */ jsx10(Text10, { color: theme.primary, bold: true, children: chainName }),
+      /* @__PURE__ */ jsxs10(Text10, { color: theme.muted, children: [
+        " (",
+        tokens.length,
+        ")"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx10(
+      Table,
+      {
+        data: tokens,
+        columns,
+        bordered: true,
+        borderColor: theme.border
+      }
+    ),
+    /* @__PURE__ */ jsx10(Box10, { marginTop: 1, children: /* @__PURE__ */ jsx10(Text10, { color: theme.muted, dimColor: true, children: "Tokens that can be bridged to Hyperliquid via Mina" }) })
+  ] });
+}
+
+// src/commands/status.tsx
+import { useState as useState5, useEffect as useEffect5, useCallback as useCallback2, useMemo } from "react";
+import { Box as Box11, Text as Text11, useApp as useApp5 } from "ink";
+import {
+  Mina as Mina2
+} from "@siphoyawe/mina-sdk";
+import { jsx as jsx11, jsxs as jsxs11 } from "react/jsx-runtime";
+function formatDuration(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  return `${minutes}m ${remainingSeconds}s`;
+}
+function truncateHash(hash) {
+  if (hash.length <= 16) return hash;
+  return `${hash.slice(0, 8)}...${hash.slice(-6)}`;
+}
+function getStatusColor2(status) {
+  switch (status) {
+    case "completed":
+      return theme.success;
+    case "failed":
+      return theme.error;
+    case "pending":
+      return theme.muted;
+    case "bridging":
+    case "depositing":
+    case "executing":
+      return theme.primary;
+    default:
+      return theme.secondary;
+  }
+}
+function getStepIndicator(status) {
+  switch (status) {
+    case "pending":
+      return /* @__PURE__ */ jsx11(Text11, { color: theme.muted, children: symbols.pending });
+    case "executing":
+      return /* @__PURE__ */ jsx11(Text11, { color: theme.primary, children: /* @__PURE__ */ jsx11(Spinner, {}) });
+    case "completed":
+      return /* @__PURE__ */ jsx11(Text11, { color: theme.success, children: symbols.completed });
+    case "failed":
+      return /* @__PURE__ */ jsx11(Text11, { color: theme.error, children: symbols.failed });
+    default:
+      return /* @__PURE__ */ jsx11(Text11, { color: theme.muted, children: symbols.pending });
+  }
+}
+function calculateProgress(steps) {
+  if (steps.length === 0) return 0;
+  const completedSteps = steps.filter((s) => s.status === "completed").length;
+  const executingSteps = steps.filter((s) => s.status === "executing").length;
+  return Math.round((completedSteps + executingSteps * 0.5) / steps.length * 100);
+}
+function getCurrentStepInfo(steps) {
+  const total = steps.length;
+  const current = steps.findIndex((s) => s.status === "executing" || s.status === "pending");
+  if (current === -1) {
+    return { current: total, total };
+  }
+  return { current: current + 1, total };
+}
+function formatStepType(stepType) {
+  if (!stepType) return "Unknown";
+  const mapping = {
+    approval: "Approval",
+    swap: "Swap",
+    bridge: "Bridging",
+    deposit: "Deposit"
+  };
+  return mapping[stepType] || stepType.charAt(0).toUpperCase() + stepType.slice(1);
+}
+function StatusDisplay({
+  status,
+  txHash,
+  elapsedTime,
+  estimatedRemaining
+}) {
+  const stepInfo = getCurrentStepInfo(status.steps);
+  const progress = calculateProgress(status.steps);
+  const statusLabel = status.status.charAt(0).toUpperCase() + status.status.slice(1);
+  return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx11(Box, { bordered: true, title: "Bridge Status", padding: 1, children: /* @__PURE__ */ jsx11(
+      KeyValue,
+      {
+        items: [
+          { key: "TX", value: truncateHash(txHash) },
+          { key: "Status", value: `${statusLabel} (Step ${stepInfo.current}/${stepInfo.total})` }
+        ],
+        valueColor: getStatusColor2(status.status)
+      }
+    ) }),
+    /* @__PURE__ */ jsx11(Box11, { marginTop: 1, children: /* @__PURE__ */ jsx11(Box, { bordered: true, padding: 1, children: /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", children: [
+      status.steps.map((step, index) => /* @__PURE__ */ jsxs11(Box11, { children: [
+        /* @__PURE__ */ jsx11(Box11, { width: 3, children: getStepIndicator(step.status) }),
+        /* @__PURE__ */ jsx11(Box11, { flexGrow: 1, children: /* @__PURE__ */ jsxs11(
+          Text11,
+          {
+            color: getStatusColor2(step.status),
+            bold: step.status === "executing",
+            dimColor: step.status === "pending",
+            children: [
+              formatStepType(step.stepType),
+              step.status === "executing" && progress > 0 && ` (${progress}%)`
+            ]
+          }
+        ) }),
+        step.txHash && /* @__PURE__ */ jsx11(Box11, { marginLeft: 2, children: /* @__PURE__ */ jsx11(Text11, { color: theme.muted, dimColor: true, children: truncateHash(step.txHash) }) })
+      ] }, step.stepId)),
+      status.steps.length === 0 && /* @__PURE__ */ jsx11(Text11, { color: theme.muted, children: "No steps found" })
+    ] }) }) }),
+    /* @__PURE__ */ jsx11(Box11, { marginTop: 1, children: /* @__PURE__ */ jsx11(Box, { bordered: true, padding: 1, children: /* @__PURE__ */ jsx11(
+      KeyValue,
+      {
+        items: [
+          { key: "Elapsed", value: formatDuration(elapsedTime) },
+          {
+            key: "Remaining",
+            value: estimatedRemaining !== null ? `~${formatDuration(estimatedRemaining)}` : "Calculating..."
+          }
+        ],
+        keyColor: theme.muted,
+        valueColor: theme.secondary
+      }
+    ) }) }),
+    status.status === "failed" && /* @__PURE__ */ jsx11(Box11, { marginTop: 1, children: /* @__PURE__ */ jsx11(Box, { bordered: true, borderColor: theme.error, padding: 1, children: /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs11(Text11, { color: theme.error, bold: true, children: [
+        symbols.failed,
+        " Transaction Failed"
+      ] }),
+      status.steps.find((s) => s.status === "failed")?.error && /* @__PURE__ */ jsx11(Box11, { marginTop: 1, children: /* @__PURE__ */ jsx11(Text11, { color: theme.muted, children: status.steps.find((s) => s.status === "failed")?.error }) })
+    ] }) }) }),
+    status.status === "completed" && /* @__PURE__ */ jsx11(Box11, { marginTop: 1, children: /* @__PURE__ */ jsx11(Box, { bordered: true, borderColor: theme.success, padding: 1, children: /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs11(Text11, { color: theme.success, bold: true, children: [
+        symbols.completed,
+        " Bridge Completed Successfully"
+      ] }),
+      status.bridgeTxHash && /* @__PURE__ */ jsx11(Box11, { marginTop: 1, children: /* @__PURE__ */ jsx11(
+        KeyValue,
+        {
+          items: [
+            { key: "Bridge TX", value: truncateHash(status.bridgeTxHash) },
+            ...status.depositTxHash ? [{ key: "Deposit TX", value: truncateHash(status.depositTxHash) }] : []
+          ],
+          keyColor: theme.muted,
+          valueColor: theme.success
+        }
+      ) })
+    ] }) }) })
+  ] });
+}
+function LoadingState({ txHash }) {
+  return /* @__PURE__ */ jsx11(Box11, { flexDirection: "column", children: /* @__PURE__ */ jsx11(Box, { bordered: true, title: "Bridge Status", padding: 1, children: /* @__PURE__ */ jsx11(Box11, { children: /* @__PURE__ */ jsx11(Spinner, { text: `Looking up ${truncateHash(txHash)}...` }) }) }) });
+}
+function NotFoundState({ txHash }) {
+  return /* @__PURE__ */ jsx11(Box11, { flexDirection: "column", children: /* @__PURE__ */ jsx11(Box, { bordered: true, borderColor: theme.warning, title: "Bridge Status", padding: 1, children: /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs11(Text11, { color: theme.warning, children: [
+      symbols.pending,
+      " Transaction not found"
+    ] }),
+    /* @__PURE__ */ jsx11(Box11, { marginTop: 1, children: /* @__PURE__ */ jsxs11(Text11, { color: theme.muted, children: [
+      "TX: ",
+      truncateHash(txHash)
+    ] }) }),
+    /* @__PURE__ */ jsx11(Box11, { marginTop: 1, children: /* @__PURE__ */ jsx11(Text11, { color: theme.muted, dimColor: true, children: "The transaction may not have been initiated via this CLI, or it may have expired from the local cache." }) })
+  ] }) }) });
+}
+function ErrorState({ error }) {
+  return /* @__PURE__ */ jsx11(Box11, { flexDirection: "column", children: /* @__PURE__ */ jsx11(Box, { bordered: true, borderColor: theme.error, title: "Error", padding: 1, children: /* @__PURE__ */ jsxs11(Text11, { color: theme.error, children: [
+    symbols.failed,
+    " ",
+    error
+  ] }) }) });
+}
+function Status({ txHash, watch = false }) {
+  const { exit } = useApp5();
+  const [status, setStatus] = useState5(null);
+  const [loading, setLoading] = useState5(true);
+  const [error, setError] = useState5(null);
+  const [notFound, setNotFound] = useState5(false);
+  const [startTime] = useState5(Date.now());
+  const [elapsedTime, setElapsedTime] = useState5(0);
+  const mina = useMemo(() => new Mina2({ integrator: "mina-cli" }), []);
+  const fetchStatus = useCallback2(async () => {
+    try {
+      const result = await mina.getStatus(txHash);
+      if (result === null) {
+        setNotFound(true);
+        setLoading(false);
+        if (!watch) {
+          setTimeout(() => exit(), 100);
+        }
+        return;
+      }
+      setStatus(result);
+      setNotFound(false);
+      setLoading(false);
+      if (!watch && (result.status === "completed" || result.status === "failed")) {
+        setTimeout(() => exit(), 100);
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to fetch status");
+      setLoading(false);
+      if (!watch) {
+        setTimeout(() => exit(), 100);
+      }
+    }
+  }, [txHash, watch, exit, mina]);
+  useEffect5(() => {
+    fetchStatus();
+  }, [fetchStatus]);
+  useEffect5(() => {
+    if (!watch) return;
+    const interval = setInterval(() => {
+      fetchStatus();
+    }, 5e3);
+    return () => clearInterval(interval);
+  }, [watch, fetchStatus]);
+  useEffect5(() => {
+    const interval = setInterval(() => {
+      setElapsedTime(Date.now() - (status?.createdAt || startTime));
+    }, 1e3);
+    return () => clearInterval(interval);
+  }, [status?.createdAt, startTime]);
+  const estimatedRemaining = status ? (() => {
+    const progress = calculateProgress(status.steps);
+    if (progress === 0) return null;
+    if (progress >= 100) return 0;
+    const elapsed = elapsedTime;
+    const totalEstimated = elapsed / progress * 100;
+    return Math.max(0, totalEstimated - elapsed);
+  })() : null;
+  return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx11(Header, { showTagline: false }),
+    watch && /* @__PURE__ */ jsx11(Box11, { marginBottom: 1, children: /* @__PURE__ */ jsxs11(Text11, { color: theme.primary, children: [
+      /* @__PURE__ */ jsx11(Spinner, {}),
+      " Watching for updates (polling every 5s)"
+    ] }) }),
+    /* @__PURE__ */ jsxs11(Box11, { marginTop: 1, children: [
+      loading && /* @__PURE__ */ jsx11(LoadingState, { txHash }),
+      error && /* @__PURE__ */ jsx11(ErrorState, { error }),
+      notFound && !loading && /* @__PURE__ */ jsx11(NotFoundState, { txHash }),
+      status && !loading && !error && /* @__PURE__ */ jsx11(
+        StatusDisplay,
+        {
+          status,
+          txHash,
+          elapsedTime,
+          estimatedRemaining
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx11(Box11, { marginTop: 1, children: /* @__PURE__ */ jsx11(Text11, { color: theme.muted, dimColor: true, children: watch ? "Ctrl+C to stop watching" : "Press any key to exit" }) })
+  ] });
+}
+
+// src/commands/bridge.tsx
+import { useState as useState6, useEffect as useEffect6, useCallback as useCallback3 } from "react";
+import { Box as Box12, Text as Text12, useApp as useApp6, useInput as useInput2 } from "ink";
+import {
+  Mina as Mina3,
+  getChains as getChains5,
+  getBridgeableTokens as getBridgeableTokens3,
+  getQuote,
+  HYPEREVM_CHAIN_ID as HYPEREVM_CHAIN_ID4,
+  HYPEREVM_USDC_ADDRESS as HYPEREVM_USDC_ADDRESS2,
+  normalizeError,
+  isRecoverableError,
+  RECOVERY_ACTIONS
+} from "@siphoyawe/mina-sdk";
+
+// src/lib/wallet.ts
+import fs from "fs";
+import readline from "readline";
+async function loadPrivateKey(path3) {
+  if (path3) {
+    if (!fs.existsSync(path3)) {
+      throw new Error(`Key file not found: ${path3}`);
+    }
+    const content = fs.readFileSync(path3, "utf-8");
+    try {
+      const json = JSON.parse(content);
+      const key = json.privateKey || json.private_key || json.key;
+      if (key) {
+        return normalizePrivateKey(key);
+      }
+      return normalizePrivateKey(content.trim());
+    } catch {
+      return normalizePrivateKey(content.trim());
+    }
+  }
+  return promptForPrivateKey();
+}
+function promptForPrivateKey() {
+  return new Promise((resolve, reject) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    process.stdout.write("Enter private key (input will be visible): ");
+    rl.on("line", (answer) => {
+      rl.close();
+      try {
+        resolve(normalizePrivateKey(answer.trim()));
+      } catch (err) {
+        reject(err);
+      }
+    });
+    rl.on("close", () => {
+    });
+  });
+}
+function normalizePrivateKey(key) {
+  const trimmed = key.trim();
+  const keyWithoutPrefix = trimmed.startsWith("0x") ? trimmed.slice(2) : trimmed;
+  if (!/^[0-9a-fA-F]{64}$/.test(keyWithoutPrefix)) {
+    throw new Error("Invalid private key format. Expected 64 hex characters.");
+  }
+  return trimmed.startsWith("0x") ? trimmed : `0x${trimmed}`;
+}
+async function getAddressFromPrivateKey(privateKey) {
+  const { privateKeyToAccount } = await import("viem/accounts");
+  const account = privateKeyToAccount(privateKey);
+  return account.address;
+}
+async function createSigner(privateKey, chainId, rpcUrl) {
+  const { privateKeyToAccount } = await import("viem/accounts");
+  const { createWalletClient, http } = await import("viem");
+  const { arbitrum, mainnet, optimism, polygon, base, avalanche, bsc } = await import("viem/chains");
+  const chainMap = {
+    1: mainnet,
+    42161: arbitrum,
+    10: optimism,
+    137: polygon,
+    8453: base,
+    43114: avalanche,
+    56: bsc,
+    // HyperEVM
+    999: {
+      id: 999,
+      name: "HyperEVM",
+      nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
+      rpcUrls: {
+        default: { http: ["https://rpc.hyperliquid.xyz/evm"] }
+      }
+    }
+  };
+  const chain = chainMap[chainId];
+  if (!chain) {
+    throw new Error(`Unsupported chain ID: ${chainId}. Supported: ${Object.keys(chainMap).join(", ")}`);
+  }
+  const account = privateKeyToAccount(privateKey);
+  const transport = rpcUrl ? http(rpcUrl) : http();
+  const walletClient = createWalletClient({
+    account,
+    chain,
+    transport
+  });
+  return {
+    sendTransaction: async (request) => {
+      const txHash = await walletClient.sendTransaction({
+        to: request.to,
+        data: request.data,
+        value: BigInt(request.value || "0"),
+        gas: request.gasLimit ? BigInt(request.gasLimit) : void 0,
+        gasPrice: request.gasPrice ? BigInt(request.gasPrice) : void 0,
+        chain
+      });
+      return txHash;
+    },
+    getAddress: async () => {
+      return account.address;
+    },
+    getChainId: async () => {
+      return chainId;
+    }
+  };
+}
+
+// src/commands/bridge.tsx
+import { jsx as jsx12, jsxs as jsxs12 } from "react/jsx-runtime";
+function ErrorDisplay2({
+  error,
+  recoveryAction
+}) {
+  const normalizedError = normalizeError(error);
+  const isRecoverable = isRecoverableError(normalizedError);
+  return /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsx12(Box12, { children: /* @__PURE__ */ jsxs12(Text12, { color: theme.error, bold: true, children: [
+      symbols.failed,
+      " Error: ",
+      normalizedError.message
+    ] }) }),
+    recoveryAction && /* @__PURE__ */ jsx12(Box12, { marginTop: 1, children: /* @__PURE__ */ jsxs12(Text12, { color: theme.warning, children: [
+      symbols.arrow,
+      " Recovery suggestion: ",
+      recoveryAction
+    ] }) }),
+    isRecoverable && /* @__PURE__ */ jsx12(Box12, { marginTop: 1, children: /* @__PURE__ */ jsx12(Text12, { color: theme.muted, dimColor: true, children: "This error may be temporary. Try again in a few moments." }) })
+  ] });
+}
+function QuoteDisplay2({
+  quote,
+  chain,
+  token,
+  amount
+}) {
+  const estimatedMinutes = Math.ceil(quote.estimatedTime / 60);
+  const outputFormatted = (Number(quote.toAmount) / Math.pow(10, quote.toToken.decimals)).toFixed(2);
+  return /* @__PURE__ */ jsxs12(Box, { bordered: true, title: "Bridge Quote", padding: 1, children: [
+    /* @__PURE__ */ jsx12(
+      KeyValue,
+      {
+        items: [
+          { key: "From Chain", value: chain.name },
+          { key: "Token", value: `${amount} ${token.symbol}` },
+          { key: "To Chain", value: "HyperEVM" },
+          { key: "You Receive", value: `~${outputFormatted} ${quote.toToken.symbol}` }
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx12(Box12, { marginTop: 1, marginBottom: 1, children: /* @__PURE__ */ jsx12(Divider, { width: 40 }) }),
+    /* @__PURE__ */ jsx12(
+      KeyValue,
+      {
+        items: [
+          { key: "Gas Fee", value: `$${quote.fees.gasUsd.toFixed(2)}` },
+          { key: "Bridge Fee", value: `$${quote.fees.bridgeFeeUsd.toFixed(2)}` },
+          { key: "Total Fees", value: `$${quote.fees.totalUsd.toFixed(2)}` },
+          { key: "Est. Time", value: `~${estimatedMinutes} min` }
+        ],
+        keyColor: theme.muted,
+        valueColor: theme.warning
+      }
+    ),
+    quote.highImpact && /* @__PURE__ */ jsx12(Box12, { marginTop: 1, children: /* @__PURE__ */ jsxs12(Text12, { color: theme.warning, children: [
+      symbols.pending,
+      " Warning: High price impact (",
+      (quote.priceImpact * 100).toFixed(2),
+      "%)"
+    ] }) }),
+    quote.includesAutoDeposit && /* @__PURE__ */ jsx12(Box12, { marginTop: 1, children: /* @__PURE__ */ jsxs12(Text12, { color: theme.success, dimColor: true, children: [
+      symbols.check,
+      " Auto-deposit to Hyperliquid L1 included"
+    ] }) })
+  ] });
+}
+function BridgeProgressDisplay({
+  stepState,
+  error,
+  currentStepDescription
+}) {
+  const steps = [
+    {
+      label: "Loading wallet & chain data",
+      status: stepState.loading
+    },
+    {
+      label: "Fetching bridge quote",
+      status: stepState.quote
+    },
+    {
+      label: "Approving token spend",
+      status: stepState.approval,
+      description: stepState.approval === "active" ? "Waiting for approval transaction..." : void 0
+    },
+    {
+      label: "Executing bridge transaction",
+      status: stepState.bridge,
+      description: stepState.bridge === "active" ? "Waiting for bridge transaction..." : void 0
+    },
+    {
+      label: "Confirming on destination",
+      status: stepState.confirm,
+      description: stepState.confirm === "active" ? currentStepDescription : error
+    }
+  ];
+  if (error) {
+    const activeIndex = steps.findIndex((s) => s.status === "active" || s.status === "failed");
+    if (activeIndex >= 0) {
+      const step = steps[activeIndex];
+      if (step) {
+        step.status = "failed";
+        step.description = error;
+      }
+    }
+  }
+  return /* @__PURE__ */ jsx12(ProgressSteps, { steps, title: "Bridge Progress", showNumbers: true });
+}
+function SuccessDisplay({
+  result,
+  chain,
+  token,
+  amount
+}) {
+  return /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", marginTop: 1, children: [
+    /* @__PURE__ */ jsx12(Box12, { children: /* @__PURE__ */ jsxs12(Text12, { color: theme.success, bold: true, children: [
+      symbols.check,
+      " Bridge completed successfully!"
+    ] }) }),
+    /* @__PURE__ */ jsx12(Box12, { marginTop: 1, children: /* @__PURE__ */ jsx12(Box, { bordered: true, padding: 1, children: /* @__PURE__ */ jsx12(
+      KeyValue,
+      {
+        items: [
+          { key: "Status", value: "Success" },
+          { key: "From", value: `${amount} ${token.symbol} on ${chain.name}` },
+          { key: "To", value: "USDC on HyperEVM" },
+          ...result.txHash ? [{ key: "Bridge TX", value: result.txHash.slice(0, 20) + "..." }] : [],
+          ...result.depositTxHash ? [{ key: "Deposit TX", value: result.depositTxHash.slice(0, 20) + "..." }] : []
+        ],
+        valueColor: theme.success
+      }
+    ) }) }),
+    /* @__PURE__ */ jsx12(Box12, { marginTop: 1, children: /* @__PURE__ */ jsx12(Text12, { color: theme.muted, dimColor: true, children: "Your funds are now available on HyperEVM. Check your Hyperliquid balance." }) })
+  ] });
+}
+function Bridge({ options }) {
+  const { exit } = useApp6();
+  const [state, setState] = useState6("loading");
+  const [chain, setChain] = useState6(null);
+  const [token, setToken] = useState6(null);
+  const [quote, setQuote] = useState6(null);
+  const [walletAddress, setWalletAddress] = useState6(null);
+  const [privateKey, setPrivateKey] = useState6(null);
+  const [error, setError] = useState6(null);
+  const [recoveryAction, setRecoveryAction] = useState6(null);
+  const [result, setResult] = useState6(null);
+  const [currentStepDescription, setCurrentStepDescription] = useState6("");
+  const [stepState, setStepState] = useState6({
+    loading: "active",
+    quote: "pending",
+    approval: "pending",
+    bridge: "pending",
+    confirm: "pending"
+  });
+  useInput2((input, key) => {
+    if (state === "confirming") {
+      if (key.return || input === "y" || input === "Y") {
+        executeBridge();
+      } else if (input === "n" || input === "N" || input === "q") {
+        exit();
+      }
+    }
+    if (state === "completed" || state === "failed") {
+      if (key.return || input === "q") {
+        exit();
+      }
+    }
+  });
+  useEffect6(() => {
+    loadInitialData();
+  }, []);
+  const loadInitialData = async () => {
+    try {
+      setStepState((prev) => ({ ...prev, loading: "active" }));
+      const key = await loadPrivateKey(options.key);
+      setPrivateKey(key);
+      const address = await getAddressFromPrivateKey(key);
+      setWalletAddress(address);
+      const chainsResponse = await getChains5();
+      const foundChain = chainsResponse.chains.find(
+        (c) => c.key.toLowerCase() === options.from.toLowerCase() || c.name.toLowerCase() === options.from.toLowerCase() || c.id.toString() === options.from
+      );
+      if (!foundChain) {
+        throw new Error(`Chain not found: ${options.from}. Available chains: ${chainsResponse.chains.map((c) => c.key).join(", ")}`);
+      }
+      setChain(foundChain);
+      const tokensResponse = await getBridgeableTokens3(foundChain.id);
+      const foundToken = tokensResponse.tokens.find(
+        (t) => t.symbol.toLowerCase() === options.token.toLowerCase() || t.address.toLowerCase() === options.token.toLowerCase()
+      );
+      if (!foundToken) {
+        throw new Error(`Token not found: ${options.token}. Available tokens: ${tokensResponse.tokens.map((t) => t.symbol).join(", ")}`);
+      }
+      setToken(foundToken);
+      setStepState((prev) => ({ ...prev, loading: "completed", quote: "active" }));
+      const amountInSmallestUnit = (parseFloat(options.amount) * Math.pow(10, foundToken.decimals)).toString();
+      const quoteResult = await getQuote({
+        fromChainId: foundChain.id,
+        toChainId: HYPEREVM_CHAIN_ID4,
+        fromToken: foundToken.address,
+        toToken: HYPEREVM_USDC_ADDRESS2,
+        fromAmount: amountInSmallestUnit,
+        fromAddress: address
+      });
+      setQuote(quoteResult);
+      setStepState((prev) => ({ ...prev, quote: "completed" }));
+      setState("loaded");
+      if (options.yes) {
+        setState("confirming");
+        setTimeout(() => executeBridge(), 500);
+      } else {
+        setState("confirming");
+      }
+    } catch (err) {
+      const normalizedError = normalizeError(err instanceof Error ? err : new Error(String(err)));
+      setError(normalizedError);
+      const action = RECOVERY_ACTIONS[normalizedError.code];
+      if (action) {
+        setRecoveryAction(action);
+      }
+      setStepState((prev) => ({
+        ...prev,
+        loading: prev.loading === "active" ? "failed" : prev.loading,
+        quote: prev.quote === "active" ? "failed" : prev.quote
+      }));
+      setState("failed");
+    }
+  };
+  const executeBridge = useCallback3(async () => {
+    if (!quote || !chain || !token || !privateKey || !walletAddress) return;
+    try {
+      setState("executing");
+      setStepState((prev) => ({ ...prev, approval: "active" }));
+      const signer = await createSigner(privateKey, chain.id);
+      const mina = new Mina3({
+        integrator: "mina-cli",
+        autoDeposit: options.autoDeposit !== false
+      });
+      const executeResult = await mina.execute({
+        quote,
+        signer,
+        onStepChange: (stepStatus) => {
+          setCurrentStepDescription(`${stepStatus.step}: ${stepStatus.status}`);
+          if (stepStatus.step === "approval") {
+            if (stepStatus.status === "completed") {
+              setStepState((prev) => ({ ...prev, approval: "completed", bridge: "active" }));
+            } else if (stepStatus.status === "failed") {
+              setStepState((prev) => ({ ...prev, approval: "failed" }));
+            }
+          } else if (stepStatus.step === "bridge" || stepStatus.step === "swap") {
+            if (stepStatus.status === "completed") {
+              setStepState((prev) => ({ ...prev, bridge: "completed", confirm: "active" }));
+            } else if (stepStatus.status === "failed") {
+              setStepState((prev) => ({ ...prev, bridge: "failed" }));
+            }
+          } else if (stepStatus.step === "deposit") {
+            if (stepStatus.status === "completed") {
+              setStepState((prev) => ({ ...prev, confirm: "completed" }));
+            } else if (stepStatus.status === "failed") {
+              setStepState((prev) => ({ ...prev, confirm: "failed" }));
+            }
+          }
+        },
+        onStatusChange: (status) => {
+          setCurrentStepDescription(status.substatus || `Step ${status.currentStep}/${status.totalSteps}`);
+        }
+      });
+      setResult(executeResult);
+      if (executeResult.status === "completed") {
+        setStepState((prev) => ({
+          ...prev,
+          approval: "completed",
+          bridge: "completed",
+          confirm: "completed"
+        }));
+        setState("completed");
+      } else if (executeResult.status === "failed") {
+        setError(executeResult.error || new Error("Bridge execution failed"));
+        setState("failed");
+      }
+    } catch (err) {
+      const normalizedError = normalizeError(err instanceof Error ? err : new Error(String(err)));
+      setError(normalizedError);
+      const action = RECOVERY_ACTIONS[normalizedError.code];
+      if (action) {
+        setRecoveryAction(action);
+      }
+      setState("failed");
+    }
+  }, [quote, chain, token, privateKey, walletAddress, options.autoDeposit]);
+  return /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx12(Header, { compact: true, showTagline: false }),
+    /* @__PURE__ */ jsx12(Box12, { marginBottom: 1, children: /* @__PURE__ */ jsxs12(Text12, { color: theme.primary, bold: true, children: [
+      "Bridge ",
+      options.amount,
+      " ",
+      options.token,
+      " from ",
+      options.from
+    ] }) }),
+    walletAddress && /* @__PURE__ */ jsx12(Box12, { marginBottom: 1, children: /* @__PURE__ */ jsxs12(Text12, { color: theme.muted, dimColor: true, children: [
+      "Wallet: ",
+      walletAddress.slice(0, 8),
+      "...",
+      walletAddress.slice(-6)
+    ] }) }),
+    state === "loading" && /* @__PURE__ */ jsx12(Box12, { flexDirection: "column", children: /* @__PURE__ */ jsx12(BridgeProgressDisplay, { stepState }) }),
+    state === "confirming" && quote && chain && token && /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx12(
+        QuoteDisplay2,
+        {
+          quote,
+          chain,
+          token,
+          amount: options.amount
+        }
+      ),
+      !options.yes && /* @__PURE__ */ jsx12(Box12, { marginTop: 1, children: /* @__PURE__ */ jsxs12(Text12, { color: theme.warning, bold: true, children: [
+        symbols.arrow,
+        " Proceed with bridge? (y/n)"
+      ] }) }),
+      options.yes && /* @__PURE__ */ jsx12(Box12, { marginTop: 1, children: /* @__PURE__ */ jsx12(Spinner, { text: "Auto-confirming..." }) })
+    ] }),
+    state === "executing" && /* @__PURE__ */ jsx12(Box12, { flexDirection: "column", children: /* @__PURE__ */ jsx12(
+      BridgeProgressDisplay,
+      {
+        stepState,
+        currentStepDescription
+      }
+    ) }),
+    state === "completed" && result && chain && token && /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx12(BridgeProgressDisplay, { stepState }),
+      /* @__PURE__ */ jsx12(
+        SuccessDisplay,
+        {
+          result,
+          chain,
+          token,
+          amount: options.amount
+        }
+      ),
+      /* @__PURE__ */ jsx12(Box12, { marginTop: 1, children: /* @__PURE__ */ jsx12(Text12, { color: theme.muted, dimColor: true, children: "Press Enter or q to exit" }) })
+    ] }),
+    state === "failed" && error && /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx12(BridgeProgressDisplay, { stepState, error: error.message }),
+      /* @__PURE__ */ jsx12(ErrorDisplay2, { error, recoveryAction: recoveryAction || void 0 }),
+      /* @__PURE__ */ jsx12(Box12, { marginTop: 1, children: /* @__PURE__ */ jsx12(Text12, { color: theme.muted, dimColor: true, children: "Press Enter or q to exit" }) })
+    ] })
+  ] });
+}
+async function bridgeCommand(options) {
+  const { render: render2 } = await import("ink");
+  const React12 = await import("react");
+  render2(React12.createElement(Bridge, { options }));
+}
+
+// src/commands/history.tsx
+import { useState as useState7, useEffect as useEffect7 } from "react";
+import { Box as Box13, Text as Text13, useApp as useApp7 } from "ink";
+
+// src/lib/history.ts
+import os from "os";
+import fs2 from "fs";
+import path from "path";
+var HISTORY_PATH = path.join(os.homedir(), ".mina", "history.json");
+function ensureDir() {
+  const dir = path.dirname(HISTORY_PATH);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
+  }
+}
+function getHistory(limit = 10, address) {
+  ensureDir();
+  if (!fs2.existsSync(HISTORY_PATH)) {
+    return [];
+  }
+  try {
+    const data = JSON.parse(fs2.readFileSync(HISTORY_PATH, "utf-8"));
+    let entries = data.entries || [];
+    if (address) {
+      entries = entries.filter(
+        (e) => e.walletAddress?.toLowerCase() === address.toLowerCase()
+      );
+    }
+    return entries.slice(-limit).reverse();
+  } catch {
+    return [];
+  }
+}
+
+// src/commands/history.tsx
+import { Fragment, jsx as jsx13, jsxs as jsxs13 } from "react/jsx-runtime";
+function formatDate(timestamp) {
+  return new Date(timestamp).toLocaleString("en-US", {
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  });
+}
+function truncateHash2(hash) {
+  if (hash.length <= 16) return hash;
+  return `${hash.slice(0, 8)}...${hash.slice(-6)}`;
+}
+function getStatusDisplay(status) {
+  switch (status) {
+    case "completed":
+      return { icon: symbols.completed, color: theme.success, label: "Complete" };
+    case "pending":
+      return { icon: symbols.pending, color: theme.warning, label: "Pending" };
+    case "failed":
+      return { icon: symbols.failed, color: theme.error, label: "Failed" };
+    default:
+      return { icon: symbols.pending, color: theme.muted, label: "Unknown" };
+  }
+}
+function transformToRows(entries) {
+  return entries.map((entry) => {
+    const { icon, color, label } = getStatusDisplay(entry.status);
+    return {
+      date: formatDate(entry.timestamp),
+      route: `${entry.fromChain} ${symbols.arrow} ${entry.toChain}`,
+      amount: `${entry.amount} ${entry.token}`,
+      status: `${icon} ${label}`,
+      txHash: entry.txHash,
+      statusColor: color
+    };
+  });
+}
+function EmptyState({ address }) {
+  return /* @__PURE__ */ jsx13(Box13, { flexDirection: "column", children: /* @__PURE__ */ jsx13(
+    Box13,
+    {
+      borderStyle: "round",
+      borderColor: theme.border,
+      paddingX: 2,
+      paddingY: 1,
+      children: /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs13(Text13, { color: theme.muted, children: [
+          symbols.pending,
+          " No bridge history found"
+        ] }),
+        /* @__PURE__ */ jsx13(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx13(Text13, { color: theme.muted, dimColor: true, children: address ? `No transactions found for address ${truncateHash2(address)}` : "Start by running a bridge transaction with: mina bridge --from <chain> --token USDC --amount 100" }) })
+      ] })
+    }
+  ) });
+}
+function HistoryCommand({
+  limit,
+  address,
+  json = false
+}) {
+  const { exit } = useApp7();
+  const [entries, setEntries] = useState7([]);
+  const [loading, setLoading] = useState7(true);
+  useEffect7(() => {
+    const history = getHistory(limit, address);
+    setEntries(history);
+    setLoading(false);
+  }, [limit, address]);
+  useEffect7(() => {
+    if (!loading && json) {
+      setTimeout(() => exit(), 100);
+    }
+  }, [loading, json, exit]);
+  if (json) {
+    if (loading) return null;
+    console.log(JSON.stringify(entries, null, 2));
+    return null;
+  }
+  if (loading) {
+    return /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", padding: 1, children: [
+      /* @__PURE__ */ jsx13(Header, { compact: true, showTagline: false }),
+      /* @__PURE__ */ jsx13(Text13, { color: theme.muted, children: "Loading history..." })
+    ] });
+  }
+  const rows = transformToRows(entries);
+  const columns = [
+    {
+      header: "Date",
+      accessor: "date",
+      headerColor: theme.primary,
+      cellColor: theme.secondary
+    },
+    {
+      header: "Route",
+      accessor: "route",
+      headerColor: theme.primary,
+      cellColor: theme.info
+    },
+    {
+      header: "Amount",
+      accessor: "amount",
+      align: "right",
+      headerColor: theme.primary,
+      cellColor: theme.secondary
+    },
+    {
+      header: "Status",
+      accessor: "status",
+      headerColor: theme.primary,
+      cellColor: (_, row) => row.statusColor
+    }
+  ];
+  return /* @__PURE__ */ jsxs13(Box13, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx13(Header, { compact: true, showTagline: false }),
+    /* @__PURE__ */ jsx13(Box13, { marginBottom: 1, children: /* @__PURE__ */ jsxs13(Text13, { color: theme.secondary, children: [
+      symbols.arrow,
+      " Bridge History",
+      address && /* @__PURE__ */ jsxs13(Text13, { color: theme.muted, children: [
+        " (",
+        truncateHash2(address),
+        ")"
+      ] }),
+      entries.length > 0 && /* @__PURE__ */ jsxs13(Text13, { color: theme.muted, children: [
+        " - ",
+        entries.length,
+        " transaction",
+        entries.length !== 1 ? "s" : ""
+      ] })
+    ] }) }),
+    entries.length === 0 ? /* @__PURE__ */ jsx13(EmptyState, { address }) : /* @__PURE__ */ jsxs13(Fragment, { children: [
+      /* @__PURE__ */ jsx13(
+        Table,
+        {
+          data: rows,
+          columns,
+          bordered: true,
+          borderColor: theme.border
+        }
+      ),
+      /* @__PURE__ */ jsxs13(Box13, { marginTop: 1, flexDirection: "column", children: [
+        /* @__PURE__ */ jsxs13(Text13, { color: theme.muted, dimColor: true, children: [
+          "Use ",
+          '"',
+          "mina status ",
+          "<",
+          "hash",
+          '>"',
+          " for full transaction details"
+        ] }),
+        entries.length >= limit && /* @__PURE__ */ jsxs13(Text13, { color: theme.muted, dimColor: true, children: [
+          "Showing last ",
+          limit,
+          " entries. Use --limit to see more."
+        ] })
+      ] })
+    ] })
+  ] });
+}
+
+// src/commands/balance.tsx
+import React9, { useState as useState8, useEffect as useEffect8 } from "react";
+import { Box as Box14, Text as Text14, useApp as useApp8 } from "ink";
+import {
+  Mina as Mina4,
+  getChains as getChains6
+} from "@siphoyawe/mina-sdk";
+import { Fragment as Fragment2, jsx as jsx14, jsxs as jsxs14 } from "react/jsx-runtime";
+function truncateAddress2(address) {
+  if (address.length <= 14) return address;
+  return `${address.slice(0, 6)}...${address.slice(-4)}`;
+}
+function formatNumber(value, decimals = 2) {
+  if (value === 0) return "0";
+  if (value < 0.01 && value > 0) {
+    return value.toFixed(6);
+  }
+  return value.toLocaleString("en-US", {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  });
+}
+function formatUsd2(value) {
+  if (value === void 0 || value === 0) return "-";
+  return `$${formatNumber(value, 2)}`;
+}
+var MAJOR_CHAIN_IDS = [1, 42161, 137, 10, 8453];
+var CHAIN_NAMES = {
+  1: "Ethereum",
+  42161: "Arbitrum",
+  137: "Polygon",
+  10: "Optimism",
+  8453: "Base",
+  56: "BNB Chain",
+  43114: "Avalanche",
+  250: "Fantom",
+  100: "Gnosis",
+  59144: "Linea",
+  534352: "Scroll",
+  324: "zkSync"
+};
+async function resolveChainId2(chainInput) {
+  const numericId = parseInt(chainInput, 10);
+  if (!isNaN(numericId)) {
+    const response2 = await getChains6();
+    const chain2 = response2.chains.find((c) => c.id === numericId);
+    if (chain2) {
+      return { chainId: chain2.id, chainName: chain2.name };
+    }
+    return { chainId: numericId, chainName: CHAIN_NAMES[numericId] || chainInput };
+  }
+  const response = await getChains6();
+  const chainLower = chainInput.toLowerCase();
+  const chain = response.chains.find(
+    (c) => c.name.toLowerCase() === chainLower || c.key?.toLowerCase() === chainLower
+  );
+  if (chain) {
+    return { chainId: chain.id, chainName: chain.name };
+  }
+  return null;
+}
+function BalanceCommand({
+  address,
+  chain,
+  showAll = false,
+  json = false
+}) {
+  const { exit } = useApp8();
+  const [chainBalances, setChainBalances] = useState8([]);
+  const [loading, setLoading] = useState8(true);
+  const [error, setError] = useState8(null);
+  const [totalUsd, setTotalUsd] = useState8(0);
+  useEffect8(() => {
+    async function loadBalances() {
+      try {
+        setLoading(true);
+        setError(null);
+        const mina = new Mina4({ integrator: "mina-cli" });
+        let chainIds = [];
+        let chainNameMap = {};
+        if (chain) {
+          const resolved = await resolveChainId2(chain);
+          if (!resolved) {
+            setError(`Unknown chain: "${chain}"`);
+            setLoading(false);
+            return;
+          }
+          chainIds = [resolved.chainId];
+          chainNameMap[resolved.chainId] = resolved.chainName;
+        } else {
+          chainIds = MAJOR_CHAIN_IDS;
+          chainIds.forEach((id) => {
+            chainNameMap[id] = CHAIN_NAMES[id] || `Chain ${id}`;
+          });
+        }
+        const results = await Promise.all(
+          chainIds.map(async (chainId) => {
+            try {
+              const balances = await mina.getChainBalances(address, chainId);
+              return { chainId, balances };
+            } catch (err) {
+              console.warn(`Failed to fetch balances for chain ${chainId}:`, err);
+              return { chainId, balances: [] };
+            }
+          })
+        );
+        const processedChains = [];
+        let grandTotal = 0;
+        for (const result of results) {
+          const { chainId, balances } = result;
+          let filteredBalances = balances.filter((b) => {
+            return showAll || b.hasBalance;
+          });
+          const chainTotal = balances.reduce((sum, b) => {
+            return sum + (b.balanceUsd || 0);
+          }, 0);
+          grandTotal += chainTotal;
+          const balanceRows = filteredBalances.map((b) => ({
+            symbol: b.token.symbol,
+            balance: b.balance,
+            balanceFormatted: b.formatted,
+            usdValue: b.balanceUsd,
+            hasBalance: b.hasBalance
+          }));
+          balanceRows.sort((a, b) => {
+            if (a.hasBalance !== b.hasBalance) {
+              return a.hasBalance ? -1 : 1;
+            }
+            return (b.usdValue || 0) - (a.usdValue || 0);
+          });
+          if (balanceRows.length > 0 || showAll) {
+            processedChains.push({
+              chainId,
+              chainName: chainNameMap[chainId] || `Chain ${chainId}`,
+              balances: balanceRows,
+              totalUsd: chainTotal
+            });
+          }
+        }
+        processedChains.sort((a, b) => b.totalUsd - a.totalUsd);
+        setChainBalances(processedChains);
+        setTotalUsd(grandTotal);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Failed to load balances");
+      } finally {
+        setLoading(false);
+      }
+    }
+    loadBalances();
+  }, [address, chain, showAll]);
+  useEffect8(() => {
+    if (!loading && json) {
+      setTimeout(() => exit(), 100);
+    }
+  }, [loading, json, exit]);
+  if (json) {
+    if (loading) return null;
+    if (error) {
+      console.error(JSON.stringify({ error }, null, 2));
+      return null;
+    }
+    console.log(JSON.stringify({
+      address,
+      chains: chainBalances.map((cb) => ({
+        chainId: cb.chainId,
+        chainName: cb.chainName,
+        balances: cb.balances,
+        totalUsd: cb.totalUsd
+      })),
+      totalUsd
+    }, null, 2));
+    return null;
+  }
+  if (loading) {
+    return /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", padding: 1, children: [
+      /* @__PURE__ */ jsx14(Header, { compact: true, showTagline: false }),
+      /* @__PURE__ */ jsx14(Spinner, { text: chain ? `Loading balances on ${chain}...` : "Loading balances across chains..." })
+    ] });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", padding: 1, children: [
+      /* @__PURE__ */ jsx14(Header, { compact: true, showTagline: false }),
+      /* @__PURE__ */ jsx14(Box14, { children: /* @__PURE__ */ jsxs14(Text14, { color: theme.error, children: [
+        symbols.failed,
+        " Error: ",
+        error
+      ] }) })
+    ] });
+  }
+  const maxSymbolWidth = Math.max(
+    8,
+    ...chainBalances.flatMap((cb) => cb.balances.map((b) => b.symbol.length))
+  );
+  const maxBalanceWidth = Math.max(
+    12,
+    ...chainBalances.flatMap((cb) => cb.balances.map((b) => b.balanceFormatted.length))
+  );
+  const boxWidth = Math.max(40, maxSymbolWidth + maxBalanceWidth + 20);
+  const hasAnyBalances = chainBalances.some((cb) => cb.balances.length > 0);
+  return /* @__PURE__ */ jsxs14(Box14, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx14(Header, { compact: true, showTagline: false }),
+    /* @__PURE__ */ jsx14(Box14, { children: /* @__PURE__ */ jsxs14(Text14, { color: theme.border, children: [
+      borders.topLeft,
+      borders.horizontal.repeat(boxWidth - 2),
+      borders.topRight
+    ] }) }),
+    /* @__PURE__ */ jsxs14(Box14, { children: [
+      /* @__PURE__ */ jsx14(Text14, { color: theme.border, children: borders.vertical }),
+      /* @__PURE__ */ jsx14(Box14, { width: boxWidth - 2, justifyContent: "center", children: /* @__PURE__ */ jsxs14(Text14, { color: theme.primary, bold: true, children: [
+        "Balances: ",
+        truncateAddress2(address)
+      ] }) }),
+      /* @__PURE__ */ jsx14(Text14, { color: theme.border, children: borders.vertical })
+    ] }),
+    /* @__PURE__ */ jsx14(Box14, { children: /* @__PURE__ */ jsxs14(Text14, { color: theme.border, children: [
+      borders.leftT,
+      borders.horizontal.repeat(boxWidth - 2),
+      borders.rightT
+    ] }) }),
+    !hasAnyBalances ? /* @__PURE__ */ jsx14(Fragment2, { children: /* @__PURE__ */ jsxs14(Box14, { children: [
+      /* @__PURE__ */ jsx14(Text14, { color: theme.border, children: borders.vertical }),
+      /* @__PURE__ */ jsx14(Box14, { width: boxWidth - 2, justifyContent: "center", children: /* @__PURE__ */ jsx14(Text14, { color: theme.muted, children: "No balances found" }) }),
+      /* @__PURE__ */ jsx14(Text14, { color: theme.border, children: borders.vertical })
+    ] }) }) : chainBalances.map((chainData, chainIndex) => /* @__PURE__ */ jsxs14(React9.Fragment, { children: [
+      /* @__PURE__ */ jsxs14(Box14, { children: [
+        /* @__PURE__ */ jsx14(Text14, { color: theme.border, children: borders.vertical }),
+        /* @__PURE__ */ jsx14(Text14, { children: "  " }),
+        /* @__PURE__ */ jsx14(Text14, { color: theme.accent, bold: true, children: chainData.chainName }),
+        /* @__PURE__ */ jsx14(Box14, { flexGrow: 1 }),
+        /* @__PURE__ */ jsx14(Text14, { color: theme.border, children: borders.vertical })
+      ] }),
+      chainData.balances.length === 0 ? /* @__PURE__ */ jsxs14(Box14, { children: [
+        /* @__PURE__ */ jsx14(Text14, { color: theme.border, children: borders.vertical }),
+        /* @__PURE__ */ jsx14(Text14, { children: "    " }),
+        /* @__PURE__ */ jsx14(Text14, { color: theme.muted, dimColor: true, children: "No balances" }),
+        /* @__PURE__ */ jsx14(Box14, { flexGrow: 1 }),
+        /* @__PURE__ */ jsx14(Text14, { color: theme.border, children: borders.vertical })
+      ] }) : chainData.balances.map((balance, i) => /* @__PURE__ */ jsxs14(Box14, { children: [
+        /* @__PURE__ */ jsx14(Text14, { color: theme.border, children: borders.vertical }),
+        /* @__PURE__ */ jsx14(Text14, { children: "    " }),
+        /* @__PURE__ */ jsx14(
+          Text14,
+          {
+            color: balance.hasBalance ? theme.success : theme.muted,
+            dimColor: !balance.hasBalance,
+            children: balance.symbol.padEnd(maxSymbolWidth)
+          }
+        ),
+        /* @__PURE__ */ jsx14(Text14, { children: "  " }),
+        /* @__PURE__ */ jsx14(
+          Text14,
+          {
+            color: balance.hasBalance ? theme.secondary : theme.muted,
+            dimColor: !balance.hasBalance,
+            children: balance.balanceFormatted.padStart(maxBalanceWidth)
+          }
+        ),
+        /* @__PURE__ */ jsx14(Text14, { children: "  " }),
+        /* @__PURE__ */ jsx14(
+          Text14,
+          {
+            color: balance.hasBalance ? theme.muted : theme.muted,
+            dimColor: !balance.hasBalance,
+            children: formatUsd2(balance.usdValue).padStart(12)
+          }
+        ),
+        /* @__PURE__ */ jsx14(Box14, { flexGrow: 1 }),
+        /* @__PURE__ */ jsx14(Text14, { color: theme.border, children: borders.vertical })
+      ] }, `${chainData.chainId}-${balance.symbol}-${i}`)),
+      chainIndex < chainBalances.length - 1 && /* @__PURE__ */ jsx14(Box14, { children: /* @__PURE__ */ jsxs14(Text14, { color: theme.border, children: [
+        borders.leftT,
+        borders.horizontal.repeat(boxWidth - 2),
+        borders.rightT
+      ] }) })
+    ] }, chainData.chainId)),
+    /* @__PURE__ */ jsx14(Box14, { children: /* @__PURE__ */ jsxs14(Text14, { color: theme.border, children: [
+      borders.bottomLeft,
+      borders.horizontal.repeat(boxWidth - 2),
+      borders.bottomRight
+    ] }) }),
+    hasAnyBalances && totalUsd > 0 && /* @__PURE__ */ jsxs14(Box14, { marginTop: 1, children: [
+      /* @__PURE__ */ jsxs14(Text14, { color: theme.secondary, children: [
+        symbols.arrow,
+        " Total:"
+      ] }),
+      /* @__PURE__ */ jsxs14(Text14, { color: theme.success, bold: true, children: [
+        " ",
+        "$",
+        formatNumber(totalUsd, 2)
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx14(Box14, { marginTop: 1, children: /* @__PURE__ */ jsx14(Text14, { color: theme.muted, dimColor: true, children: chain ? "Use --all to show zero balances" : "Use --chain <name> for specific chain, --all for zero balances" }) })
+  ] });
+}
+
+// src/commands/config.tsx
+import { useState as useState9, useEffect as useEffect9 } from "react";
+import { Box as Box15, Text as Text15, useApp as useApp9 } from "ink";
+
+// src/lib/config.ts
+import os2 from "os";
+import fs3 from "fs";
+import path2 from "path";
+var CONFIG_PATH = path2.join(os2.homedir(), ".mina", "config.json");
+var DEFAULT_CONFIG = {
+  slippage: 0.5,
+  autoDeposit: true,
+  defaultChain: "arbitrum",
+  rpc: {}
+};
+var VALID_KEYS = ["slippage", "autoDeposit", "defaultChain", "rpc"];
+function ensureDir2() {
+  const dir = path2.dirname(CONFIG_PATH);
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
+  }
+}
+function getConfig() {
+  ensureDir2();
+  if (!fs3.existsSync(CONFIG_PATH)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const data = JSON.parse(fs3.readFileSync(CONFIG_PATH, "utf-8"));
+    return {
+      ...DEFAULT_CONFIG,
+      ...data,
+      // Ensure rpc is always an object
+      rpc: { ...DEFAULT_CONFIG.rpc, ...data.rpc || {} }
+    };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function parseValue(value) {
+  if (value.toLowerCase() === "true") return true;
+  if (value.toLowerCase() === "false") return false;
+  const num = Number(value);
+  if (!isNaN(num) && value.trim() !== "") return num;
+  return value;
+}
+function isValidKey(key) {
+  const parts = key.split(".");
+  if (parts.length === 2 && parts[0] === "rpc") {
+    return true;
+  }
+  return VALID_KEYS.includes(key);
+}
+function setConfig(key, value) {
+  ensureDir2();
+  const config = getConfig();
+  const keys = key.split(".");
+  const rpcKey = keys[1];
+  if (keys.length === 2 && keys[0] === "rpc" && rpcKey) {
+    config.rpc[rpcKey] = value;
+  } else if (VALID_KEYS.includes(key)) {
+    config[key] = value;
+  } else {
+    throw new Error(`Unknown config key: ${key}`);
+  }
+  fs3.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+function getConfigValue(key) {
+  const config = getConfig();
+  const keys = key.split(".");
+  const rpcKey = keys[1];
+  if (keys.length === 2 && keys[0] === "rpc" && rpcKey) {
+    return config.rpc[rpcKey] ?? null;
+  }
+  if (VALID_KEYS.includes(key)) {
+    return config[key];
+  }
+  return void 0;
+}
+function getConfigList() {
+  const config = getConfig();
+  const savedConfig = fs3.existsSync(CONFIG_PATH) ? JSON.parse(fs3.readFileSync(CONFIG_PATH, "utf-8")) : {};
+  const items = [];
+  items.push({
+    key: "slippage",
+    value: String(config.slippage),
+    isDefault: savedConfig.slippage === void 0
+  });
+  items.push({
+    key: "autoDeposit",
+    value: String(config.autoDeposit),
+    isDefault: savedConfig.autoDeposit === void 0
+  });
+  items.push({
+    key: "defaultChain",
+    value: config.defaultChain,
+    isDefault: savedConfig.defaultChain === void 0
+  });
+  const commonChains = ["ethereum", "arbitrum", "polygon", "optimism", "base"];
+  for (const chain of commonChains) {
+    const customRpc = config.rpc[chain];
+    items.push({
+      key: `rpc.${chain}`,
+      value: customRpc || "(default)",
+      isDefault: !customRpc
+    });
+  }
+  for (const [chain, url] of Object.entries(config.rpc)) {
+    if (!commonChains.includes(chain) && url) {
+      items.push({
+        key: `rpc.${chain}`,
+        value: url,
+        isDefault: false
+      });
+    }
+  }
+  return items;
+}
+function getConfigPath() {
+  return CONFIG_PATH;
+}
+
+// src/commands/config.tsx
+import { jsx as jsx15, jsxs as jsxs15 } from "react/jsx-runtime";
+function ConfigList() {
+  const { exit } = useApp9();
+  const [items, setItems] = useState9([]);
+  useEffect9(() => {
+    const configItems = getConfigList();
+    setItems(
+      configItems.map((item) => ({
+        setting: item.key,
+        value: item.value,
+        isDefault: item.isDefault
+      }))
+    );
+    setTimeout(() => exit(), 100);
+  }, [exit]);
+  const columns = [
+    {
+      header: "Setting",
+      accessor: "setting",
+      headerColor: theme.primary,
+      cellColor: theme.secondary
+    },
+    {
+      header: "Value",
+      accessor: "value",
+      headerColor: theme.primary,
+      cellColor: (value, row) => row.isDefault ? theme.muted : theme.success
+    }
+  ];
+  return /* @__PURE__ */ jsxs15(Box15, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx15(Header, { compact: true, showTagline: false }),
+    /* @__PURE__ */ jsx15(Box15, { marginBottom: 1, children: /* @__PURE__ */ jsxs15(Text15, { color: theme.secondary, children: [
+      symbols.arrow,
+      " Configuration Settings"
+    ] }) }),
+    /* @__PURE__ */ jsx15(Table, { data: items, columns, bordered: true, borderColor: theme.border }),
+    /* @__PURE__ */ jsx15(Box15, { marginTop: 1, children: /* @__PURE__ */ jsx15(Text15, { color: theme.muted, dimColor: true, children: "Values in gray are defaults. Use 'mina config set <key> <value>' to customize." }) })
+  ] });
+}
+function ConfigGet({ configKey }) {
+  const { exit } = useApp9();
+  const [value, setValue] = useState9(null);
+  const [error, setError] = useState9(null);
+  useEffect9(() => {
+    if (!isValidKey(configKey)) {
+      setError(`Unknown config key: ${configKey}`);
+    } else {
+      const val = getConfigValue(configKey);
+      setValue(val === void 0 || val === null ? "(not set)" : String(val));
+    }
+    setTimeout(() => exit(), 100);
+  }, [configKey, exit]);
+  if (error) {
+    return /* @__PURE__ */ jsxs15(Box15, { flexDirection: "column", padding: 1, children: [
+      /* @__PURE__ */ jsx15(Header, { compact: true, showTagline: false }),
+      /* @__PURE__ */ jsx15(Box15, { children: /* @__PURE__ */ jsxs15(Text15, { color: theme.error, children: [
+        symbols.failed,
+        " ",
+        error
+      ] }) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs15(Box15, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx15(Header, { compact: true, showTagline: false }),
+    /* @__PURE__ */ jsxs15(Box15, { children: [
+      /* @__PURE__ */ jsx15(Text15, { color: theme.secondary, children: configKey }),
+      /* @__PURE__ */ jsx15(Text15, { color: theme.muted, children: " = " }),
+      /* @__PURE__ */ jsx15(Text15, { color: theme.primary, children: value })
+    ] })
+  ] });
+}
+function ConfigSet({ configKey, configValue }) {
+  const { exit } = useApp9();
+  const [success, setSuccess] = useState9(false);
+  const [error, setError] = useState9(null);
+  const [parsedValue, setParsedValue] = useState9(null);
+  useEffect9(() => {
+    if (!isValidKey(configKey)) {
+      setError(`Unknown config key: ${configKey}`);
+    } else {
+      try {
+        const parsed = parseValue(configValue);
+        setParsedValue(parsed);
+        setConfig(configKey, parsed);
+        setSuccess(true);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Failed to set value");
+      }
+    }
+    setTimeout(() => exit(), 100);
+  }, [configKey, configValue, exit]);
+  if (error) {
+    return /* @__PURE__ */ jsxs15(Box15, { flexDirection: "column", padding: 1, children: [
+      /* @__PURE__ */ jsx15(Header, { compact: true, showTagline: false }),
+      /* @__PURE__ */ jsx15(Box15, { children: /* @__PURE__ */ jsxs15(Text15, { color: theme.error, children: [
+        symbols.failed,
+        " ",
+        error
+      ] }) })
+    ] });
+  }
+  if (success) {
+    return /* @__PURE__ */ jsxs15(Box15, { flexDirection: "column", padding: 1, children: [
+      /* @__PURE__ */ jsx15(Header, { compact: true, showTagline: false }),
+      /* @__PURE__ */ jsxs15(Box15, { children: [
+        /* @__PURE__ */ jsxs15(Text15, { color: theme.success, children: [
+          symbols.completed,
+          " "
+        ] }),
+        /* @__PURE__ */ jsx15(Text15, { color: theme.secondary, children: "Set " }),
+        /* @__PURE__ */ jsx15(Text15, { color: theme.primary, children: configKey }),
+        /* @__PURE__ */ jsx15(Text15, { color: theme.muted, children: " = " }),
+        /* @__PURE__ */ jsx15(Text15, { color: theme.success, children: String(parsedValue) })
+      ] })
+    ] });
+  }
+  return null;
+}
+function ConfigPath() {
+  const { exit } = useApp9();
+  useEffect9(() => {
+    setTimeout(() => exit(), 100);
+  }, [exit]);
+  return /* @__PURE__ */ jsxs15(Box15, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx15(Header, { compact: true, showTagline: false }),
+    /* @__PURE__ */ jsxs15(Box15, { children: [
+      /* @__PURE__ */ jsx15(Text15, { color: theme.muted, children: "Config file: " }),
+      /* @__PURE__ */ jsx15(Text15, { color: theme.secondary, children: getConfigPath() })
+    ] })
+  ] });
+}
+function ConfigHelp() {
+  const { exit } = useApp9();
+  useEffect9(() => {
+    setTimeout(() => exit(), 100);
+  }, [exit]);
+  return /* @__PURE__ */ jsxs15(Box15, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx15(Header, { compact: true, showTagline: false }),
+    /* @__PURE__ */ jsx15(Box, { bordered: true, title: "Config Usage", padding: 1, children: /* @__PURE__ */ jsxs15(Box15, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx15(Text15, { color: theme.secondary, children: "mina config list" }),
+      /* @__PURE__ */ jsx15(Text15, { color: theme.muted, children: "  Show all settings" }),
+      /* @__PURE__ */ jsx15(Text15, { children: " " }),
+      /* @__PURE__ */ jsx15(Text15, { color: theme.secondary, children: "mina config get <key>" }),
+      /* @__PURE__ */ jsx15(Text15, { color: theme.muted, children: "  Show single value" }),
+      /* @__PURE__ */ jsx15(Text15, { children: " " }),
+      /* @__PURE__ */ jsx15(Text15, { color: theme.secondary, children: "mina config set <key> <value>" }),
+      /* @__PURE__ */ jsx15(Text15, { color: theme.muted, children: "  Set a value" }),
+      /* @__PURE__ */ jsx15(Text15, { children: " " }),
+      /* @__PURE__ */ jsx15(Text15, { color: theme.secondary, children: "mina config path" }),
+      /* @__PURE__ */ jsx15(Text15, { color: theme.muted, children: "  Show config file location" })
+    ] }) }),
+    /* @__PURE__ */ jsx15(Box15, { marginTop: 1, children: /* @__PURE__ */ jsx15(Box, { bordered: true, title: "Available Settings", padding: 1, children: /* @__PURE__ */ jsxs15(Box15, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsxs15(Box15, { children: [
+        /* @__PURE__ */ jsx15(Text15, { color: theme.primary, bold: true, children: "slippage" }),
+        /* @__PURE__ */ jsx15(Text15, { color: theme.muted, children: " - Default slippage tolerance (e.g., 0.5)" })
+      ] }),
+      /* @__PURE__ */ jsxs15(Box15, { children: [
+        /* @__PURE__ */ jsx15(Text15, { color: theme.primary, bold: true, children: "autoDeposit" }),
+        /* @__PURE__ */ jsx15(Text15, { color: theme.muted, children: " - Auto-deposit to Hyperliquid (true/false)" })
+      ] }),
+      /* @__PURE__ */ jsxs15(Box15, { children: [
+        /* @__PURE__ */ jsx15(Text15, { color: theme.primary, bold: true, children: "defaultChain" }),
+        /* @__PURE__ */ jsx15(Text15, { color: theme.muted, children: " - Default source chain (e.g., arbitrum)" })
+      ] }),
+      /* @__PURE__ */ jsxs15(Box15, { children: [
+        /* @__PURE__ */ jsx15(Text15, { color: theme.primary, bold: true, children: "rpc.<chain>" }),
+        /* @__PURE__ */ jsx15(Text15, { color: theme.muted, children: " - Custom RPC URL for a chain" })
+      ] })
+    ] }) }) }),
+    /* @__PURE__ */ jsx15(Box15, { marginTop: 1, children: /* @__PURE__ */ jsx15(Box, { bordered: true, title: "Examples", padding: 1, children: /* @__PURE__ */ jsxs15(Box15, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx15(Text15, { color: theme.secondary, children: "mina config set slippage 0.5" }),
+      /* @__PURE__ */ jsx15(Text15, { color: theme.secondary, children: "mina config set autoDeposit false" }),
+      /* @__PURE__ */ jsx15(Text15, { color: theme.secondary, children: "mina config set rpc.arbitrum https://arb1.example.com" }),
+      /* @__PURE__ */ jsx15(Text15, { color: theme.secondary, children: "mina config get slippage" })
+    ] }) }) })
+  ] });
+}
+function ConfigCommand({ action, key: configKey, value }) {
+  switch (action) {
+    case "list":
+      return /* @__PURE__ */ jsx15(ConfigList, {});
+    case "get":
+      if (!configKey) {
+        return /* @__PURE__ */ jsx15(ConfigHelp, {});
+      }
+      return /* @__PURE__ */ jsx15(ConfigGet, { configKey });
+    case "set":
+      if (!configKey || value === void 0) {
+        return /* @__PURE__ */ jsx15(ConfigHelp, {});
+      }
+      return /* @__PURE__ */ jsx15(ConfigSet, { configKey, configValue: value });
+    case "path":
+      return /* @__PURE__ */ jsx15(ConfigPath, {});
+    default:
+      return /* @__PURE__ */ jsx15(ConfigHelp, {});
+  }
+}
+
+// src/index.tsx
+var VERSION = "1.0.0";
+var program = new Command();
+program.name("mina").description("Mina Bridge CLI - Bridge assets from any chain to Hyperliquid").version(VERSION, "-v, --version", "Display the current version").helpOption("-h, --help", "Display help information");
+program.command("wizard").description("Launch the interactive bridge wizard").action(() => {
+  render(React11.createElement(Wizard));
+});
+program.command("quote").description("Get a bridge quote").requiredOption("--from <chain>", "Source chain (e.g., ethereum, arbitrum, polygon)").option("--to <chain>", "Destination chain", "hyperliquid").requiredOption("--token <symbol>", "Token to bridge (e.g., USDC, ETH)").requiredOption("--amount <number>", "Amount to bridge").option("--json", "Output as JSON for machine-readable format").action((options) => {
+  render(
+    React11.createElement(QuoteDisplay, {
+      fromChain: options.from,
+      toChain: options.to,
+      token: options.token,
+      amount: options.amount,
+      jsonOutput: options.json || false
+    })
+  );
+});
+program.command("status <txHash>").description("Check bridge status").option("--watch", "Poll for updates").action((txHash, options) => {
+  render(
+    React11.createElement(Status, {
+      txHash,
+      watch: options.watch || false
+    })
+  );
+});
+program.command("chains").description("List supported chains").option("--json", "Output as JSON").action((options) => {
+  render(
+    React11.createElement(ChainsCommand, {
+      json: options.json || false
+    })
+  );
+});
+program.command("tokens").description("List bridgeable tokens").option("--chain <chain>", "Filter by chain (name or ID)").option("--json", "Output as JSON").action((options) => {
+  render(
+    React11.createElement(TokensCommand, {
+      chain: options.chain,
+      json: options.json || false
+    })
+  );
+});
+program.command("bridge").description("Execute a bridge transaction").requiredOption("--from <chain>", "Source chain (e.g., arbitrum, ethereum, polygon)").requiredOption("--token <symbol>", "Token to bridge (e.g., USDC, ETH)").requiredOption("--amount <number>", "Amount to bridge").option("--key <path>", "Path to private key file (JSON or plain text)").option("--yes", "Skip confirmation prompt").option("--auto-deposit", "Auto-deposit to Hyperliquid L1", true).action((options) => {
+  bridgeCommand(options);
+});
+program.command("history").description("View bridge transaction history").option("--limit <number>", "Number of entries to show", "10").option("--address <address>", "Filter by wallet address").option("--json", "Output as JSON").action((options) => {
+  render(
+    React11.createElement(HistoryCommand, {
+      limit: parseInt(options.limit, 10) || 10,
+      address: options.address,
+      json: options.json || false
+    })
+  );
+});
+program.command("balance").description("Check wallet balances").requiredOption("--address <address>", "Wallet address").option("--chain <chain>", "Specific chain (name or ID)").option("--all", "Show all tokens including zero balance").option("--json", "Output as JSON").action((options) => {
+  render(
+    React11.createElement(BalanceCommand, {
+      address: options.address,
+      chain: options.chain,
+      showAll: options.all || false,
+      json: options.json || false
+    })
+  );
+});
+program.command("config [action] [key] [value]").description("Manage CLI configuration").action((action, key, value) => {
+  render(
+    React11.createElement(ConfigCommand, {
+      action,
+      key,
+      value
+    })
+  );
+});
+program.addHelpText("after", `
+${chalk.bold("Examples:")}
+  ${chalk.dim("# Launch interactive wizard (default when no command given)")}
+  $ mina
+
+  ${chalk.dim("# Get a bridge quote")}
+  $ mina quote --from arbitrum --token USDC --amount 100
+  $ mina quote --from ethereum --token ETH --amount 0.5 --json
+
+  ${chalk.dim("# Bridge USDC from Ethereum to Hyperliquid")}
+  $ mina bridge --from arbitrum --token USDC --amount 100 --key ./key.json
+  $ mina bridge --from ethereum --token ETH --amount 0.5 --yes
+
+  ${chalk.dim("# Check transaction status")}
+  $ mina status 0x1234...abcd
+  $ mina status 0x1234...abcd --watch
+
+  ${chalk.dim("# View supported chains and tokens")}
+  $ mina chains
+  $ mina tokens --chain arbitrum
+  $ mina tokens --chain 1
+
+  ${chalk.dim("# View bridge transaction history")}
+  $ mina history
+  $ mina history --limit 20
+  $ mina history --address 0x1234...abcd
+  $ mina history --json
+
+  ${chalk.dim("# Check wallet balances")}
+  $ mina balance --address 0x1234...abcd
+  $ mina balance --address 0x1234...abcd --chain arbitrum
+  $ mina balance --address 0x1234...abcd --all
+  $ mina balance --address 0x1234...abcd --json
+
+  ${chalk.dim("# Manage configuration")}
+  $ mina config list
+  $ mina config get slippage
+  $ mina config set slippage 0.5
+  $ mina config set rpc.arbitrum https://arb1.example.com
+
+${chalk.bold("Documentation:")}
+  https://github.com/siphoyawe/mina-sdk
+`);
+var args = process.argv.slice(2);
+var hasCommand = args.length > 0 && !args[0]?.startsWith("-");
+var isHelpOrVersion = args.some((arg) => ["-h", "--help", "-v", "--version"].includes(arg));
+if (!hasCommand && !isHelpOrVersion) {
+  render(React11.createElement(Wizard));
+} else {
+  program.parse(process.argv);
+}
+//# sourceMappingURL=index.js.map