apow-cli 0.4.1 → 0.6.1

package/dist/fund.js

@@ -1,9 +1,15 @@
 "use strict";
-// Fund command — bridge SOL → ETH on Base so Solana users can start mining.
-// Three paths:
-//   Option A: Direct Solana signing via deBridge DLN (~20s)
-//   Option B: Deposit address + QR via Squid Router (~1-3 min)
-//   Option C: Manual send (just show Base address)
+// Fund command — unified funding for mining on Base.
+// Accepts deposits in 6 forms across 3 chains, auto-bridges to Base,
+// auto-splits into ETH (gas) + USDC (x402 RPC).
+//
+// Deposit types:
+//   1. Solana SOL     → bridge → ETH on Base → swap portion to USDC
+//   2. Solana USDC    → bridge → USDC on Base → swap portion to ETH
+//   3. Ethereum ETH   → bridge → ETH on Base → swap portion to USDC
+//   4. Ethereum USDC  → bridge → USDC on Base → swap portion to ETH
+//   5. Base ETH       → (already there) → swap portion to USDC
+//   6. Base USDC      → (already there) → swap portion to ETH
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -40,7 +46,12 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runFundFlow = runFundFlow;
 const viem_1 = require("viem");
+const constants_1 = require("./bridge/constants");
+const debridge_1 = require("./bridge/debridge");
+const squid_1 = require("./bridge/squid");
+const uniswap_1 = require("./bridge/uniswap");
 const wallet_1 = require("./wallet");
