@token2chat/t2c 0.2.0-beta.1 → 0.2.0

package/README.md

@@ -1,188 +1,161 @@
-# t2c - Token2Chat CLI
+# t2c — Pay for AI with Ecash
 
-Pay-per-request LLM access via Cashu ecash.
+> CLI + local proxy that makes any AI tool work with token2chat. No accounts, no API keys.
 
-## Installation
+t2c manages a local Cashu ecash wallet and runs a proxy that auto-attaches payment tokens to your LLM requests. Point your AI tool at `localhost:10402` and it just works.
 
-```bash
-npm install -g @token2chat/cli
-```
-
-## Quick Start
-
-```bash
-# 1. Run setup wizard
-t2c setup
-
-# 2. Start the proxy service
-t2c service start
-
-# 3. Add funds to your wallet
-t2c mint
-
-# 4. Configure your AI tool
-t2c config openclaw --apply  # For OpenClaw (auto-merge)
-t2c config cursor            # For Cursor
-t2c config env               # For other tools
-
-# 5. (Optional) Install as system service for auto-start
-t2c service install
-```
-
-## Commands
+Built by an autonomous AI agent.
 
-### `t2c setup`
-Interactive setup wizard. Configures Gate URL, Mint URL, proxy port, and wallet path.
-
-### `t2c status`
-Show service status and wallet balance.
+## Install
 
 ```bash
-t2c status          # Pretty output
-t2c status --json   # JSON output
+npm install -g @token2chat/t2c
 ```
 
-### `t2c service`
-Manage the local proxy service.
+## Quick Start
 
 ```bash
-t2c service start           # Start as daemon
-t2c service start -f        # Run in foreground
-t2c service stop            # Stop the service
-t2c service restart         # Restart the service
-t2c service status          # Show detailed service status
-t2c service logs            # Show logs
-t2c service logs -f         # Follow logs
-
-# System service management (auto-start on login)
-t2c service install         # Install as launchd (macOS) or systemd (Linux)
-t2c service uninstall       # Uninstall system service
-```
+# 1. Initialize wallet and config
+t2c init
 
-### `t2c mint`
-Add funds to your wallet.
+# 2. Fund your wallet via Lightning
+t2c mint 5000              # creates invoice for 5000 sats
+t2c mint --check <quote>   # check payment & mint ecash
 
-```bash
-t2c mint              # Show deposit address
-t2c mint --check      # Check for pending deposits
-t2c mint 1000         # Create Lightning invoice for 1000 sat
-```
+# 3. Connect your AI tool
+t2c connect cursor         # or: openclaw, cline, aider, continue, env
+t2c service start          # start the local proxy
 
-### `t2c config`
-Generate configuration for AI tools.
-
-```bash
-t2c config list             # List supported tools
-t2c config openclaw         # Show OpenClaw config
-t2c config openclaw --apply # Apply to openclaw.json (creates backup)
-t2c config openclaw --json  # Output raw JSON
-t2c config cursor           # Show Cursor config
-t2c config env              # Show environment variables
+# 4. Use AI as normal — t2c handles payment automatically
 ```
 
-## Architecture
+## How It Works
 
 ```
-┌─────────────┐     ┌──────────────────┐     ┌──────────┐
-│  AI Tool    │────▶│  t2c proxy       │────▶│   Gate   │
-│  (OpenClaw, │     │  :10402 (ecash)   │     │          │
-│   Cursor,   │     └──────────────────┘     └──────────┘
-│   etc.)     │
-└─────────────┘
+Your AI Tool (Cursor, Cline, OpenClaw, etc.)
+    │
+    │  POST http://127.0.0.1:10402/v1/chat/completions
+    │  Authorization: Bearer <proxy-secret>
+    ▼
+t2c proxy (local)
+    │  1. Estimate price from request
+    │  2. Select ecash proofs from wallet
+    │  3. Encode as Cashu V4 token
+    │  4. Attach X-Cashu header
+    │  5. Forward to Gate
+    ▼
+Gate (gate.token2chat.com)
+    │  6. Verify ecash, proxy to LLM
+    │  7. Return response + change token
+    ▼
+Response flows back to your AI tool
+(t2c reclaims change into wallet)
 ```
 
