apow-cli 0.4.0 → 0.6.0

package/.env.example

@@ -1,9 +1,10 @@
 # Wallet
 PRIVATE_KEY=
 
-# RPC — The public default works but is unreliable for sustained mining.
-# We strongly recommend a free Alchemy endpoint: https://www.alchemy.com/ (no credit card)
-RPC_URL=https://mainnet.base.org
+# RPC — Default: Alchemy x402 (premium RPC, paid automatically via USDC in your wallet).
+# No API key needed. If you prefer a different RPC, uncomment and set RPC_URL below.
+# Setting RPC_URL disables x402 and uses the specified endpoint instead.
+# RPC_URL=https://mainnet.base.org
 
 # LLM Provider (openai / anthropic / gemini / ollama / claude-code / codex)
 LLM_PROVIDER=openai
@@ -20,10 +21,14 @@ LLM_API_KEY=
 # Ollama (only if LLM_PROVIDER=ollama)
 # OLLAMA_URL=http://127.0.0.1:11434
 
-# Solana bridging (only needed for `apow fund --solana`)
+# Bridging (only needed for `apow fund`)
 # SOLANA_RPC_URL=https://api.mainnet-beta.solana.com
 # SQUID_INTEGRATOR_ID=
 
+# Ethereum mainnet RPC (only for `apow fund --chain ethereum`)
+# Default: https://eth.llamarpc.com (free)
+# ETHEREUM_RPC_URL=
+
 # Contract addresses (defaults built-in, override only if needed)
 # MINING_AGENT_ADDRESS=0xB7caD3ca5F2BD8aEC2Eb67d6E8D448099B3bC03D
 # AGENT_COIN_ADDRESS=0x12577CF0D8a07363224D6909c54C056A183e13b3

package/README.md

