apow-cli 0.4.1 → 0.6.1

package/dist/bridge/uniswap.js

@@ -0,0 +1,184 @@
+"use strict";
+// Uniswap V3 SwapRouter02 on Base — ETH↔USDC swaps.
+// No new npm deps — uses viem's built-in ABI encoding.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUsdcBalance = getUsdcBalance;
+exports.swapEthToUsdc = swapEthToUsdc;
+exports.swapUsdcToEth = swapUsdcToEth;
+const viem_1 = require("viem");
+const constants_1 = require("./constants");
+const wallet_1 = require("../wallet");
+const SWAP_ROUTER = "0x2626664c2603336E57B271c5C0b26F421741e481";
+const WETH = constants_1.TOKENS.base.weth;
+const USDC = constants_1.TOKENS.base.usdc;
+const FEE_TIER = 500; // 0.05% pool (highest TVL)
+const erc20Abi = [
+    {
+        type: "function",
+        name: "balanceOf",
+        inputs: [{ name: "account", type: "address" }],
+        outputs: [{ name: "", type: "uint256" }],
+        stateMutability: "view",
+    },
+    {
+        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 swapRouterAbi = [
+    {
+        name: "exactInputSingle",
+        type: "function",
+        stateMutability: "payable",
+        inputs: [
+            {
+                name: "params",
+                type: "tuple",
+                components: [
+                    { name: "tokenIn", type: "address" },
+                    { name: "tokenOut", type: "address" },
+                    { name: "fee", type: "uint24" },
+                    { name: "recipient", type: "address" },
+                    { name: "amountIn", type: "uint256" },
+                    { name: "amountOutMinimum", type: "uint256" },
+                    { name: "sqrtPriceLimitX96", type: "uint160" },
+                ],
+            },
+        ],
+        outputs: [{ name: "amountOut", type: "uint256" }],
+    },
+    {
+        name: "multicall",
+        type: "function",
+        stateMutability: "payable",
+        inputs: [
+            { name: "deadline", type: "uint256" },
+            { name: "data", type: "bytes[]" },
+        ],
+        outputs: [{ name: "results", type: "bytes[]" }],
+    },
+    {
+        name: "unwrapWETH9",
+        type: "function",
+        stateMutability: "payable",
+        inputs: [
+            { name: "amountMinimum", type: "uint256" },
+            { name: "recipient", type: "address" },
+        ],
+        outputs: [],
+    },
+];
+/** Get USDC balance for an address on Base. */
+async function getUsdcBalance(address) {
+    return (await wallet_1.publicClient.readContract({
+        address: USDC,
+        abi: erc20Abi,
+        functionName: "balanceOf",
+        args: [address],
+    }));
+}
+/**
+ * Swap ETH → USDC via Uniswap V3 on Base.
+ * Sends ETH as msg.value; router auto-wraps to WETH.
+ */
+async function swapEthToUsdc(ethAmount, minUsdcOut) {
+    const { account, walletClient } = (0, wallet_1.requireWallet)();
+    const txHash = await walletClient.writeContract({
+        address: SWAP_ROUTER,
+        abi: swapRouterAbi,
+        functionName: "exactInputSingle",
+        args: [
+            {
+                tokenIn: WETH,
+                tokenOut: USDC,
+                fee: FEE_TIER,
+                recipient: account.address,
+                amountIn: ethAmount,
+                amountOutMinimum: minUsdcOut,
+                sqrtPriceLimitX96: 0n,
+            },
+        ],
+        value: ethAmount,
+    });
+    const receipt = await wallet_1.publicClient.waitForTransactionReceipt({ hash: txHash });
+    if (receipt.status === "reverted") {
+        throw new Error("ETH→USDC swap reverted");
+    }
+    // Read USDC balance after swap to report actual amount
+    const usdcBal = await getUsdcBalance(account.address);
+    return { txHash, usdcReceived: (0, viem_1.formatUnits)(usdcBal, 6) };
+}
+/**
+ * Swap USDC → ETH via Uniswap V3 on Base.
+ * Approves USDC (if needed), then multicalls [exactInputSingle, unwrapWETH9].
+ */
+async function swapUsdcToEth(usdcAmount, minEthOut) {
+    const { account, walletClient } = (0, wallet_1.requireWallet)();
+    // Check and set USDC allowance
+    const allowance = (await wallet_1.publicClient.readContract({
+        address: USDC,
+        abi: erc20Abi,
+        functionName: "allowance",
+        args: [account.address, SWAP_ROUTER],
+    }));
+    if (allowance < usdcAmount) {
+        const approveTx = await walletClient.writeContract({
+            address: USDC,
+            abi: erc20Abi,
+            functionName: "approve",
+            args: [SWAP_ROUTER, usdcAmount],
+        });
+        await wallet_1.publicClient.waitForTransactionReceipt({ hash: approveTx });
+    }
+    // Encode exactInputSingle: USDC → WETH, recipient = SWAP_ROUTER (so it holds WETH)
+    const swapData = (0, viem_1.encodeFunctionData)({
+        abi: swapRouterAbi,
+        functionName: "exactInputSingle",
+        args: [
+            {
+                tokenIn: USDC,
+                tokenOut: WETH,
+                fee: FEE_TIER,
+                recipient: SWAP_ROUTER, // Router holds WETH temporarily
+                amountIn: usdcAmount,
+                amountOutMinimum: minEthOut,
+                sqrtPriceLimitX96: 0n,
+            },
+        ],
+    });
+    // Encode unwrapWETH9: router converts WETH → ETH and sends to user
+    const unwrapData = (0, viem_1.encodeFunctionData)({
+        abi: swapRouterAbi,
+        functionName: "unwrapWETH9",
+        args: [minEthOut, account.address],
+    });
+    const deadline = BigInt(Math.floor(Date.now() / 1000) + 300); // 5 min
+    const txHash = await walletClient.writeContract({
+        address: SWAP_ROUTER,
+        abi: swapRouterAbi,
+        functionName: "multicall",
+        args: [deadline, [swapData, unwrapData]],
+    });
+    const receipt = await wallet_1.publicClient.waitForTransactionReceipt({ hash: txHash });
+    if (receipt.status === "reverted") {
+        throw new Error("USDC→ETH swap reverted");
+    }
+    const ethBal = await wallet_1.publicClient.getBalance({ address: account.address });
+    return { txHash, ethReceived: (0, viem_1.formatEther)(ethBal) };
+}

package/dist/config.js

@@ -79,6 +79,7 @@ const chainName = resolveChainName();
 exports.config = {
     privateKey: parsePrivateKey(process.env.PRIVATE_KEY),
     rpcUrl: process.env.RPC_URL ?? DEFAULT_RPC_URL,
+    useX402: !process.env.RPC_URL,
     llmProvider: normalizeProvider(process.env.LLM_PROVIDER),
     llmApiKey: resolveLlmApiKey(normalizeProvider(process.env.LLM_PROVIDER)),
     llmModel: process.env.LLM_MODEL ?? DEFAULT_LLM_MODEL,

package/dist/dashboard.js

@@ -43,6 +43,7 @@ const node_path_1 = require("node:path");
 const viem_1 = require("viem");
 const chains_1 = require("viem/chains");
 const dashboard_html_1 = require("./dashboard-html");
+const x402_1 = require("./x402");
 const AgentCoin_json_1 = __importDefault(require("./abi/AgentCoin.json"));
 const MiningAgent_json_1 = __importDefault(require("./abi/MiningAgent.json"));
 const AgentCoinAbi = AgentCoin_json_1.default;
@@ -186,10 +187,13 @@ function parseArtFromTokenUri(raw) {
 }
 // --- Server ---
 function startDashboardServer(opts) {
-    const { port, walletsPath, rpcUrl, miningAgentAddress, agentCoinAddress } = opts;
+    const { port, walletsPath, rpcUrl, useX402, privateKey, miningAgentAddress, agentCoinAddress } = opts;
+    const transport = useX402 && privateKey
+        ? (0, x402_1.createX402Transport)(privateKey)
+        : (0, viem_1.http)(rpcUrl);
     const publicClient = (0, viem_1.createPublicClient)({
         chain: chains_1.base,
-        transport: (0, viem_1.http)(rpcUrl),
+        transport,
     });
     const artCache = new Map();
     const htmlPage = (0, dashboard_html_1.getDashboardHtml)();

package/dist/errors.js

@@ -69,6 +69,14 @@ const patterns = [
             recovery: "Run `apow setup` to configure a valid key",
         }),
     },
+    {
+        test: (m) => /\b402\b/.test(m) || m.toLowerCase().includes("x402") || (m.toLowerCase().includes("insufficient") && m.toLowerCase().includes("usdc")),
+        classify: () => ({
+            category: "transient",
+            userMessage: "x402 RPC payment failed — check USDC balance on Base",
+            recovery: "Send USDC to your wallet on Base, or set RPC_URL in .env to use a free RPC",
+        }),
+    },
     {
         test: (m) => m.toLowerCase().includes("insufficient funds"),
         classify: () => ({
@@ -85,6 +93,38 @@ const patterns = [
             recovery: "Try a different model (gpt-4o-mini recommended) or check your LLM API key",
         }),
     },
+    {
+        test: (m) => m.includes("INSUFFICIENT_OUTPUT_AMOUNT") || m.includes("Too little received"),
+        classify: () => ({
+            category: "transient",
+            userMessage: "Uniswap swap failed — slippage exceeded",
+            recovery: "Price moved during swap. Try again — the auto-split will recalculate.",
+        }),
+    },
+    {
+        test: (m) => m.includes("swap reverted"),
+        classify: () => ({
+            category: "transient",
+            userMessage: "Uniswap swap transaction reverted",
+            recovery: "Try again. If persistent, check ETH/USDC balances on Base.",
+        }),
+    },
+    {
+        test: (m) => m.includes("deBridge") && (m.includes("route") || m.includes("unavailable")),
+        classify: () => ({
+            category: "transient",
+            userMessage: "Bridge route temporarily unavailable",
+            recovery: "Try a different bridge method or wait a few minutes",
+        }),
+    },
+    {
+        test: (m) => m.includes("ethereum-rpc.publicnode") || (m.includes("ETHEREUM_RPC") && m.includes("unreachable")),
+        classify: () => ({
+            category: "setup",
+            userMessage: "Ethereum mainnet RPC unreachable",
+            recovery: "Set ETHEREUM_RPC_URL in .env (default: https://ethereum-rpc.publicnode.com)",
+        }),
+    },
 ];
 function classifyError(error) {
     const message = error instanceof Error ? error.message : String(error);