-The proxy:
-1. Receives OpenAI-compatible requests from AI tools
-2. Selects ecash tokens from your local wallet
-3. Forwards requests to the Gate with payment
-4. Handles change/refund tokens automatically
-5. Returns the LLM response to your AI tool
+## CLI Reference
+
+### Wallet
+
+| Command | Description |
+|---------|-------------|
+| `t2c init` | Initialize config + wallet |
+| `t2c balance` | Show wallet balance (in USD) |
+| `t2c mint [amount]` | Fund wallet via Lightning invoice |
+| `t2c mint --check <quote>` | Check payment and mint ecash |
+| `t2c recover` | Recover failed change/refund tokens |
+| `t2c audit` | Full fund audit (wallet + mint + gate + anomalies) |
+
+### Proxy Service
+
+| Command | Description |
+|---------|-------------|
+| `t2c service start` | Start local proxy (foreground) |
+| `t2c service stop` | Stop proxy |
+| `t2c service restart` | Restart proxy |
+| `t2c service status` | Show proxy status |
+| `t2c service logs` | View proxy logs |
+| `t2c service install` | Install as system service (launchd/systemd) |
+| `t2c service uninstall` | Remove system service |
+
+### Integration
+
+| Command | Description |
+|---------|-------------|
+| `t2c connect <app>` | Auto-configure an AI tool |
+| `t2c config <tool>` | Print config snippet for a specific tool |
+| `t2c status` | Service status + balance overview |
+| `t2c monitor` | Live TUI dashboard |
+| `t2c doctor` | Self-diagnostic |
+
+### Supported AI Tools
+
+| Tool | Command | What it does |
+|------|---------|-------------|
+| **Cursor** | `t2c connect cursor` | Writes proxy URL + key to Cursor config |
+| **OpenClaw** | `t2c connect openclaw` | Adds provider to OpenClaw config |
+| **Cline** | `t2c connect cline` | Configures VS Code extension |
+| **Continue** | `t2c connect continue` | Configures Continue extension |
+| **Aider** | `t2c connect aider` | Sets environment variables |
+| **Any tool** | `t2c connect env` | Prints env vars to export manually |
 
 ## Configuration
 
-Config is stored in `~/.t2c/config.json`:
+Config is stored at `~/.t2c/config.json`.
 
-```json
-{
-  "gateUrl": "https://gate.token2chat.com",
-  "mintUrl": "https://mint.token2chat.com",
-  "walletPath": "~/.t2c/wallet.json",
-  "proxyPort": 10402,
-  "lowBalanceThreshold": 1000
-}
-```
+| Field | Default | Description |
+|-------|---------|-------------|
+| `gate` | `https://gate.token2chat.com` | Gate URL |
+| `mint` | `https://mint.token2chat.com` | Mint URL |
+| `proxy.port` | `10402` | Local proxy port |
+| `proxy.secret` | (auto-generated) | Bearer token for proxy auth |
+| `wallet` | `~/.t2c/wallet.json` | Wallet file path |
 
-## System Service
+### Gate Discovery
 