@@ -2,7 +2,7 @@
 
 Mining client for the [APoW (Agentic Proof of Work)](https://github.com/Agentoshi/apow-core) protocol on Base. Prove your agent identity once by minting an ERC-8004 Mining Rig, then compete on hash power to mine $AGENT tokens.
 
-**Your agent does all the work — you just fund a wallet.**
+**Your agent does all the work. You just fund a wallet.**
 
 ## Install
 
@@ -16,19 +16,17 @@ Or run directly:
 npx apow-cli
 ```
 
-## Important: RPC Endpoint
+## RPC: Alchemy x402 (Default)
 
-> **The default public RPC (`mainnet.base.org`) is unreliable for mining.** It rate-limits aggressively and will cause frequent transaction failures. **We strongly recommend getting a free Alchemy endpoint** before you start:
+> **v0.5.0+: Premium RPC with zero setup.** The CLI uses [Alchemy x402](https://x402.alchemy.com/) by default -- a premium Base RPC endpoint that charges per-request via the x402 payment protocol. Your mining wallet pays automatically with USDC on Base. No API key, no account, no rate limits.
 >
-> 1. Sign up at [alchemy.com](https://www.alchemy.com/) (free, no credit card)
-> 2. Create an app → Chain: **Base** → Network: **Base Mainnet**
-> 3. Copy the HTTPS URL → set `RPC_URL` in your `.env`
+> **Requirements:** USDC balance on Base in your mining wallet. Even a small amount (1-2 USDC) covers thousands of RPC calls.
 >
-> Alchemy's free tier gives you 300M compute units/month — more than enough for mining. See [RPC Recommendations](skill.md#rpc-recommendations) for other free options.
+> **Fallback:** If no USDC is available, the CLI automatically falls back to the public RPC (`mainnet.base.org`). To use a custom RPC instead, set `RPC_URL` in your `.env` (this disables x402).
 
 ## For AI Agents
 
-Any AI agent can go from zero to actively mining in 5 steps — no human interaction except funding the wallet.
+Any AI agent can go from zero to actively mining in 5 steps with no human interaction except funding the wallet.
 
 ```bash
 # 1. Generate a wallet
@@ -36,20 +34,21 @@ npx apow-cli wallet new
 # → Captures address + private key from stdout
 
 # 2. Write .env (no interactive prompts)
-#    LLM config is only needed for minting — mining uses optimized SMHL solving
+#    LLM config is only needed for minting; mining uses optimized SMHL solving
+#    RPC defaults to Alchemy x402 (paid via USDC) — no RPC_URL needed
 cat > .env << 'EOF'
 PRIVATE_KEY=0x<from step 1>
-RPC_URL=https://mainnet.base.org  # UNRELIABLE — get a free Alchemy URL (see above)
 LLM_PROVIDER=openai               # Required for minting only
 LLM_MODEL=gpt-4o-mini             # Required for minting only
 LLM_API_KEY=<your key>            # Required for minting only
 EOF
 
-# 3. Fund the wallet (bridge from Solana or send ETH on Base)
-npx apow-cli fund --solana            # bridge SOL → ETH on Base
-# Or ask your user to send ≥0.005 ETH on Base directly
+# 3. Fund the wallet (bridge from any chain, auto-splits into ETH + USDC)
+npx apow-cli fund --chain solana --token sol    # bridge SOL → ETH+USDC on Base
+npx apow-cli fund --chain ethereum --token eth  # bridge ETH → ETH+USDC on Base
+# Or send ETH/USDC on Base directly
 
-# 4. Mint a mining rig NFT (proves agent identity via LLM — one-time)
+# 4. Mint a mining rig NFT (proves agent identity via LLM, one-time)
 npx apow-cli mint
 
 # 5. Start mining (runs forever, no LLM needed, multi-threaded)
@@ -75,7 +74,7 @@ Each wallet gets one rig, each rig mines independently. More wallets = more chan
 If you prefer to do it yourself:
 
 ```bash
-# 1. Interactive setup — wallet, RPC, LLM config
+# 1. Interactive setup: wallet, RPC, LLM config
 npx apow-cli setup
 
 # 2. Fund your wallet (bridge from Solana or send ETH directly)
@@ -92,8 +91,8 @@ npx apow-cli mine
 
 | Command | Description |
 |---------|-------------|
-| `apow setup` | Interactive setup wizard — configure wallet, RPC, and LLM |
-| `apow fund` | Fund your wallet — bridge SOL → ETH on Base, or show deposit address |
+| `apow setup` | Interactive setup wizard: configure wallet, RPC, and LLM |
+| `apow fund` | Fund your wallet: bridge from Solana/Ethereum, swap on Base, auto-split ETH+USDC |
 | `apow wallet new` | Generate a new mining wallet |
 | `apow wallet show` | Show configured wallet address |
 | `apow wallet export` | Export your wallet's private key |
@@ -101,6 +100,9 @@ npx apow-cli mine
 | `apow mint` | Mint a MiningAgent NFT (one per wallet) |
 | `apow mine [tokenId]` | Mine $AGENT with your NFT (auto-detects best rig) |
 | `apow stats [tokenId]` | View mining stats, earnings, difficulty |
+| `apow dashboard start` | Launch multi-wallet mining dashboard |
+| `apow dashboard add <addr>` | Add a wallet to the dashboard |
+| `apow dashboard scan [dir]` | Auto-detect wallet files in a directory |
 
 ## Configuration
 
@@ -108,12 +110,13 @@ Create a `.env` file or use `apow setup`:
 
 ```bash
 PRIVATE_KEY=0x...              # Your wallet private key
-RPC_URL=https://mainnet.base.org  # UNRELIABLE — strongly recommend a free Alchemy URL instead (see above)
-LLM_PROVIDER=openai            # openai | anthropic | gemini | ollama | claude-code | codex (for minting)
-LLM_MODEL=gpt-4o-mini         # Required for minting only — mining uses optimized SMHL solving
+# RPC_URL=https://mainnet.base.org  # Optional: set to override default Alchemy x402
+LLM_PROVIDER=openai            # openai | gemini | deepseek | qwen | anthropic | ollama (for minting)
+LLM_MODEL=gpt-4o-mini         # Required for minting only; mining uses optimized SMHL solving
 LLM_API_KEY=sk-...             # Required for minting only
-# Solana bridging (only for `apow fund --solana`)
+# Bridging (only for `apow fund`)
 # SOLANA_RPC_URL=https://api.mainnet-beta.solana.com
+# ETHEREUM_RPC_URL=https://eth.llamarpc.com    # free, for `--chain ethereum` only
 # SQUID_INTEGRATOR_ID=          # free, get at squidrouter.com (deposit address flow only)
 # Contract addresses (defaults built-in, override only if needed)
 # MINING_AGENT_ADDRESS=0xB7caD3ca5F2BD8aEC2Eb67d6E8D448099B3bC03D
@@ -124,16 +127,40 @@ See [.env.example](.env.example) for all options.
 
 ## LLM Providers (for Minting)
 
-An LLM is required to mint your Mining Rig NFT (one-time identity verification). Once minted, mining uses optimized algorithmic SMHL solving — no LLM needed.
+An LLM is required to mint your Mining Rig NFT (one-time identity verification). Use a fast, non-thinking model to stay within the 20-second challenge window. Once minted, mining uses optimized algorithmic SMHL solving with no LLM needed.
 
 | Provider | Model | Cost/call | Notes |
 |----------|-------|-----------|-------|
-| OpenAI | `gpt-4o-mini` | ~$0.001 | Cheapest cloud option |
-| Anthropic | `claude-sonnet-4-5-20250929` | ~$0.005 | High accuracy |
-| Gemini | `gemini-2.5-flash` | ~$0.001 | Fast |
+| OpenAI | `gpt-4o-mini` | ~$0.001 | Recommended. Cheapest, fastest |
+| Gemini | `gemini-2.5-flash` | ~$0.001 | Fast, good accuracy |
+| DeepSeek | `deepseek-chat` | ~$0.001 | Fast, accessible in China |
+| Qwen | `qwen-plus` | ~$0.002 | Alibaba Cloud |
+| Anthropic | `claude-sonnet-4-5-20250929` | ~$0.005 | Works but slower |
 | Ollama | `llama3.1` | Free | Local GPU required |
-| Claude Code | `default` | Subscription | No API key needed |
-| Codex | `default` | Subscription | No API key needed |
+
+## Funding (v0.6.0+)
+
+Mining requires two assets on Base: **ETH** (gas) and **USDC** (x402 RPC). The `fund` command accepts deposits in 6 forms across 3 chains, auto-bridges to Base, and auto-splits into both:
+
+```bash
+# From Solana
+apow fund --chain solana --token sol              # bridge SOL → ETH, auto-swap portion to USDC
+apow fund --chain solana --token usdc             # bridge USDC, auto-swap portion to ETH
+apow fund --chain solana --token sol --key <b58>  # direct signing (fast, ~20s)
+
+# From Ethereum mainnet
+apow fund --chain ethereum --token eth            # bridge ETH → Base, auto-swap portion to USDC
+apow fund --chain ethereum --token usdc           # bridge USDC → Base, auto-swap portion to ETH
+
+# Already on Base
+apow fund --chain base --token eth                # show address, wait for deposit, auto-split
+apow fund --chain base --token usdc               # show address, wait for deposit, auto-split
+
+# Skip auto-split (keep single asset)
+apow fund --chain base --no-swap
+```
+
+**Auto-split targets:** 0.003 ETH (gas for ~100 mine txns) + 2.00 USDC (~100K x402 RPC calls). If both are already met, the CLI skips the swap.
 
 ## Speed Mining (v0.4.0+)
 
@@ -142,6 +169,42 @@ Mining in v0.4.0 uses two key optimizations:
 - **Algorithmic SMHL**: Mining SMHL challenges are solved algorithmically in microseconds (no LLM call). Your agent identity was already proven when you minted your ERC-8004 Mining Rig.
 - **Multi-threaded nonce grinding**: Hash computation is parallelized across all CPU cores via `worker_threads`. Set `MINER_THREADS` in `.env` to override the default (all cores).
 
+> **Want more hash power?** Rent a high-core-count machine on [vast.ai](https://vast.ai/) to increase your nonce grinding throughput. Not required, but scales linearly with core count.
+
+## Dashboard
+
+Monitor your entire mining fleet from a single web UI. Zero external dependencies -- vanilla HTML/JS served by the CLI.
+
+```bash
+# Quick start: scan wallet files and launch
+apow dashboard scan .          # detect wallet-0x*.txt files in current directory
+apow dashboard start           # open dashboard at http://localhost:3847
+```
+
+### Commands
+
+| Command | Description |
+|---------|-------------|
+| `apow dashboard start` | Launch dashboard web UI (default port 3847) |
+| `apow dashboard add <addr>` | Add a wallet address to monitor |
+| `apow dashboard remove <addr>` | Remove a wallet from monitoring |
+| `apow dashboard scan [dir]` | Auto-detect wallets from `wallet-0x*.txt` files |
+| `apow dashboard wallets` | List all monitored wallets |
+
+### Fleet Configuration
+
+Wallets are stored in `~/.apow/wallets.json` (plain JSON array of addresses). For advanced fleet management, create `~/.apow/fleets.json`:
+
+```json
+[
+  { "name": "Local", "type": "array", "path": "/home/user/.apow/wallets.json" },
+  { "name": "Vast.ai", "type": "rigdirs", "path": "/mnt/mining/rigs" },
+  { "name": "Pool", "type": "walletfiles", "path": "/mnt/mining/wallets" }
+]
+```
+
+Fleet types: `array` (JSON array of addresses), `solkek` (master/miners JSON), `rigdirs` (scan `rig*/wallet-0x*.txt`), `walletfiles` (scan `wallet-0x*.txt`).
+
 ## Protocol
 
 The APoW protocol contracts and documentation live in [apow-core](https://github.com/Agentoshi/apow-core).

package/dist/bridge/constants.js

@@ -0,0 +1,34 @@
+"use strict";
+// Shared chain IDs, token addresses, and types for cross-chain bridging.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SLIPPAGE_BPS = exports.MIN_USDC = exports.MIN_ETH = exports.TOKENS = exports.CHAIN_IDS = void 0;
+exports.bridgeOutputAsset = bridgeOutputAsset;
+exports.CHAIN_IDS = {
+    solana: { debridge: "7565164", squid: "solana" },
+    ethereum: { debridge: "1", squid: "1" },
+    base: { debridge: "8453", squid: "8453" },
+};
+exports.TOKENS = {
+    solana: {
+        native: "11111111111111111111111111111111",
+        nativeWrapped: "So11111111111111111111111111111111111111112",
+        usdc: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+    },
+    ethereum: {
+        native: "0x0000000000000000000000000000000000000000",
+        nativeSquid: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+        usdc: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    },
+    base: {
+        native: "0x0000000000000000000000000000000000000000",
+        nativeSquid: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+        weth: "0x4200000000000000000000000000000000000006",
+        usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    },
+};
+function bridgeOutputAsset(token) {
+    return token === "usdc" ? "usdc" : "eth";
+}
+exports.MIN_ETH = 0.003;
+exports.MIN_USDC = 2.0;
+exports.SLIPPAGE_BPS = 200; // 2%

package/dist/bridge/debridge.js

@@ -1,6 +1,6 @@
 "use strict";
-// deBridge DLN bridge — direct signing flow (Option A).
-// SOL → native ETH on Base in ~20 seconds via DLN market makers.
+// deBridge DLN bridge — direct signing flow.
+// Supports SOL→Base and Ethereum→Base bridging.
 // No API key needed.
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -36,40 +36,77 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.bridgeViaDeBridge = bridgeViaDeBridge;
+exports.ROUTES = void 0;
+exports.bridgeFromSolana = bridgeFromSolana;
+exports.bridgeFromEvm = bridgeFromEvm;
 exports.pollOrderStatus = pollOrderStatus;
+const viem_1 = require("viem");
+const chains_1 = require("viem/chains");
+const accounts_1 = require("viem/accounts");
+const constants_1 = require("./constants");
 const solana = __importStar(require("./solana"));
 const DLN_API = "https://dln.debridge.finance/v1.0";
-const SOLANA_CHAIN_ID = "7565164";
-const BASE_CHAIN_ID = "8453";
-const NATIVE_SOL = "11111111111111111111111111111111"; // System Program = native SOL
-const NATIVE_ETH = "0x0000000000000000000000000000000000000000";
+exports.ROUTES = {
+    sol_to_eth: {
+        srcChainId: constants_1.CHAIN_IDS.solana.debridge,
+        srcToken: constants_1.TOKENS.solana.native,
+        srcDecimals: 9,
+        dstChainId: constants_1.CHAIN_IDS.base.debridge,
+        dstToken: constants_1.TOKENS.base.native,
+    },
+    sol_usdc_to_base_usdc: {
+        srcChainId: constants_1.CHAIN_IDS.solana.debridge,
+        srcToken: constants_1.TOKENS.solana.usdc,
+        srcDecimals: 6,
+        dstChainId: constants_1.CHAIN_IDS.base.debridge,
+        dstToken: constants_1.TOKENS.base.usdc,
+    },
+    eth_to_base_eth: {
+        srcChainId: constants_1.CHAIN_IDS.ethereum.debridge,
+        srcToken: constants_1.TOKENS.ethereum.native,
+        srcDecimals: 18,
+        dstChainId: constants_1.CHAIN_IDS.base.debridge,
+        dstToken: constants_1.TOKENS.base.native,
+    },
+    eth_usdc_to_base_usdc: {
+        srcChainId: constants_1.CHAIN_IDS.ethereum.debridge,
+        srcToken: constants_1.TOKENS.ethereum.usdc,
+        srcDecimals: 6,
+        dstChainId: constants_1.CHAIN_IDS.base.debridge,
+        dstToken: constants_1.TOKENS.base.usdc,
+    },
+};
 /**
- * Create and submit a deBridge DLN order: SOL → ETH on Base.
- * Returns after the Solana tx is confirmed. Call pollOrderStatus() to wait for fulfillment.
+ * Create DLN order params for any route.
  */
-async function bridgeViaDeBridge(solanaKeypair, baseAddress, solAmount) {
-    const startTime = Date.now();
-    const lamports = Math.floor(solAmount * 1e9);
-    const srcPublicKey = solanaKeypair.publicKey.toBase58();
-    // Step 1: Get serialized bridge transaction from DLN
-    const params = new URLSearchParams({
-        srcChainId: SOLANA_CHAIN_ID,
-        srcChainTokenIn: NATIVE_SOL,
-        srcChainTokenInAmount: lamports.toString(),
-        dstChainId: BASE_CHAIN_ID,
-        dstChainTokenOut: NATIVE_ETH,
+function buildOrderParams(route, amount, senderAddress, baseAddress) {
+    const rawAmount = Math.floor(amount * 10 ** route.srcDecimals);
+    return new URLSearchParams({
+        srcChainId: route.srcChainId,
+        srcChainTokenIn: route.srcToken,
+        srcChainTokenInAmount: rawAmount.toString(),
+        dstChainId: route.dstChainId,
+        dstChainTokenOut: route.dstToken,
         dstChainTokenOutRecipient: baseAddress,
-        senderAddress: srcPublicKey,
-        srcChainOrderAuthorityAddress: srcPublicKey,
+        senderAddress,
+        srcChainOrderAuthorityAddress: senderAddress,
         dstChainOrderAuthorityAddress: baseAddress,
     });
+}
+/**
+ * Bridge from Solana to Base via deBridge DLN (direct signing).
+ * Works for SOL→ETH and USDC→USDC routes.
+ */
+async function bridgeFromSolana(solanaKeypair, baseAddress, amount, route = exports.ROUTES.sol_to_eth) {
+    const startTime = Date.now();
+    const srcPublicKey = solanaKeypair.publicKey.toBase58();
+    const params = buildOrderParams(route, amount, srcPublicKey, baseAddress);
     const response = await fetch(`${DLN_API}/dln/order/create-tx?${params}`);
     if (!response.ok) {
         const body = await response.text();
         throw new Error(`deBridge API error (${response.status}): ${body}`);
     }
-    const data = await response.json();
+    const data = (await response.json());
     if (data.errorCode || data.error) {
         throw new Error(`deBridge error: ${data.error || data.message || JSON.stringify(data)}`);
     }
@@ -78,7 +115,6 @@ async function bridgeViaDeBridge(solanaKeypair, baseAddress, solAmount) {
     if (!txData) {
         throw new Error("deBridge API returned no transaction data");
     }
-    // Step 2: Sign and submit on Solana
     const txSignature = await solana.signAndSendTransaction(txData, solanaKeypair);
     return {
         orderId,
@@ -87,9 +123,96 @@ async function bridgeViaDeBridge(solanaKeypair, baseAddress, solAmount) {
         timeMs: Date.now() - startTime,
     };
 }
+/**
+ * Bridge from Ethereum mainnet to Base via deBridge DLN (direct signing).
+ * Uses the same PRIVATE_KEY — same address on all EVM chains.
+ * Works for ETH→ETH and USDC→USDC routes.
+ */
+async function bridgeFromEvm(privateKey, baseAddress, amount, route = exports.ROUTES.eth_to_base_eth) {
+    const startTime = Date.now();
+    const evmAccount = (0, accounts_1.privateKeyToAccount)(privateKey);
+    const rpcUrl = process.env.ETHEREUM_RPC_URL ?? "https://eth.llamarpc.com";
+    const ethWalletClient = (0, viem_1.createWalletClient)({
+        account: evmAccount,
+        chain: chains_1.mainnet,
+        transport: (0, viem_1.http)(rpcUrl),
+    });
+    const params = buildOrderParams(route, amount, evmAccount.address, baseAddress);
+    const response = await fetch(`${DLN_API}/dln/order/create-tx?${params}`);
+    if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`deBridge API error (${response.status}): ${body}`);
+    }
+    const data = (await response.json());
+    if (data.errorCode || data.error) {
+        throw new Error(`deBridge error: ${data.error || data.message || JSON.stringify(data)}`);
+    }
+    const orderId = data.orderId;
+    // For EVM, the API returns tx params instead of serialized tx
+    const tx = data.tx;
+    if (!tx || !tx.to) {
+        throw new Error("deBridge API returned no EVM transaction data");
+    }
+    // For USDC routes, handle token approval if needed
+    if (tx.allowanceTarget && tx.allowanceValue) {
+        const { createPublicClient } = await Promise.resolve().then(() => __importStar(require("viem")));
+        const ethPublicClient = createPublicClient({
+            chain: chains_1.mainnet,
+            transport: (0, viem_1.http)(rpcUrl),
+        });
+        const erc20Abi = [
+            {
+                type: "function",
+                name: "allowance",
+                inputs: [
+                    { name: "owner", type: "address" },
+                    { name: "spender", type: "address" },
+                ],
+                outputs: [{ name: "", type: "uint256" }],
+                stateMutability: "view",
+            },
+            {
+                type: "function",
+                name: "approve",
+                inputs: [
+                    { name: "spender", type: "address" },
+                    { name: "amount", type: "uint256" },
+                ],
+                outputs: [{ name: "", type: "bool" }],
+                stateMutability: "nonpayable",
+            },
+        ];
+        const currentAllowance = (await ethPublicClient.readContract({
+            address: route.srcToken,
+            abi: erc20Abi,
+            functionName: "allowance",
+            args: [evmAccount.address, tx.allowanceTarget],
+        }));
+        if (currentAllowance < BigInt(tx.allowanceValue)) {
+            const approveTx = await ethWalletClient.writeContract({
+                address: route.srcToken,
+                abi: erc20Abi,
+                functionName: "approve",
+                args: [tx.allowanceTarget, BigInt(tx.allowanceValue)],
+            });
+            await ethPublicClient.waitForTransactionReceipt({ hash: approveTx });
+        }
+    }
+    const txHash = await ethWalletClient.sendTransaction({
+        to: tx.to,
+        data: tx.data,
+        value: tx.value ? BigInt(tx.value) : 0n,
+    });
+    return {
+        orderId,
+        txSignature: txHash,
+        status: "submitted",
+        timeMs: Date.now() - startTime,
+    };
+}
 /**
  * Poll deBridge order status until fulfilled, cancelled, or timeout.
- * Default timeout: 5 minutes.
+ * Works for all deBridge orders regardless of source chain.
  */
 async function pollOrderStatus(orderId, onUpdate, timeoutMs = 300_000) {
     const deadline = Date.now() + timeoutMs;
@@ -97,7 +220,7 @@ async function pollOrderStatus(orderId, onUpdate, timeoutMs = 300_000) {
         try {
             const response = await fetch(`${DLN_API}/dln/order/${orderId}/status`);
             if (response.ok) {
-                const data = await response.json();
+                const data = (await response.json());
                 const status = data.status || data.orderStatus || "unknown";
                 if (onUpdate)
                     onUpdate(status);
@@ -106,8 +229,8 @@ async function pollOrderStatus(orderId, onUpdate, timeoutMs = 300_000) {
                     status === "SentUnlock") {
                     return {
                         status: "fulfilled",
-                        ethReceived: data.fulfilledDstAmount
-                            ? (Number(data.fulfilledDstAmount) / 1e18).toFixed(6)
+                        received: data.fulfilledDstAmount
+                            ? data.fulfilledDstAmount.toString()
                             : undefined,
                     };
                 }

package/dist/bridge/solana.js

@@ -39,6 +39,7 @@ exports.getSolanaRpcUrl = getSolanaRpcUrl;
 exports.parseSolanaKey = parseSolanaKey;
 exports.getSolanaBalance = getSolanaBalance;
 exports.getAddressBalance = getAddressBalance;
+exports.getSplTokenBalance = getSplTokenBalance;
 exports.signAndSendTransaction = signAndSendTransaction;
 const DEFAULT_SOLANA_RPC = "https://api.mainnet-beta.solana.com";
 const BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
@@ -112,6 +113,18 @@ async function getAddressBalance(address) {
     const lamports = await connection.getBalance(new PublicKey(address));
     return lamports / 1e9;
 }
+/** Get SPL token balance (e.g., USDC) for a Solana public key. Returns UI amount (not raw). */
+async function getSplTokenBalance(publicKeyBase58, mintAddress) {
+    const { Connection, PublicKey } = await Promise.resolve().then(() => __importStar(require("@solana/web3.js")));
+    const connection = new Connection(getSolanaRpcUrl(), "confirmed");
+    const owner = new PublicKey(publicKeyBase58);
+    const mint = new PublicKey(mintAddress);
+    const accounts = await connection.getParsedTokenAccountsByOwner(owner, { mint });
+    if (accounts.value.length === 0)
+        return 0;
+    const parsed = accounts.value[0].account.data.parsed;
+    return parsed?.info?.tokenAmount?.uiAmount ?? 0;
+}
 /** Deserialize, sign, and submit a base64-encoded Solana transaction. */
 async function signAndSendTransaction(serializedTxBase64, keypair) {
     const { Connection, VersionedTransaction } = await Promise.resolve().then(() => __importStar(require("@solana/web3.js")));

package/dist/bridge/squid.js

@@ -1,31 +1,63 @@
 "use strict";
-// Squid Router bridge — deposit address flow (Options B+C).
-// SOL → ETH on Base via Chainflip multi-hop (~1-3 minutes).
+// Squid Router bridge — deposit address flow.
+// Supports SOL→Base and Ethereum→Base via Chainflip multi-hop (~1-3 minutes).
 // Requires SQUID_INTEGRATOR_ID (free, apply at squidrouter.com).
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQUID_ROUTES = void 0;
 exports.getDepositAddress = getDepositAddress;
 exports.pollBridgeStatus = pollBridgeStatus;
+const constants_1 = require("./constants");
 const SQUID_API = "https://v2.api.squidrouter.com/v2";
-const SOLANA_CHAIN_ID = "solana";
-const BASE_CHAIN_ID = "8453";
-const NATIVE_SOL_ADDRESS = "So11111111111111111111111111111111111111112"; // Wrapped SOL mint
-const NATIVE_ETH_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+exports.SQUID_ROUTES = {
+    sol_to_eth: {
+        fromChain: constants_1.CHAIN_IDS.solana.squid,
+        fromToken: constants_1.TOKENS.solana.nativeWrapped,
+        toChain: constants_1.CHAIN_IDS.base.squid,
+        toToken: constants_1.TOKENS.base.nativeSquid,
+        srcDecimals: 9,
+        dstDecimals: 18,
+    },
+    sol_usdc_to_base_usdc: {
+        fromChain: constants_1.CHAIN_IDS.solana.squid,
+        fromToken: constants_1.TOKENS.solana.usdc,
+        toChain: constants_1.CHAIN_IDS.base.squid,
+        toToken: constants_1.TOKENS.base.usdc,
+        srcDecimals: 6,
+        dstDecimals: 6,
+    },
+    eth_to_base_eth: {
+        fromChain: constants_1.CHAIN_IDS.ethereum.squid,
+        fromToken: constants_1.TOKENS.ethereum.nativeSquid,
+        toChain: constants_1.CHAIN_IDS.base.squid,
+        toToken: constants_1.TOKENS.base.nativeSquid,
+        srcDecimals: 18,
+        dstDecimals: 18,
+    },
+    eth_usdc_to_base_usdc: {
+        fromChain: constants_1.CHAIN_IDS.ethereum.squid,
+        fromToken: constants_1.TOKENS.ethereum.usdc,
+        toChain: constants_1.CHAIN_IDS.base.squid,
+        toToken: constants_1.TOKENS.base.usdc,
+        srcDecimals: 6,
+        dstDecimals: 6,
+    },
+};
 function getIntegratorId() {
     const id = process.env.SQUID_INTEGRATOR_ID;
     if (!id) {
         throw new Error("SQUID_INTEGRATOR_ID is required for the deposit address flow.\n" +
             "Get one free at https://app.squidrouter.com/\n" +
-            "Or use direct signing instead: apow fund --solana --key <base58>");
+            "Or use direct signing instead: apow fund --chain solana --key <base58>");
     }
     return id;
 }
 /**
- * Get a Squid deposit address for SOL → ETH on Base bridging.
- * User sends SOL to this address from any wallet; Squid handles the rest.
+ * Get a Squid deposit address for bridging to Base.
+ * User sends tokens to this address from any wallet; Squid handles the rest.
  */
-async function getDepositAddress(baseAddress, solAmount) {
+async function getDepositAddress(baseAddress, amount, route = exports.SQUID_ROUTES.sol_to_eth) {
     const integratorId = getIntegratorId();
-    const lamports = Math.floor(solAmount * 1e9).toString();
+    const rawAmount = Math.floor(amount * 10 ** route.srcDecimals).toString();
     // Step 1: Get route quote
     const routeResponse = await fetch(`${SQUID_API}/route`, {
         method: "POST",
@@ -34,11 +66,11 @@ async function getDepositAddress(baseAddress, solAmount) {
             "x-integrator-id": integratorId,
         },
         body: JSON.stringify({
-            fromChain: SOLANA_CHAIN_ID,
-            toChain: BASE_CHAIN_ID,
-            fromToken: NATIVE_SOL_ADDRESS,
-            toToken: NATIVE_ETH_ADDRESS,
-            fromAmount: lamports,
+            fromChain: route.fromChain,
+            toChain: route.toChain,
+            fromToken: route.fromToken,
+            toToken: route.toToken,
+            fromAmount: rawAmount,
             toAddress: baseAddress,
             quoteOnly: false,
             enableBoost: true,
@@ -69,8 +101,9 @@ async function getDepositAddress(baseAddress, solAmount) {
         throw new Error(`Squid deposit-address API error (${depositResponse.status}): ${body}`);
     }
     const depositData = (await depositResponse.json());
-    const estimatedReceive = routeData.route?.estimate?.toAmount
-        ? (Number(routeData.route.estimate.toAmount) / 1e18).toFixed(6)
+    const toAmount = routeData.route?.estimate?.toAmount;
+    const estimatedReceive = toAmount
+        ? (Number(toAmount) / 10 ** route.dstDecimals).toFixed(route.dstDecimals === 6 ? 2 : 6)
         : "unknown";
     return {
         depositAddress: depositData.depositAddress,
@@ -83,7 +116,7 @@ async function getDepositAddress(baseAddress, solAmount) {
  * Poll Squid bridge status until complete, failed, or timeout.
  * Default timeout: 10 minutes (Chainflip can be slow).
  */
-async function pollBridgeStatus(requestId, onUpdate, timeoutMs = 600_000) {
+async function pollBridgeStatus(requestId, dstDecimals = 18, onUpdate, timeoutMs = 600_000) {
     const integratorId = getIntegratorId();
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
@@ -105,8 +138,8 @@ async function pollBridgeStatus(requestId, onUpdate, timeoutMs = 600_000) {
                     status === "destination_executed") {
                     return {
                         status: "fulfilled",
-                        ethReceived: data.toChain?.amount
-                            ? (Number(data.toChain.amount) / 1e18).toFixed(6)
+                        received: data.toChain?.amount
+                            ? (Number(data.toChain.amount) / 10 ** dstDecimals).toFixed(dstDecimals === 6 ? 2 : 6)
                             : undefined,
                     };
                 }