+const config_1 = require("./config");
 const ui = __importStar(require("./ui"));
 async function fetchPrices() {
     const res = await fetch("https://api.coingecko.com/api/v3/simple/price?ids=solana,ethereum&vs_currencies=usd");
@@ -51,9 +62,9 @@ async function fetchPrices() {
     const solUsd = data.solana.usd;
     return { solPerEth: ethUsd / solUsd, ethPriceUsd: ethUsd, solPriceUsd: solUsd };
 }
-/** SOL needed for target ETH, with 10% buffer for bridge fees + slippage. */
-function solNeededForEth(targetEth, solPerEth) {
-    return targetEth * solPerEth * 1.1;
+/** Source token amount needed for target ETH worth, with 10% buffer. */
+function amountNeededForEth(targetEth, tokenPriceUsd, ethPriceUsd) {
+    return (targetEth * ethPriceUsd / tokenPriceUsd) * 1.1;
 }
 // ---------------------------------------------------------------------------
 // QR code helper
@@ -77,12 +88,112 @@ async function showQrCode(text) {
     }
 }
 // ---------------------------------------------------------------------------
-// Option A — Direct signing via deBridge
+// Auto-split: ensure both ETH and USDC minimums are met
 // ---------------------------------------------------------------------------
-async function runDirectBridge(solanaKeyInput, baseAddress, targetEth) {
+async function autoSplit(depositedAsset, prices, noSwap) {
+    if (noSwap)
+        return;
+    if (!wallet_1.account)
+        return;
+    const ethBal = Number((0, viem_1.formatEther)(await (0, wallet_1.getEthBalance)()));
+    const usdcBal = Number((0, viem_1.formatUnits)(await (0, uniswap_1.getUsdcBalance)(wallet_1.account.address), 6));
+    // Already good
+    if (ethBal >= constants_1.MIN_ETH && usdcBal >= constants_1.MIN_USDC) {
+        return;
+    }
+    // Not enough to cover anything useful
+    const totalUsd = ethBal * prices.ethPriceUsd + usdcBal;
+    const minTotalUsd = constants_1.MIN_ETH * prices.ethPriceUsd + constants_1.MIN_USDC;
+    if (totalUsd < minTotalUsd * 0.5) {
+        ui.warn("Balance too low for auto-split. Fund more to cover both ETH (gas) and USDC (x402 RPC).");
+        return;
+    }
+    if (depositedAsset === "eth" && usdcBal < constants_1.MIN_USDC) {
+        const usdcNeeded = constants_1.MIN_USDC - usdcBal;
+        const ethToSwap = (usdcNeeded / prices.ethPriceUsd) * 1.02; // 2% buffer
+        if (ethBal - ethToSwap < constants_1.MIN_ETH * 0.5) {
+            ui.warn("Not enough ETH to swap for USDC and keep enough for gas. Skipping auto-split.");
+            return;
+        }
+        console.log("");
+        ui.table([
+            ["Auto-split", `Swap ~${ethToSwap.toFixed(6)} ETH → ~${usdcNeeded.toFixed(2)} USDC`],
+            ["Purpose", "USDC for x402 RPC calls"],
+            ["Remaining ETH", `~${(ethBal - ethToSwap).toFixed(6)} ETH (gas)`],
+        ]);
+        console.log("");
+        const proceed = await ui.confirm("Confirm swap?");
+        if (!proceed) {
+            console.log("  Skipped auto-split.");
+            return;
+        }
+        const swapSpinner = ui.spinner("Swapping ETH → USDC on Uniswap V3...");
+        const ethWei = (0, viem_1.parseEther)(ethToSwap.toFixed(18));
+        const minUsdc = (0, viem_1.parseUnits)((usdcNeeded * (1 - constants_1.SLIPPAGE_BPS / 10000)).toFixed(6), 6);
+        try {
+            const result = await (0, uniswap_1.swapEthToUsdc)(ethWei, minUsdc);
+            swapSpinner.stop(`Swap complete: ${result.usdcReceived} USDC`);
+        }
+        catch (err) {
+            swapSpinner.fail("Swap failed");
+            throw err;
+        }
+    }
+    if (depositedAsset === "usdc" && ethBal < constants_1.MIN_ETH) {
+        const ethNeeded = constants_1.MIN_ETH - ethBal;
+        const usdcToSwap = ethNeeded * prices.ethPriceUsd * 1.02; // 2% buffer
+        if (usdcBal - usdcToSwap < constants_1.MIN_USDC * 0.5) {
+            ui.warn("Not enough USDC to swap for ETH and keep enough for RPC. Skipping auto-split.");
+            return;
+        }
+        console.log("");
+        ui.table([
+            ["Auto-split", `Swap ~${usdcToSwap.toFixed(2)} USDC → ~${ethNeeded.toFixed(6)} ETH`],
+            ["Purpose", "ETH for gas"],
+            ["Remaining USDC", `~${(usdcBal - usdcToSwap).toFixed(2)} USDC (x402 RPC)`],
+        ]);
+        console.log("");
+        const proceed = await ui.confirm("Confirm swap?");
+        if (!proceed) {
+            console.log("  Skipped auto-split.");
+            return;
+        }
+        const swapSpinner = ui.spinner("Swapping USDC → ETH on Uniswap V3...");
+        const usdcRaw = (0, viem_1.parseUnits)(usdcToSwap.toFixed(6), 6);
+        const minEth = (0, viem_1.parseEther)((ethNeeded * (1 - constants_1.SLIPPAGE_BPS / 10000)).toFixed(18));
+        try {
+            const result = await (0, uniswap_1.swapUsdcToEth)(usdcRaw, minEth);
+            swapSpinner.stop(`Swap complete: ${result.ethReceived} ETH`);
+        }
+        catch (err) {
+            swapSpinner.fail("Swap failed");
+            throw err;
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// Show final balances
+// ---------------------------------------------------------------------------
+async function showFinalBalances() {
+    if (!wallet_1.account)
+        return;
+    const ethBal = Number((0, viem_1.formatEther)(await (0, wallet_1.getEthBalance)()));
+    const usdcBal = Number((0, viem_1.formatUnits)(await (0, uniswap_1.getUsdcBalance)(wallet_1.account.address), 6));
+    console.log("");
+    console.log(`  ${ui.green("Ready to mine!")}`);
+    ui.table([
+        ["ETH", `${ethBal.toFixed(6)} ETH (gas)`],
+        ["USDC", `${usdcBal.toFixed(2)} USDC (x402 RPC)`],
+    ]);
+    console.log(`  Next: ${ui.cyan("apow mint")}`);
+    console.log("");
+}
+// ---------------------------------------------------------------------------
+// Solana direct bridge (deBridge DLN)
+// ---------------------------------------------------------------------------
+async function runSolanaDirectBridge(solanaKeyInput, baseAddress, sourceToken, targetEth) {
     const solanaSpinner = ui.spinner("Checking Solana balance...");
     const solana = await Promise.resolve().then(() => __importStar(require("./bridge/solana")));
-    const debridge = await Promise.resolve().then(() => __importStar(require("./bridge/debridge")));
     let kp;
     try {
         kp = await solana.parseSolanaKey(solanaKeyInput);
@@ -91,26 +202,205 @@ async function runDirectBridge(solanaKeyInput, baseAddress, targetEth) {
         solanaSpinner.fail("Invalid Solana key");
         throw err;
     }
-    const balance = await solana.getSolanaBalance(kp.publicKey);
-    solanaSpinner.stop(`Solana balance: ${balance.toFixed(4)} SOL`);
-    // Prices
+    if (sourceToken === "usdc") {
+        const usdcBal = await solana.getSplTokenBalance(kp.publicKey, constants_1.TOKENS.solana.usdc);
+        solanaSpinner.stop(`Solana USDC balance: ${usdcBal.toFixed(2)} USDC`);
+        const priceSpinner = ui.spinner("Fetching prices...");
+        const prices = await fetchPrices();
+        priceSpinner.stop(`ETH price: $${prices.ethPriceUsd.toFixed(0)}`);
+        const usdcAmount = targetEth * prices.ethPriceUsd * 1.1; // 10% buffer
+        if (usdcBal < usdcAmount) {
+            ui.error(`Insufficient USDC. Need ~${usdcAmount.toFixed(2)} USDC, have ${usdcBal.toFixed(2)} USDC.`);
+            return;
+        }
+        console.log("");
+        ui.table([
+            ["Bridging", `${usdcAmount.toFixed(2)} USDC → USDC on Base`],
+            ["Via", "deBridge DLN (~20 seconds)"],
+            ["From", `${kp.publicKey.slice(0, 4)}...${kp.publicKey.slice(-4)}`],
+            ["To", `${baseAddress.slice(0, 6)}...${baseAddress.slice(-4)}`],
+        ]);
+        console.log("");
+        const proceed = await ui.confirm("Confirm bridge?");
+        if (!proceed) {
+            console.log("  Cancelled.");
+            return;
+        }
+        const bridgeSpinner = ui.spinner("Signing bridge transaction...");
+        const result = await (0, debridge_1.bridgeFromSolana)(kp.keypair, baseAddress, usdcAmount, debridge_1.ROUTES.sol_usdc_to_base_usdc);
+        bridgeSpinner.stop(`Submitted! Order: ${result.orderId.slice(0, 12)}...`);
+        const pollSpinner = ui.spinner("Waiting for bridge fulfillment... (~20s)");
+        const fulfillment = await (0, debridge_1.pollOrderStatus)(result.orderId, (s) => pollSpinner.update(`Bridge status: ${s}`));
+        pollSpinner.stop("Bridge complete! USDC arrived on Base");
+        await autoSplit("usdc", prices, false);
+        await showFinalBalances();
+    }
+    else {
+        // SOL → ETH
+        const balance = await solana.getSolanaBalance(kp.publicKey);
+        solanaSpinner.stop(`Solana balance: ${balance.toFixed(4)} SOL`);
+        const priceSpinner = ui.spinner("Fetching prices...");
+        const prices = await fetchPrices();
+        const solAmount = amountNeededForEth(targetEth, prices.solPriceUsd, prices.ethPriceUsd);
+        priceSpinner.stop(`SOL/ETH rate: ${prices.solPerEth.toFixed(1)} SOL = 1 ETH`);
+        if (balance < solAmount) {
+            ui.error(`Insufficient SOL. Need ~${solAmount.toFixed(4)} SOL, have ${balance.toFixed(4)} SOL.`);
+            return;
+        }
+        console.log("");
+        ui.table([
+            ["Bridging", `${solAmount.toFixed(4)} SOL → ~${targetEth.toFixed(4)} ETH on Base`],
+            ["Via", "deBridge DLN (~20 seconds)"],
+            ["From", `${kp.publicKey.slice(0, 4)}...${kp.publicKey.slice(-4)}`],
+            ["To", `${baseAddress.slice(0, 6)}...${baseAddress.slice(-4)}`],
+        ]);
+        console.log("");
+        const proceed = await ui.confirm("Confirm bridge?");
+        if (!proceed) {
+            console.log("  Cancelled.");
+            return;
+        }
+        const bridgeSpinner = ui.spinner("Signing bridge transaction...");
+        const result = await (0, debridge_1.bridgeFromSolana)(kp.keypair, baseAddress, solAmount, debridge_1.ROUTES.sol_to_eth);
+        bridgeSpinner.stop(`Submitted! Order: ${result.orderId.slice(0, 12)}...`);
+        const pollSpinner = ui.spinner("Waiting for bridge fulfillment... (~20s)");
+        const fulfillment = await (0, debridge_1.pollOrderStatus)(result.orderId, (s) => pollSpinner.update(`Bridge status: ${s}`));
+        const received = fulfillment.received
+            ? (Number(fulfillment.received) / 1e18).toFixed(6)
+            : `~${targetEth.toFixed(4)}`;
+        pollSpinner.stop(`Bridge complete! ${received} ETH arrived on Base`);
+        await autoSplit("eth", prices, false);
+        await showFinalBalances();
+    }
+}
+// ---------------------------------------------------------------------------
+// Solana deposit address bridge (Squid Router)
+// ---------------------------------------------------------------------------
+async function runSolanaDepositBridge(baseAddress, sourceToken, targetEth) {
     const priceSpinner = ui.spinner("Fetching prices...");
     const prices = await fetchPrices();
-    const solAmount = solNeededForEth(targetEth, prices.solPerEth);
-    priceSpinner.stop(`SOL/ETH rate: ${prices.solPerEth.toFixed(1)} SOL = 1 ETH`);
-    if (balance < solAmount) {
-        ui.error(`Insufficient SOL. Need ~${solAmount.toFixed(4)} SOL, have ${balance.toFixed(4)} SOL.`);
+    priceSpinner.stop(`ETH price: $${prices.ethPriceUsd.toFixed(0)}`);
+    const route = sourceToken === "usdc"
+        ? squid_1.SQUID_ROUTES.sol_usdc_to_base_usdc
+        : squid_1.SQUID_ROUTES.sol_to_eth;
+    const amount = sourceToken === "usdc"
+        ? targetEth * prices.ethPriceUsd * 1.1
+        : amountNeededForEth(targetEth, prices.solPriceUsd, prices.ethPriceUsd);
+    const tokenLabel = sourceToken === "usdc" ? "USDC" : "SOL";
+    const addrSpinner = ui.spinner("Generating deposit address...");
+    const squid = await Promise.resolve().then(() => __importStar(require("./bridge/squid")));
+    const solana = await Promise.resolve().then(() => __importStar(require("./bridge/solana")));
+    let deposit;
+    try {
+        deposit = await squid.getDepositAddress(baseAddress, amount, route);
+    }
+    catch (err) {
+        addrSpinner.fail("Failed to get deposit address");
+        throw err;
+    }
+    addrSpinner.stop("Deposit address ready");
+    console.log("");
+    console.log(`  ${ui.bold(`Send ${tokenLabel} to this address:`)}`);
+    console.log("");
+    console.log(`  ${ui.cyan(deposit.depositAddress)}`);
+    console.log("");
+    await showQrCode(deposit.depositAddress);
+    console.log("");
+    ui.table([
+        ["Amount", `~${amount.toFixed(sourceToken === "usdc" ? 2 : 4)} ${tokenLabel}`],
+        ["You'll receive", `~${deposit.expectedReceive} ${sourceToken === "usdc" ? "USDC" : "ETH"} on Base`],
+        ["Bridge", "Squid Router (Chainflip)"],
+        ["Time", "~1-3 minutes"],
+    ]);
+    console.log("");
+    if (deposit.expiresAt) {
+        ui.warn(`Deposit address expires: ${deposit.expiresAt}`);
+        console.log("");
+    }
+    // Poll for deposit
+    const depositSpinner = ui.spinner(`Waiting for ${tokenLabel} deposit... (Ctrl+C to cancel)`);
+    if (sourceToken === "native") {
+        // SOL deposit: poll Solana balance
+        const initialBalance = await solana.getAddressBalance(deposit.depositAddress);
+        let depositDetected = false;
+        const depositDeadline = Date.now() + 600_000;
+        while (!depositDetected && Date.now() < depositDeadline) {
+            await new Promise((r) => setTimeout(r, 3000));
+            try {
+                const currentBalance = await solana.getAddressBalance(deposit.depositAddress);
+                if (currentBalance > initialBalance + 0.001) {
+                    depositDetected = true;
+                    depositSpinner.stop(`Deposit received! ${(currentBalance - initialBalance).toFixed(4)} SOL`);
+                }
+            }
+            catch {
+                // Transient RPC error
+            }
+        }
+        if (!depositDetected) {
+            depositSpinner.fail(`No ${tokenLabel} deposit detected after 10 minutes`);
+            ui.hint("If you sent tokens, check: https://explorer.squidrouter.com");
+            return;
+        }
+    }
+    else {
+        // USDC deposit: poll SPL token balance at the deposit address
+        let depositDetected = false;
+        const depositDeadline = Date.now() + 600_000;
+        while (!depositDetected && Date.now() < depositDeadline) {
+            await new Promise((r) => setTimeout(r, 3000));
+            try {
+                const bal = await solana.getSplTokenBalance(deposit.depositAddress, constants_1.TOKENS.solana.usdc);
+                if (bal > 0.01) {
+                    depositDetected = true;
+                    depositSpinner.stop(`Deposit received! ${bal.toFixed(2)} USDC`);
+                }
+            }
+            catch {
+                // Transient RPC error
+            }
+        }
+        if (!depositDetected) {
+            depositSpinner.fail("No USDC deposit detected after 10 minutes");
+            ui.hint("If you sent USDC, check: https://explorer.squidrouter.com");
+            return;
+        }
+    }
+    // Poll for bridge completion
+    const bridgeSpinner = ui.spinner("Bridging to Base... (~1-3 min)");
+    const result = await (0, squid_1.pollBridgeStatus)(deposit.requestId, route.dstDecimals, (status) => bridgeSpinner.update(`Bridge status: ${status}`));
+    const received = result.received || deposit.expectedReceive;
+    const receivedAsset = sourceToken === "usdc" ? "USDC" : "ETH";
+    bridgeSpinner.stop(`Bridge complete! ${received} ${receivedAsset} arrived`);
+    const outputAsset = (0, constants_1.bridgeOutputAsset)(sourceToken);
+    await autoSplit(outputAsset, prices, false);
+    await showFinalBalances();
+}
+// ---------------------------------------------------------------------------
+// Ethereum direct bridge (deBridge DLN)
+// ---------------------------------------------------------------------------
+async function runEthereumDirectBridge(baseAddress, sourceToken, targetEth) {
+    if (!config_1.config.privateKey) {
+        ui.error("No PRIVATE_KEY configured. Your wallet key is used on Ethereum mainnet too.");
         return;
     }
+    const priceSpinner = ui.spinner("Fetching prices...");
+    const prices = await fetchPrices();
+    priceSpinner.stop(`ETH price: $${prices.ethPriceUsd.toFixed(0)}`);
+    const route = sourceToken === "usdc"
+        ? debridge_1.ROUTES.eth_usdc_to_base_usdc
+        : debridge_1.ROUTES.eth_to_base_eth;
+    const amount = sourceToken === "usdc"
+        ? targetEth * prices.ethPriceUsd * 1.1
+        : targetEth * 1.1;
+    const tokenLabel = sourceToken === "usdc" ? "USDC" : "ETH";
+    const receivedLabel = sourceToken === "usdc" ? "USDC" : "ETH";
     console.log("");
     ui.table([
-        ["Bridging", `${solAmount.toFixed(4)} SOL → ~${targetEth.toFixed(4)} ETH on Base`],
+        ["Bridging", `${amount.toFixed(sourceToken === "usdc" ? 2 : 6)} ${tokenLabel} → ${receivedLabel} on Base`],
         ["Via", "deBridge DLN (~20 seconds)"],
-        [
-            "From",
-            `${kp.publicKey.slice(0, 4)}...${kp.publicKey.slice(-4)}`,
-        ],
-        ["To", `${baseAddress.slice(0, 6)}...${baseAddress.slice(-4)}`],
+        ["From", `Ethereum mainnet (${baseAddress.slice(0, 6)}...${baseAddress.slice(-4)})`],
+        ["To", `Base (same address)`],
     ]);
     console.log("");
     const proceed = await ui.confirm("Confirm bridge?");
@@ -118,51 +408,58 @@ async function runDirectBridge(solanaKeyInput, baseAddress, targetEth) {
         console.log("  Cancelled.");
         return;
     }
-    const bridgeSpinner = ui.spinner("Signing bridge transaction...");
-    const result = await debridge.bridgeViaDeBridge(kp.keypair, baseAddress, solAmount);
-    bridgeSpinner.stop(`Submitted! Order: ${result.orderId.slice(0, 12)}...`);
-    const pollSpinner = ui.spinner("Waiting for bridge fulfillment... (~20s)");
-    const fulfillment = await debridge.pollOrderStatus(result.orderId, (status) => pollSpinner.update(`Bridge status: ${status}`));
-    const received = fulfillment.ethReceived || `~${targetEth.toFixed(4)}`;
-    pollSpinner.stop(`Bridge complete! ${received} ETH arrived on Base`);
-    console.log("");
-    console.log(`  ${ui.green("Your wallet is funded!")} Next: ${ui.cyan("apow mint")}`);
-    console.log("");
+    const bridgeSpinner = ui.spinner("Signing bridge transaction on Ethereum...");
+    try {
+        const result = await (0, debridge_1.bridgeFromEvm)(config_1.config.privateKey, baseAddress, amount, route);
+        bridgeSpinner.stop(`Submitted! Order: ${result.orderId.slice(0, 12)}...`);
+        const pollSpinner = ui.spinner("Waiting for bridge fulfillment... (~20s)");
+        const fulfillment = await (0, debridge_1.pollOrderStatus)(result.orderId, (s) => pollSpinner.update(`Bridge status: ${s}`));
+        pollSpinner.stop(`Bridge complete! ${receivedLabel} arrived on Base`);
+        const outputAsset = (0, constants_1.bridgeOutputAsset)(sourceToken);
+        await autoSplit(outputAsset, prices, false);
+        await showFinalBalances();
+    }
+    catch (err) {
+        bridgeSpinner.fail("Bridge failed");
+        throw err;
+    }
 }
 // ---------------------------------------------------------------------------
-// Options B+C — Deposit address via Squid
+// Ethereum deposit address bridge (Squid Router)
 // ---------------------------------------------------------------------------
-async function runDepositBridge(baseAddress, targetEth) {
+async function runEthereumDepositBridge(baseAddress, sourceToken, targetEth) {
     const priceSpinner = ui.spinner("Fetching prices...");
     const prices = await fetchPrices();
-    const solAmount = solNeededForEth(targetEth, prices.solPerEth);
-    priceSpinner.stop(`SOL/ETH rate: ${prices.solPerEth.toFixed(1)} SOL = 1 ETH`);
+    priceSpinner.stop(`ETH price: $${prices.ethPriceUsd.toFixed(0)}`);
+    const route = sourceToken === "usdc"
+        ? squid_1.SQUID_ROUTES.eth_usdc_to_base_usdc
+        : squid_1.SQUID_ROUTES.eth_to_base_eth;
+    const amount = sourceToken === "usdc"
+        ? targetEth * prices.ethPriceUsd * 1.1
+        : targetEth * 1.1;
+    const tokenLabel = sourceToken === "usdc" ? "USDC" : "ETH";
     const addrSpinner = ui.spinner("Generating deposit address...");
     const squid = await Promise.resolve().then(() => __importStar(require("./bridge/squid")));
-    const solana = await Promise.resolve().then(() => __importStar(require("./bridge/solana")));
     let deposit;
     try {
-        deposit = await squid.getDepositAddress(baseAddress, solAmount);
+        deposit = await squid.getDepositAddress(baseAddress, amount, route);
     }
     catch (err) {
         addrSpinner.fail("Failed to get deposit address");
         throw err;
     }
     addrSpinner.stop("Deposit address ready");
-    // Display deposit info
     console.log("");
-    console.log(`  ${ui.bold("Send SOL to this address:")}`);
+    console.log(`  ${ui.bold(`Send ${tokenLabel} on Ethereum mainnet to:`)}`);
     console.log("");
     console.log(`  ${ui.cyan(deposit.depositAddress)}`);
     console.log("");
     await showQrCode(deposit.depositAddress);
     console.log("");
     ui.table([
-        [
-            "Amount",
-            `~${solAmount.toFixed(4)} SOL (~$${(solAmount * prices.solPriceUsd).toFixed(2)})`,
-        ],
-        ["You'll receive", `~${deposit.expectedReceive} ETH on Base`],
+        ["Amount", `~${amount.toFixed(sourceToken === "usdc" ? 2 : 6)} ${tokenLabel}`],
+        ["Network", "Ethereum mainnet"],
+        ["You'll receive", `~${deposit.expectedReceive} ${sourceToken === "usdc" ? "USDC" : "ETH"} on Base`],
         ["Bridge", "Squid Router (Chainflip)"],
         ["Time", "~1-3 minutes"],
     ]);
@@ -171,53 +468,127 @@ async function runDepositBridge(baseAddress, targetEth) {
         ui.warn(`Deposit address expires: ${deposit.expiresAt}`);
         console.log("");
     }
-    // Poll for SOL deposit
-    const depositSpinner = ui.spinner("Waiting for SOL deposit... (Ctrl+C to cancel)");
-    const initialBalance = await solana.getAddressBalance(deposit.depositAddress);
+    // Wait for user to send manually — poll Squid status directly
+    const bridgeSpinner = ui.spinner(`Send ${tokenLabel} and waiting for bridge... (Ctrl+C to cancel)`);
+    // For Ethereum deposits, we rely on Squid status API rather than polling an RPC
+    const result = await (0, squid_1.pollBridgeStatus)(deposit.requestId, route.dstDecimals, (status) => bridgeSpinner.update(`Bridge status: ${status}`), 900_000);
+    const received = result.received || deposit.expectedReceive;
+    const receivedAsset = sourceToken === "usdc" ? "USDC" : "ETH";
+    bridgeSpinner.stop(`Bridge complete! ${received} ${receivedAsset} arrived`);
+    const outputAsset = (0, constants_1.bridgeOutputAsset)(sourceToken);
+    await autoSplit(outputAsset, prices, false);
+    await showFinalBalances();
+}
+// ---------------------------------------------------------------------------
+// Base manual send (already on the right chain)
+// ---------------------------------------------------------------------------
+async function runBaseFund(baseAddress, sourceToken, noSwap) {
+    const tokenLabel = sourceToken === "usdc" ? "USDC" : "ETH";
+    console.log("");
+    console.log(`  ${ui.bold(`Send ${tokenLabel} on Base to this address:`)}`);
+    console.log("");
+    console.log(`  ${ui.cyan(baseAddress)}`);
+    console.log("");
+    await showQrCode(baseAddress);
+    console.log("");
+    console.log(`  ${ui.dim("Send from any wallet — Coinbase, MetaMask, Phantom, etc.")}`);
+    if (sourceToken === "usdc") {
+        console.log(`  ${ui.dim("Need at least 2 USDC for x402 RPC + some for ETH swap.")}`);
+    }
+    else {
+        console.log(`  ${ui.dim("Need ~0.005 ETH to cover gas + USDC swap.")}`);
+    }
+    console.log("");
+    const waitForDeposit = await ui.confirm("Wait for deposit and auto-split?");
+    if (!waitForDeposit) {
+        console.log(`  ${ui.dim("After sending, run:")} ${ui.cyan("apow fund --chain base")} to auto-split.`);
+        console.log("");
+        return;
+    }
+    const prices = await fetchPrices();
+    // Poll for balance change
+    const depositSpinner = ui.spinner(`Waiting for ${tokenLabel} deposit... (Ctrl+C to cancel)`);
+    const initialEth = await (0, wallet_1.getEthBalance)();
+    const initialUsdc = wallet_1.account ? await (0, uniswap_1.getUsdcBalance)(wallet_1.account.address) : 0n;
+    const depositDeadline = Date.now() + 600_000;
     let depositDetected = false;
-    const depositDeadline = Date.now() + 600_000; // 10 min
     while (!depositDetected && Date.now() < depositDeadline) {
         await new Promise((r) => setTimeout(r, 3000));
         try {
-            const currentBalance = await solana.getAddressBalance(deposit.depositAddress);
-            if (currentBalance > initialBalance + 0.001) {
-                depositDetected = true;
-                depositSpinner.stop(`Deposit received! ${(currentBalance - initialBalance).toFixed(4)} SOL`);
+            if (sourceToken === "usdc" && wallet_1.account) {
+                const currentUsdc = await (0, uniswap_1.getUsdcBalance)(wallet_1.account.address);
+                if (currentUsdc > initialUsdc + 100000n) { // > 0.1 USDC
+                    depositDetected = true;
+                    depositSpinner.stop(`Deposit received! ${(0, viem_1.formatUnits)(currentUsdc - initialUsdc, 6)} USDC`);
+                }
+            }
+            else {
+                const currentEth = await (0, wallet_1.getEthBalance)();
+                if (currentEth > initialEth + (0, viem_1.parseEther)("0.0001")) {
+                    depositDetected = true;
+                    depositSpinner.stop(`Deposit received! ${(0, viem_1.formatEther)(currentEth - initialEth)} ETH`);
+                }
             }
         }
         catch {
-            // Transient RPC error — keep polling
+            // Transient RPC error
         }
     }
     if (!depositDetected) {
-        depositSpinner.fail("No deposit detected after 10 minutes");
-        ui.hint("If you sent SOL, check: https://explorer.squidrouter.com");
+        depositSpinner.fail(`No ${tokenLabel} deposit detected after 10 minutes`);
         return;
     }
-    // Poll for bridge completion
-    const bridgeSpinner = ui.spinner("Bridging SOL → ETH on Base... (~1-3 min)");
-    const result = await squid.pollBridgeStatus(deposit.requestId, (status) => bridgeSpinner.update(`Bridge status: ${status}`));
-    const received = result.ethReceived || deposit.expectedReceive;
-    bridgeSpinner.stop(`Bridge complete! ${received} ETH arrived`);
-    console.log("");
-    console.log(`  ${ui.green("Your wallet is funded!")} Next: ${ui.cyan("apow mint")}`);
-    console.log("");
+    const outputAsset = (0, constants_1.bridgeOutputAsset)(sourceToken);
+    await autoSplit(outputAsset, prices, noSwap);
+    await showFinalBalances();
 }
 // ---------------------------------------------------------------------------
-// Option C — Manual Base address
+// Interactive menus
 // ---------------------------------------------------------------------------
-async function runManualFund(baseAddress) {
+async function selectSourceChain() {
+    console.log("  Where are your funds?");
+    console.log(`    ${ui.cyan("1.")} Solana (SOL or USDC)`);
+    console.log(`    ${ui.cyan("2.")} Ethereum mainnet (ETH or USDC)`);
+    console.log(`    ${ui.cyan("3.")} Base (send ETH or USDC manually)`);
     console.log("");
-    console.log(`  ${ui.bold("Send ETH on Base to this address:")}`);
-    console.log("");
-    console.log(`  ${ui.cyan(baseAddress)}`);
-    console.log("");
-    await showQrCode(baseAddress);
+    const choice = await ui.prompt("Choice", "1");
+    switch (choice) {
+        case "2": return "ethereum";
+        case "3": return "base";
+        default: return "solana";
+    }
+}
+async function selectSourceToken(chain) {
+    const nativeLabel = chain === "solana" ? "SOL" : "ETH";
     console.log("");
-    console.log(`  ${ui.dim("Send from any wallet — Coinbase, MetaMask, Phantom, etc.")}`);
-    console.log(`  ${ui.dim("Need ~0.005 ETH to start mining.")}`);
-    console.log(`  ${ui.dim("After sending, run:")} ${ui.cyan("apow mint")}`);
+    console.log("  What token?");
+    console.log(`    ${ui.cyan("1.")} ${nativeLabel}`);
+    console.log(`    ${ui.cyan("2.")} USDC`);
     console.log("");
+    const choice = await ui.prompt("Choice", "1");
+    return choice === "2" ? "usdc" : "native";
+}
+function parseSourceChain(value) {
+    if (!value)
+        return undefined;
+    const v = value.toLowerCase();
+    if (v === "solana" || v === "sol")
+        return "solana";
+    if (v === "ethereum" || v === "eth")
+        return "ethereum";
+    if (v === "base")
+        return "base";
+    return undefined;
+}
+function parseSourceToken(value) {
+    if (!value)
+        return undefined;
+    const v = value.toLowerCase();
+    if (v === "sol" || v === "eth" || v === "native")
+        return "native";
+    if (v === "usdc")
+        return "usdc";
+    return undefined;
 }
 // ---------------------------------------------------------------------------
 // Main entry point
@@ -228,85 +599,87 @@ async function runFundFlow(options) {
         process.exit(1);
     }
     const baseAddress = wallet_1.account.address;
-    const balance = await (0, wallet_1.getEthBalance)();
-    const ethBalance = Number((0, viem_1.formatEther)(balance));
+    const ethBalance = Number((0, viem_1.formatEther)(await (0, wallet_1.getEthBalance)()));
+    const usdcBalance = Number((0, viem_1.formatUnits)(await (0, uniswap_1.getUsdcBalance)(baseAddress), 6));
+    const noSwap = options.swap === false;
     console.log("");
     ui.banner(["Fund Your Mining Wallet"]);
     console.log("");
     ui.table([
-        [
-            "Your Base wallet",
-            `${baseAddress.slice(0, 6)}...${baseAddress.slice(-4)}`,
-        ],
-        [
-            "Balance",
-            `${ethBalance.toFixed(6)} ETH${ethBalance < 0.005 ? " (need ~0.005 ETH to start)" : ""}`,
-        ],
+        ["Wallet", `${baseAddress.slice(0, 6)}...${baseAddress.slice(-4)}`],
+        ["ETH", `${ethBalance.toFixed(6)} ETH${ethBalance < constants_1.MIN_ETH ? ` (need ≥${constants_1.MIN_ETH} for gas)` : ""}`],
+        ["USDC", `${usdcBalance.toFixed(2)} USDC${usdcBalance < constants_1.MIN_USDC ? ` (need ≥${constants_1.MIN_USDC} for x402 RPC)` : ""}`],
     ]);
     console.log("");
-    // Parse target ETH
+    // Already funded?
+    if (ethBalance >= constants_1.MIN_ETH && usdcBalance >= constants_1.MIN_USDC) {
+        console.log(`  ${ui.green("Already funded! Ready to mine.")}`);
+        console.log(`  Next: ${ui.cyan("apow mint")}`);
+        console.log("");
+        // Allow explicit re-run if user wants to add more
+        const addMore = await ui.confirm("Add more funds?");
+        if (!addMore)
+            return;
+    }
+    // Parse target ETH amount
     const targetEth = options.amount ? parseFloat(options.amount) : 0.005;
     if (isNaN(targetEth) || targetEth <= 0) {
         ui.error("Invalid amount. Specify ETH target (e.g., --amount 0.005).");
         return;
     }
-    // --key flag: direct bridge immediately
-    if (options.key) {
-        await runDirectBridge(options.key, baseAddress, targetEth);
-        return;
+    // Resolve source chain and token (from flags or interactive)
+    let chain = parseSourceChain(options.chain);
+    let token = parseSourceToken(options.token);
+    if (!chain) {
+        chain = await selectSourceChain();
     }
-    // --solana flag: ask about key, then bridge
-    if (options.solana) {
-        const hasKey = await ui.confirm("Do you have your Solana private key?");
-        if (hasKey) {
-            const key = await ui.promptSecret("Solana private key (base58)");
-            if (!key) {
-                ui.error("No key provided.");
-                return;
-            }
-            await runDirectBridge(key, baseAddress, targetEth);
-        }
-        else {
-            await runDepositBridge(baseAddress, targetEth);
-        }
-        return;
+    if (!token) {
+        token = await selectSourceToken(chain);
     }
-    // Interactive menu
-    console.log("  How do you want to fund?");
-    console.log(`    ${ui.cyan("1.")} Bridge from Solana (SOL → ETH on Base)`);
-    console.log(`    ${ui.cyan("2.")} Send ETH on Base directly (from another wallet)`);
-    console.log(`    ${ui.cyan("3.")} Copy address and fund manually`);
-    console.log("");
-    const choice = await ui.prompt("Choice", "1");
-    switch (choice) {
-        case "1": {
-            const hasKey = await ui.confirm("Do you have your Solana private key?");
-            if (hasKey) {
-                const key = await ui.promptSecret("Solana private key (base58)");
-                if (!key) {
-                    ui.error("No key provided.");
-                    return;
-                }
-                await runDirectBridge(key, baseAddress, targetEth);
+    // Route to the appropriate flow
+    switch (chain) {
+        case "solana": {
+            if (options.key) {
+                await runSolanaDirectBridge(options.key, baseAddress, token, targetEth);
             }
             else {
-                await runDepositBridge(baseAddress, targetEth);
+                console.log("");
+                console.log("  Bridge method:");
+                console.log(`    ${ui.cyan("A.")} Direct signing (~20s, need Solana private key)`);
+                console.log(`    ${ui.cyan("B.")} Deposit address (~1-3 min, send from any wallet)`);
+                console.log("");
+                const method = await ui.prompt("Choice", "A");
+                if (method.toUpperCase() === "A") {
+                    const key = await ui.promptSecret("Solana private key (base58)");
+                    if (!key) {
+                        ui.error("No key provided.");
+                        return;
+                    }
+                    await runSolanaDirectBridge(key, baseAddress, token, targetEth);
+                }
+                else {
+                    await runSolanaDepositBridge(baseAddress, token, targetEth);
+                }
             }
             break;
         }
-        case "2": {
+        case "ethereum": {
             console.log("");
-            console.log(`  ${ui.bold("Send ETH on Base to:")}`);
-            console.log(`  ${ui.cyan(baseAddress)}`);
-            console.log("");
-            console.log(`  ${ui.dim("Need ~0.005 ETH to start mining.")}`);
-            console.log(`  ${ui.dim("After sending, run:")} ${ui.cyan("apow mint")}`);
+            console.log("  Bridge method:");
+            console.log(`    ${ui.cyan("A.")} Direct signing (~20s, uses your PRIVATE_KEY on mainnet)`);
+            console.log(`    ${ui.cyan("B.")} Deposit address (~1-3 min, send from any wallet)`);
             console.log("");
+            const method = await ui.prompt("Choice", "A");
+            if (method.toUpperCase() === "A") {
+                await runEthereumDirectBridge(baseAddress, token, targetEth);
+            }
+            else {
+                await runEthereumDepositBridge(baseAddress, token, targetEth);
+            }
             break;
         }
-        case "3":
-        default: {
-            await runManualFund(baseAddress);
+        case "base": {
+            await runBaseFund(baseAddress, token, noSwap);
             break;
         }
     }