-### macOS (launchd)
+t2c automatically discovers available gates from [token2.cash/gates.json](https://token2.cash/gates.json). If your primary gate is down, it fails over to other healthy gates that support your model.
 
-```bash
-# Install
-t2c service install
+## Security
 
-# Load manually
-launchctl load ~/Library/LaunchAgents/com.token2chat.proxy.plist
+- **Local proxy auth** — Bearer token with timing-safe comparison
+- **Wallet file** — 0o600 permissions, only readable by owner
+- **Config directory** — 0o700 permissions
+- **Mutex-protected wallet** — no concurrent double-spend from overlapping requests
+- **Failed token persistence** — tokens that fail to process are saved for recovery
+- **No tracking** — ecash is bearer money; the gate never knows who you are
 
-# Uninstall
-t2c service uninstall
-```
+## Wallet
 
-### Linux (systemd)
+The wallet stores Cashu ecash proofs locally at `~/.t2c/wallet.json`.
 
-```bash
-# Install
-t2c service install
+- **Unit**: USD (1 unit = $0.00001, displayed as dollars)
+- **Proof selection**: largest-first greedy (minimizes number of proofs per payment)
+- **Change handling**: automatically reclaimed from gate responses (header or SSE event)
+- **Funding**: Lightning invoices via `t2c mint`
 
-# Enable and start
-systemctl --user daemon-reload
-systemctl --user enable t2c-proxy.service
-systemctl --user start t2c-proxy.service
+### Balance Display
 
-# Uninstall
-t2c service uninstall
+```bash
+$ t2c balance
+Wallet: $4.52 (452,000 units, 23 proofs)
+Mint: https://mint.token2chat.com
 ```
 
-## Supported AI Tools
-
-| Tool | Command | Notes |
-|------|---------|-------|
-| OpenClaw | `t2c config openclaw --apply` | Auto-merges token2chat provider |
-| Cursor | `t2c config cursor` | OpenAI base URL config |
-| Generic | `t2c config env` | OPENAI_API_KEY + OPENAI_BASE_URL |
-
-Any tool that supports OpenAI-compatible APIs can use Token2Chat.
-
-## Error Handling
-
-The CLI handles various error conditions gracefully:
-
-- **No config**: Prompts to run `t2c setup`
-- **No wallet**: Creates one automatically
-- **Corrupted config**: Auto-recovers with backup
-- **Network timeout**: Retries with exponential backoff
-- **Insufficient balance**: Clear error message with balance info
+## System Service
 
-## Development
+Install t2c as a background service that starts on boot:
 
 ```bash
-# Clone and install
-git clone https://github.com/token2chat/cli.git
-cd cli
-npm install
-
-# Build
-npm run build
-
-# Run tests
-npm test
+# macOS (launchd)
+t2c service install
 
-# Run with coverage
-npm run test:coverage
+# Linux (systemd)
+t2c service install
 
-# Link for local testing
-npm link
+# Both auto-detect the platform
 ```
 
+The proxy runs in the background, automatically paying for LLM requests from any connected AI tool.
+
 ## License
 
 MIT

package/dist/cashu-store.d.ts

@@ -22,7 +22,7 @@ export declare class CashuStore {
     /** Returns true if balance is below threshold */
     needsFunding(threshold: number): boolean;
     /**
-     * Select proofs totalling at least `amount` sat,
+     * Select proofs totalling at least `amount` units,
      * encode as a Cashu V4 token, and remove them from the store.
      */
     selectAndEncode(amount: number): Promise<string>;

package/dist/cashu-store.js

@@ -73,7 +73,7 @@ export class CashuStore {
         catch {
             const data = {
                 mint: mint ?? "https://mint.token2chat.com",
-                unit: "sat",
+                unit: "usd",
                 proofs: [],
             };
             const store = new CashuStore(path, data);
@@ -102,13 +102,13 @@ export class CashuStore {
     }
     // ── Proof selection ────────────────────────────────────────
     /**
-     * Select proofs totalling at least `amount` sat,
+     * Select proofs totalling at least `amount` units,
      * encode as a Cashu V4 token, and remove them from the store.
      */
     async selectAndEncode(amount) {
         return this.mutex.lock(async () => {
             if (this.balance < amount) {
-                throw new Error(`Insufficient balance: need ${amount} sat, have ${this.balance} sat`);
+                throw new Error(`Insufficient balance: need ${amount}, have ${this.balance}`);
             }
             const sorted = [...this.data.proofs].sort((a, b) => b.amount - a.amount);
             const selected = [];
@@ -120,7 +120,7 @@ export class CashuStore {
                 total += p.amount;
             }
             if (total < amount) {
-                throw new Error(`Could not select enough proofs for ${amount} sat`);
+                throw new Error(`Could not select enough proofs for ${amount}`);
             }
             // Remove selected proofs
             const selectedSecrets = new Set(selected.map((p) => typeof p.secret === "string" ? p.secret : JSON.stringify(p.secret)));

package/dist/commands/audit.d.ts

@@ -1,6 +1,71 @@
+/**
+ * t2c audit — Full-chain fund visualization
+ *
+ * Unified view: local wallet + Mint + Gate + transaction log.
+ * Cross-references data and highlights anomalies.
+ */
+import { type TransactionRecord, type FailedToken } from "../config.js";
 interface AuditOptions {
     json?: boolean;
     lines?: string;
 }
+interface MintInfo {
+    reachable: boolean;
+    name?: string;
+    version?: string;
+    nuts?: Record<string, unknown>;
+    keysetIds?: string[];
+    error?: string;
+}
+interface GateInfo {
+    reachable: boolean;
+    mints?: string[];
+    models?: string[];
+    pricing?: Record<string, {
+        input_per_million?: number;
+        output_per_million?: number;
+        per_request?: number;
+    }>;
+    error?: string;
+}
+interface ProofBreakdown {
+    [denomination: number]: number;
+}
+export interface Anomaly {
+    severity: "error" | "warn" | "info";
+    message: string;
+}
+interface DiscoveredGate {
+    name: string;
+    url: string;
+    mint: string;
+    models: string[];
+    healthy: boolean;
+}
+export interface AuditReport {
+    timestamp: number;
+    wallet: {
+        balance: number;
+        proofCount: number;
+        proofBreakdown: ProofBreakdown;
+        mint: string;
+    } | null;
+    mint: MintInfo;
+    gate: GateInfo;
+    discoveredGates: DiscoveredGate[];
+    transactions: {
+        total: number;
+        shown: number;
+        totalSpent: number;
+        totalChange: number;
+        totalRefund: number;
+        netCost: number;
+        errorCount: number;
+        recent: TransactionRecord[];
+    };
+    failedTokens: FailedToken[];
+    anomalies: Anomaly[];
+}
+export declare function detectAnomalies(report: AuditReport): Anomaly[];
 export declare function auditCommand(opts: AuditOptions): Promise<void>;
 export {};

package/dist/commands/audit.js

@@ -4,7 +4,7 @@
  * Unified view: local wallet + Mint + Gate + transaction log.
  * Cross-references data and highlights anomalies.
  */
-import { loadConfig, resolveHome, loadFailedTokens, loadTransactions, } from "../config.js";
+import { loadConfig, resolveHome, loadFailedTokens, loadTransactions, formatUnits, } from "../config.js";
 import { CashuStore } from "../cashu-store.js";
 import { GateRegistry } from "../gate-discovery.js";
 async function fetchMintInfo(mintUrl) {
@@ -52,7 +52,7 @@ async function fetchGateInfo(gateUrl) {
         return { reachable: false, error: e instanceof Error ? e.message : String(e) };
     }
 }
-function detectAnomalies(report) {
+export function detectAnomalies(report) {
     const anomalies = [];
     // Wallet anomalies
     if (report.wallet) {
@@ -60,7 +60,7 @@ function detectAnomalies(report) {
             anomalies.push({ severity: "error", message: "Wallet balance is 0 — cannot make requests" });
         }
         else if (report.wallet.balance < 500) {
-            anomalies.push({ severity: "warn", message: `Low wallet balance: ${report.wallet.balance} sat` });
+            anomalies.push({ severity: "warn", message: `Low wallet balance: ${formatUnits(report.wallet.balance)}` });
         }
         if (report.wallet.proofCount > 100) {
             anomalies.push({ severity: "warn", message: `High proof count (${report.wallet.proofCount}) — consider consolidating via swap` });
@@ -101,7 +101,7 @@ function detectAnomalies(report) {
     if (report.transactions.totalSpent > 0 && lossRate > 50) {
         anomalies.push({
             severity: "warn",
-            message: `High fund loss rate: ${lossRate.toFixed(1)}% of spent sats not returned as change/refund`,
+            message: `High fund loss rate: ${lossRate.toFixed(1)}% of spent funds not returned as change/refund`,
         });
     }
     // Failed token anomalies
@@ -118,7 +118,7 @@ function detectAnomalies(report) {
         if (last.balanceAfter !== report.wallet.balance) {
             anomalies.push({
                 severity: "info",
-                message: `Balance drift: last tx recorded ${last.balanceAfter} sat, wallet now ${report.wallet.balance} sat (may indicate manual changes)`,
+                message: `Balance drift: last tx recorded ${formatUnits(last.balanceAfter)}, wallet now ${formatUnits(report.wallet.balance)} (may indicate manual changes)`,
             });
         }
     }
@@ -141,7 +141,7 @@ function printReport(report) {
     // ── Wallet ──
     console.log("--- Wallet ---");
     if (report.wallet) {
-        console.log(`  Balance:     ${report.wallet.balance.toLocaleString()} sat`);
+        console.log(`  Balance:     ${formatUnits(report.wallet.balance)}`);
         console.log(`  Proofs:      ${report.wallet.proofCount}`);
         console.log(`  Mint:        ${report.wallet.mint}`);
         const denominations = Object.entries(report.wallet.proofBreakdown)
@@ -149,7 +149,7 @@ function printReport(report) {
         if (denominations.length > 0) {
             console.log("  Breakdown:");
             for (const [denom, count] of denominations) {
-                console.log(`    ${denom} sat x ${count} = ${Number(denom) * count} sat`);
+                console.log(`    ${formatUnits(Number(denom))} x ${count} = ${formatUnits(Number(denom) * count)}`);
             }
         }
     }
@@ -188,7 +188,7 @@ function printReport(report) {
                 parts.push(`out:${rule.output_per_million}/M`);
             if (rule.per_request)
                 parts.push(`req:${rule.per_request}`);
-            console.log(`    ${model}: ${parts.join(", ")} sat`);
+            console.log(`    ${model}: ${parts.join(", ")}`);
         }
     }
     // ── Discovered Gates ──
@@ -210,10 +210,10 @@ function printReport(report) {
     }
     else {
         console.log(`  Total:       ${report.transactions.total} requests`);
-        console.log(`  Spent:       ${report.transactions.totalSpent.toLocaleString()} sat`);
-        console.log(`  Change:      +${report.transactions.totalChange.toLocaleString()} sat`);
-        console.log(`  Refund:      +${report.transactions.totalRefund.toLocaleString()} sat`);
-        console.log(`  Net cost:    ${report.transactions.netCost.toLocaleString()} sat`);
+        console.log(`  Spent:       ${formatUnits(report.transactions.totalSpent)}`);
+        console.log(`  Change:      +${formatUnits(report.transactions.totalChange)}`);
+        console.log(`  Refund:      +${formatUnits(report.transactions.totalRefund)}`);
+        console.log(`  Net cost:    ${formatUnits(report.transactions.netCost)}`);
         console.log(`  Errors:      ${report.transactions.errorCount}`);
         if (report.transactions.recent.length > 0) {
             console.log("\n  Recent transactions:");

package/dist/commands/balance.js

@@ -1,7 +1,7 @@
 /**
  * t2c balance - Simple balance display
  */
-import { loadConfig, WALLET_PATH } from "../config.js";
+import { loadConfig, WALLET_PATH, formatUnits } from "../config.js";
 import { CashuStore } from "../cashu-store.js";
 export async function balanceCommand(opts) {
     const config = await loadConfig();
@@ -14,7 +14,7 @@ export async function balanceCommand(opts) {
             }));
         }
         else {
-            console.log(`${wallet.balance} sat`);
+            console.log(formatUnits(wallet.balance));
         }
     }
     catch (e) {

package/dist/commands/doctor.js

@@ -4,7 +4,7 @@
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { loadConfig, configExists, checkGateHealth, checkMintHealth, CONFIG_PATH, WALLET_PATH, } from "../config.js";
+import { loadConfig, configExists, checkGateHealth, checkMintHealth, CONFIG_PATH, WALLET_PATH, formatUnits, } from "../config.js";
 import { CashuStore } from "../cashu-store.js";
 // Platform-specific service paths
 const LAUNCHD_PLIST_PATH = path.join(os.homedir(), "Library", "LaunchAgents", "com.token2chat.proxy.plist");
@@ -31,7 +31,7 @@ async function checkWallet(config) {
         return {
             name: "Wallet",
             ok: true,
-            detail: `${WALLET_PATH} (${wallet.balance} sat)`,
+            detail: `${WALLET_PATH} (${formatUnits(wallet.balance)})`,
         };
     }
     catch (e) {

package/dist/commands/init.js

@@ -4,7 +4,7 @@
  * Uses sensible defaults for gate/mint/port/wallet.
  * No interactive prompts — just validate connectivity and create wallet.
  */
-import { saveConfig, configExists, resolveHome, loadConfig, checkGateHealth, checkMintHealth, DEFAULT_CONFIG, } from "../config.js";
+import { saveConfig, configExists, resolveHome, loadConfig, checkGateHealth, checkMintHealth, DEFAULT_CONFIG, formatUnits, } from "../config.js";
 import { CashuStore } from "../cashu-store.js";
 export async function initCommand(opts) {
     console.log("\n🎟️  Token2Chat Init\n");
@@ -35,7 +35,7 @@ export async function initCommand(opts) {
     try {
         const resolvedPath = resolveHome(config.walletPath);
         const wallet = await CashuStore.load(resolvedPath, config.mintUrl);
-        console.log(`  Wallet initialized (balance: ${wallet.balance} sat)`);
+        console.log(`  Wallet initialized (balance: ${formatUnits(wallet.balance)})`);
     }
     catch (e) {
         console.log(`  ⚠️  Wallet init failed: ${e}`);

package/dist/commands/mint.js

@@ -3,7 +3,7 @@
  */
 import fs from "node:fs/promises";
 import path from "node:path";
-import { loadConfig, resolveHome, CONFIG_DIR } from "../config.js";
+import { loadConfig, resolveHome, CONFIG_DIR, formatUnits } from "../config.js";
 import { CashuStore } from "../cashu-store.js";
 // Fallback deposit address (Mint's EVM address for USDC/USDT)
 // This is used if /v1/info endpoint doesn't provide a deposit address
@@ -61,7 +61,7 @@ export async function mintCommand(amount, opts) {
     }
     const currentBalance = wallet.balance;
     console.log("\n🎟️  Token2Chat Funding\n");
-    console.log(`Current balance: ${currentBalance.toLocaleString()} sat\n`);
+    console.log(`Current balance: ${formatUnits(currentBalance)}\n`);
     if (opts.check) {
         // Check for pending Lightning quotes and mint paid ones
         console.log("Checking pending Lightning quotes...\n");
@@ -84,7 +84,7 @@ export async function mintCommand(amount, opts) {
             }
             try {
                 const minted = await wallet.mintFromQuote(pq.quote, pq.amount);
-                console.log(`✅ Minted ${minted.toLocaleString()} sat from quote ${pq.quote.slice(0, 8)}...`);
+                console.log(`✅ Minted ${formatUnits(minted)} from quote ${pq.quote.slice(0, 8)}...`);
                 mintedTotal += minted;
             }
             catch (e) {
@@ -105,8 +105,8 @@ export async function mintCommand(amount, opts) {
         // Update pending quotes file
         await savePendingQuotes({ quotes: stillPending });
         if (mintedTotal > 0) {
-            console.log(`\n🎉 Total minted: ${mintedTotal.toLocaleString()} sat`);
-            console.log(`New balance: ${wallet.balance.toLocaleString()} sat\n`);
+            console.log(`\n🎉 Total minted: ${formatUnits(mintedTotal)}`);
+            console.log(`New balance: ${formatUnits(wallet.balance)}\n`);
         }
         else if (stillPending.length > 0) {
             console.log(`\n${stillPending.length} quote(s) still awaiting payment.`);
@@ -122,19 +122,19 @@ export async function mintCommand(amount, opts) {
     }
     // Lightning funding (if amount specified)
     if (amount) {
-        const sats = parseInt(amount, 10);
-        if (isNaN(sats) || sats <= 0) {
-            console.error("Invalid amount. Specify sats to fund via Lightning.");
+        const units = parseInt(amount, 10);
+        if (isNaN(units) || units <= 0) {
+            console.error("Invalid amount. Specify units to fund via Lightning.");
             process.exit(1);
         }
-        console.log(`⚡ Creating Lightning invoice for ${sats.toLocaleString()} sat...\n`);
+        console.log(`⚡ Creating Lightning invoice for ${formatUnits(units)}...\n`);
         try {
-            const quote = await wallet.createMintQuote(sats);
+            const quote = await wallet.createMintQuote(units);
             // Save to pending quotes
             const pendingData = await loadPendingQuotes();
             pendingData.quotes.push({
                 quote: quote.quote,
-                amount: sats,
+                amount: units,
                 request: quote.request,
                 createdAt: Date.now(),
             });
@@ -153,7 +153,7 @@ export async function mintCommand(amount, opts) {
     // Show deposit instructions (EVM stablecoins)
     const depositAddress = await fetchDepositAddress(config.mintUrl);
     console.log("Option 1: Lightning (recommended)\n");
-    console.log("  t2c mint <amount_sats>    Create a Lightning invoice\n");
+    console.log("  t2c mint <amount>         Create a Lightning invoice\n");
     console.log("Option 2: EVM Stablecoins\n");
     console.log("  Send USDC or USDT to:\n");
     console.log(`  ${depositAddress}\n`);
@@ -163,6 +163,6 @@ export async function mintCommand(amount, opts) {
     }
     console.log("\n💡 Tips:");
     console.log("  • Lightning deposits are instant");
-    console.log("  • EVM deposits: ~1 sat per $0.001 USD");
-    console.log("  • Minimum deposit: $1 USD or 1000 sat\n");
+    console.log("  • EVM deposits: 100,000 units = $1.00 USD");
+    console.log("  • Minimum deposit: $1.00 USD\n");
 }