apow-cli 0.7.1 → 0.8.0

package/.env.example

@@ -1,10 +1,11 @@
 # Wallet
 PRIVATE_KEY=
 
-# 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
+# RPC — You need one of these two options:
+# Option 1: Bring your own RPC URL (free from Alchemy, QuickNode, etc.)
+RPC_URL=
+# Option 2: Auto-pay via QuickNode x402 ($10 USDC for ~1M calls, no API key needed)
+# USE_X402=true
 
 # LLM Provider (openai / anthropic / gemini / ollama / claude-code / codex)
 LLM_PROVIDER=openai

package/README.md

@@ -1,6 +1,6 @@
 # APoW CLI
 
-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-721 Mining Rig, then compete on hash power to mine $AGENT tokens.
+Mining client for the [APoW (Agentic Proof of Work)](https://github.com/Agentoshi/apow-core) protocol on Base. Prove you're an AI agent once by minting an ERC-721 Mining Rig, then compete on hash power to mine $AGENT tokens.
 
 **Your agent does all the work. You just fund a wallet.**
 
@@ -16,13 +16,14 @@ Or run directly:
 npx apow-cli
 ```
 
-## RPC: Alchemy x402 (Default)
+## RPC Setup
 
-> **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.
+> **v0.8.0+: Bring your own RPC or use auto-pay.** You need a Base RPC endpoint. Two options:
 >
-> **Requirements:** USDC balance on Base in your mining wallet. Even a small amount (1-2 USDC) covers thousands of RPC calls.
+> 1. **Bring your own** (free): Get a free RPC URL from [Alchemy](https://www.alchemy.com/), [QuickNode](https://www.quicknode.com/), or any Base RPC provider. Set `RPC_URL` in your `.env`.
+> 2. **QuickNode x402** (paid, zero setup): Set `USE_X402=true` in your `.env`. Your mining wallet pays $10 USDC for ~1M RPC calls via the [x402 payment protocol](https://www.x402.org/). No API key, no account needed.
 >
-> **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).
+> Run `apow setup` to configure interactively.
 
 ## For AI Agents
 
@@ -35,7 +36,7 @@ npx apow-cli wallet new
 
 # 2. Write .env (no interactive prompts)
 #    LLM config is only needed for minting; mining uses optimized SMHL solving
-#    RPC defaults to Alchemy x402 (paid via USDC) — no RPC_URL needed
+#    RPC: set RPC_URL for a free RPC, or USE_X402=true for auto-pay ($10 USDC)
 cat > .env << 'EOF'
 PRIVATE_KEY=0x<from step 1>
 LLM_PROVIDER=openai               # Required for minting only
@@ -47,7 +48,7 @@ EOF
 npx apow-cli fund --chain solana --token sol    # bridge SOL → 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 AI via LLM, one-time)
 npx apow-cli mint
 
 # 5. Start mining (runs forever, no LLM needed, multi-threaded)
@@ -109,7 +110,8 @@ Create a `.env` file or use `apow setup`:
 
 ```bash
 PRIVATE_KEY=0x...              # Your wallet private key
-# RPC_URL=https://mainnet.base.org  # Optional: set to override default Alchemy x402
+RPC_URL=https://...            # Your Base RPC URL (free from Alchemy, QuickNode, etc.)
+# USE_X402=true                # Or: auto-pay via QuickNode x402 ($10 USDC for ~1M calls)
 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
@@ -161,7 +163,7 @@ apow fund --chain base --no-swap
 
 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-721 Mining Rig.
+- **Algorithmic SMHL**: Mining SMHL challenges are solved algorithmically in microseconds (no LLM call). Your AI was already proven when you minted your 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.

package/dist/config.js

@@ -15,7 +15,6 @@ const node_path_1 = require("node:path");
 const chains_1 = require("viem/chains");
 (0, dotenv_1.config)();
 const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
-const DEFAULT_RPC_URL = "https://mainnet.base.org";
 const DEFAULT_LLM_PROVIDER = "openai";
 const DEFAULT_LLM_MODEL = "gpt-4o-mini";
 const DEFAULT_OLLAMA_URL = "http://127.0.0.1:11434";
@@ -35,7 +34,7 @@ function resolveChainName() {
     if (envChain === "base" || envChain === "baseSepolia") {
         return envChain;
     }
-    const rpcUrl = process.env.RPC_URL ?? DEFAULT_RPC_URL;
+    const rpcUrl = process.env.RPC_URL ?? "";
     if (rpcUrl.toLowerCase().includes("sepolia")) {
         return "baseSepolia";
     }
@@ -78,8 +77,8 @@ function resolveLlmApiKey(provider) {
 const chainName = resolveChainName();
 exports.config = {
     privateKey: parsePrivateKey(process.env.PRIVATE_KEY),
-    rpcUrl: process.env.RPC_URL ?? DEFAULT_RPC_URL,
-    useX402: !process.env.RPC_URL,
+    rpcUrl: process.env.RPC_URL ?? "",
+    useX402: process.env.USE_X402 === "true",
     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

@@ -50,7 +50,7 @@ const AgentCoinAbi = AgentCoin_json_1.default;
 const MiningAgentAbi = MiningAgent_json_1.default;
 const RARITY_LABELS = ["Common", "Uncommon", "Rare", "Epic", "Mythic"];
 const ADDR_RE = /^0x[0-9a-fA-F]{40}$/;
-const DEFAULT_RPC = "https://mainnet.base.org";
+const DEFAULT_RPC = ""; // No default public RPC — x402 is the default
 const FLEETS_PATH = (0, node_path_1.join)(process.env.HOME ?? "", ".apow", "fleets.json");
 // --- Wallet / Fleet loading ---
 function isAddress(s) {
@@ -427,7 +427,7 @@ function startDashboardServer(opts) {
         return JSON.stringify(fleets.map((f) => ({ name: f.name, walletCount: f.addresses.length })));
     }
     function handleConfig() {
-        const rpcIsDefault = rpcUrl === DEFAULT_RPC;
+        const rpcIsDefault = useX402 || rpcUrl === DEFAULT_RPC;
         const walletCount = getWalletAddresses(walletsPath).length;
         return JSON.stringify({ rpcIsDefault, walletCount });
     }

package/dist/errors.js

@@ -73,8 +73,8 @@ const patterns = [
         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",
+            userMessage: "QuickNode x402 credit purchase failed — check USDC balance on Base",
+            recovery: "Send USDC to your wallet on Base (~$10 for ~1M RPC calls), or set RPC_URL in .env to use a custom RPC",
         }),
     },
     {

package/dist/index.js

@@ -170,10 +170,28 @@ async function setupWizard() {
     console.log("");
     // Step 2: RPC
     console.log(`  ${ui.bold("Step 2/3: RPC")}`);
-    console.log(`  ${ui.dim("Default: Alchemy x402 — premium RPC paid automatically")}`);
-    console.log(`  ${ui.dim("via USDC in your mining wallet. No API key needed.")}`);
-    console.log(`  ${ui.dim("To use a custom RPC, set RPC_URL in .env after setup.")}`);
-    ui.ok("RPC: Alchemy x402 (default)");
+    console.log(`  ${ui.dim("You need a Base RPC endpoint. Two options:")}`);
+    console.log(`  ${ui.dim("  1. Bring your own (free from Alchemy, QuickNode, etc.)")}`);
+    console.log(`  ${ui.dim("  2. Auto-pay via QuickNode x402 ($10 USDC for ~1M calls)")}`);
+    const hasRpc = await ui.confirm("Do you have a Base RPC URL?");
+    if (hasRpc) {
+        const rpcUrl = await ui.prompt("RPC URL");
+        if (rpcUrl) {
+            values.RPC_URL = rpcUrl;
+            ui.ok(`RPC: Custom (${rpcUrl.slice(0, 40)}${rpcUrl.length > 40 ? "..." : ""})`);
+        }
+        else {
+            ui.warn("No URL provided — using QuickNode x402");
+            values.USE_X402 = "true";
+            ui.ok("RPC: QuickNode x402 ($10 USDC for ~1M calls)");
+        }
+    }
+    else {
+        values.USE_X402 = "true";
+        console.log(`  ${ui.dim("QuickNode x402 will charge $10 USDC from your mining wallet")}`);
+        console.log(`  ${ui.dim("for ~1M RPC calls. No API key or account needed.")}`);
+        ui.ok("RPC: QuickNode x402 ($10 USDC for ~1M calls)");
+    }
     console.log("");
     // Step 3: LLM (for minting)
     console.log(`  ${ui.bold("Step 3/3: LLM Provider (for minting)")}`);

package/dist/preflight.js

@@ -42,7 +42,6 @@ const chains_1 = require("viem/chains");
 const AgentCoin_json_1 = __importDefault(require("./abi/AgentCoin.json"));
 const config_1 = require("./config");
 const wallet_1 = require("./wallet");
-const x402_1 = require("./x402");
 const ui = __importStar(require("./ui"));
 const agentCoinAbi = AgentCoin_json_1.default;
 const USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
@@ -70,29 +69,16 @@ async function runPreflight(level) {
     else {
         results.push({ label: "Contract addresses configured", passed: true });
     }
-    // Check 2: RPC reachable + chain ID
-    try {
-        const chainId = await wallet_1.publicClient.getChainId();
-        const expectedId = config_1.config.chain.id;
-        if (chainId !== expectedId) {
-            results.push({
-                label: `RPC chain mismatch — expected ${expectedId}, got ${chainId}`,
-                passed: false,
-                fix: "Update RPC_URL to point to the correct network",
-            });
-        }
-        else {
-            results.push({ label: `RPC connected — ${config_1.config.chain.name}`, passed: true });
-        }
-    }
-    catch {
+    // Check: RPC configured (either RPC_URL or USE_X402)
+    if (!config_1.config.useX402 && !config_1.config.rpcUrl) {
         results.push({
-            label: `RPC unreachable — could not connect to ${config_1.config.rpcUrl}`,
+            label: "No RPC configured",
             passed: false,
-            fix: "Check internet connection or update RPC_URL in .env",
+            fix: "Run `apow setup` to configure RPC, or set RPC_URL or USE_X402=true in .env",
         });
     }
-    // Check x402: USDC balance when x402 mode is active
+    // Check x402: USDC balance BEFORE RPC check (can't use x402 without USDC)
+    let x402Funded = false;
     if (config_1.config.useX402 && wallet_1.account) {
         try {
             // Use a separate lightweight client to avoid chicken-and-egg
@@ -108,27 +94,53 @@ async function runPreflight(level) {
                 args: [wallet_1.account.address],
             }));
             if (usdcBalance === 0n) {
-                ui.warn("No USDC balance — x402 RPC requires USDC on Base for payment");
-                ui.hint(`Send USDC to ${wallet_1.account.address} on Base, or set RPC_URL in .env to use a free RPC`);
-                ui.hint("Falling back to public RPC (https://mainnet.base.org)");
-                config_1.config.useX402 = false;
-                (0, x402_1.resetX402)();
-                (0, wallet_1.reinitClients)();
+                results.push({
+                    label: "No USDC balance — QuickNode x402 requires USDC on Base",
+                    passed: false,
+                    fix: `Send USDC to ${wallet_1.account.address} on Base (~$10 for ~1M RPC calls). Run \`apow fund\` to bridge from Solana.`,
+                });
             }
             else {
+                x402Funded = true;
                 const formatted = (0, viem_1.formatUnits)(usdcBalance, USDC_DECIMALS);
                 results.push({
-                    label: `RPC: Alchemy x402 (${formatted} USDC available)`,
+                    label: `RPC: QuickNode x402 (${formatted} USDC available)`,
                     passed: true,
                 });
             }
         }
         catch {
-            // USDC check failed — fall back silently
-            ui.warn("Could not check USDC balance — falling back to public RPC");
-            config_1.config.useX402 = false;
-            (0, x402_1.resetX402)();
-            (0, wallet_1.reinitClients)();
+            // USDC check failed — can't verify, warn but don't block
+            x402Funded = true; // optimistic — let the RPC check determine reachability
+            ui.warn("Could not check USDC balance — QuickNode x402 may fail if wallet has no USDC");
+        }
+    }
+    // Check 2: RPC reachable + chain ID
+    // Skip when: no RPC configured at all, or x402 active but unfunded
+    const hasRpc = config_1.config.useX402 || !!config_1.config.rpcUrl;
+    if (hasRpc && (!config_1.config.useX402 || x402Funded)) {
+        try {
+            const chainId = await wallet_1.publicClient.getChainId();
+            const expectedId = config_1.config.chain.id;
+            if (chainId !== expectedId) {
+                results.push({
+                    label: `RPC chain mismatch — expected ${expectedId}, got ${chainId}`,
+                    passed: false,
+                    fix: "Update RPC_URL to point to the correct network",
+                });
+            }
+            else {
+                results.push({ label: `RPC connected — ${config_1.config.chain.name}`, passed: true });
+            }
+        }
+        catch {
+            results.push({
+                label: `RPC unreachable — could not connect to ${config_1.config.useX402 ? "QuickNode x402" : config_1.config.rpcUrl}`,
+                passed: false,
+                fix: config_1.config.useX402
+                    ? "Check internet connection and USDC balance, or set RPC_URL in .env for a custom RPC"
+                    : "Check internet connection or update RPC_URL in .env",
+            });
         }
     }
     if (level === "wallet" || level === "mining") {

package/dist/x402.js

@@ -1,45 +1,81 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createX402Transport = createX402Transport;
 exports.resetX402 = resetX402;
-const accounts_1 = require("viem/accounts");
 const viem_1 = require("viem");
-const ALCHEMY_X402_BASE = "https://x402.alchemy.com/rpc/base-mainnet";
-let _paidFetch = null;
-/* eslint-disable @typescript-eslint/no-require-imports */
-function getPaidFetchSync(privateKey) {
-    if (_paidFetch)
-        return _paidFetch;
-    // Use require() to avoid subpath module resolution issues with CommonJS.
-    // The x402 packages use `exports` maps which require "node16"/"bundler"
-    // moduleResolution — but this project uses classic "Node" resolution.
-    const { x402Client } = require("@x402/core/client");
-    const { ExactEvmScheme } = require("@x402/evm/exact/client");
-    const { toClientEvmSigner } = require("@x402/evm");
-    const { wrapFetchWithPayment } = require("@x402/fetch");
-    const account = (0, accounts_1.privateKeyToAccount)(privateKey);
-    const signer = toClientEvmSigner(account);
-    const client = new x402Client();
-    client.register("eip155:*", new ExactEvmScheme(signer));
-    _paidFetch = wrapFetchWithPayment(fetch, client);
-    return _paidFetch;
+const QUICKNODE_BASE = "https://x402.quicknode.com";
+const BASE_MAINNET = "eip155:8453";
+let _client = null;
+async function getClient(privateKey) {
+    if (_client && !_client.isTokenExpired())
+        return _client;
+    const { createQuicknodeX402Client } = await Promise.resolve().then(() => __importStar(require("@quicknode/x402")));
+    _client = await createQuicknodeX402Client({
+        baseUrl: QUICKNODE_BASE,
+        network: BASE_MAINNET,
+        evmPrivateKey: privateKey,
+        preAuth: true,
+        // paymentModel defaults to 'credit-drawdown' — no per-request payments
+    });
+    return _client;
 }
 function createX402Transport(privateKey) {
     return (0, viem_1.custom)({
         async request({ method, params }) {
-            const paidFetch = getPaidFetchSync(privateKey);
-            const response = await paidFetch(ALCHEMY_X402_BASE, {
+            const client = await getClient(privateKey);
+            const response = await client.fetch(`${QUICKNODE_BASE}/base-mainnet`, {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
                 body: JSON.stringify({ jsonrpc: "2.0", method, params, id: 1 }),
             });
+            if (response.status === 402) {
+                throw new Error("x402 payment failed — insufficient USDC balance on Base");
+            }
+            if (!response.ok) {
+                throw new Error(`QuickNode x402 HTTP ${response.status}: ${response.statusText}`);
+            }
             const data = (await response.json());
-            if (data.error)
-                throw new Error(data.error.message);
+            if (data.error) {
+                const msg = typeof data.error === "string" ? data.error : data.error.message;
+                throw new Error(msg);
+            }
             return data.result;
         },
     });
 }
 function resetX402() {
-    _paidFetch = null;
+    _client = null;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apow-cli",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "Mine AGENT tokens on Base L2 with Agentic Proof of Work",
   "keywords": [
     "apow",
@@ -39,9 +39,8 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
+    "@quicknode/x402": "^0.1.2",
     "@solana/web3.js": "^1.98.0",
-    "@x402/evm": "^2.8.0",
-    "@x402/fetch": "^2.8.0",
     "commander": "^14.0.0",
     "dotenv": "^17.2.3",
     "openai": "^6.6.0",

package/skill.md

@@ -25,7 +25,7 @@ metadata:
 configure the miner, mint, and mine. The only step that requires your user is funding the wallet
 with ETH on Base. Everything else you handle yourself.
 
-> **RPC:** The CLI uses [Alchemy x402](https://x402.alchemy.com/) by default -- a premium Base RPC that charges per-request via USDC in your mining wallet. No API key, no account, no rate limits. Just fund your wallet with USDC (the `apow fund` command handles this automatically). If no USDC is available, it falls back to the public RPC. To use a custom RPC, set `RPC_URL` in `.env`.
+> **RPC:** You need a Base RPC endpoint. Either set `RPC_URL` in `.env` (free from Alchemy, QuickNode, etc.) or set `USE_X402=true` to auto-pay via [QuickNode x402](https://x402.quicknode.com/) ($10 USDC for ~1M calls, no API key needed). Run `apow setup` to configure interactively.
 
 ---
 
@@ -93,7 +93,7 @@ SMHL ("Show Me Human Language") serves two different roles in APoW:
 
 **SMHL for Minting (identity verification):** When minting a Mining Rig, your LLM solves an SMHL challenge to prove agent capability. This is the "prove yourself" gate: your agent demonstrates it can solve constrained text generation. The LLM receives a prompt like: "Generate a sentence that is approximately N characters long, contains approximately W words, and includes the letter 'X'."
 
-**SMHL for Mining (algorithmic):** During mining, SMHL solutions are generated algorithmically in microseconds, with no LLM needed. Your agent identity was already established when you minted your ERC-721 Mining Rig. Mining is a hash power competition, not a language puzzle.
+**SMHL for Mining (algorithmic):** During mining, SMHL solutions are generated algorithmically in microseconds, with no LLM needed. Your AI was already proven when you minted your Mining Rig. Mining is a hash power competition, not a language puzzle.
 
 On-chain verification checks (both minting and mining):
 1. **Length** (in bytes): within ±5 of the target
@@ -263,7 +263,8 @@ CHAIN=base
 | `LLM_API_KEY` | For minting | - | API key for minting. Falls back to `OPENAI_API_KEY` / `GEMINI_API_KEY` / `DEEPSEEK_API_KEY` / `DASHSCOPE_API_KEY` / `ANTHROPIC_API_KEY` per provider. Not needed for `ollama` or mining. |
 | `LLM_MODEL` | For minting | `gpt-4o-mini` | Model identifier passed to the provider (minting only) |
 | `MINER_THREADS` | No | All CPU cores | Number of threads for parallel nonce grinding |
-| `RPC_URL` | No | Alchemy x402 | Base JSON-RPC endpoint. Default uses Alchemy x402 (premium, paid via USDC). Set to override with a custom endpoint. |
+| `RPC_URL` | Yes* | — | Base JSON-RPC endpoint. Get a free URL from Alchemy or QuickNode. *Not needed if `USE_X402=true`. |
+| `USE_X402` | No | `false` | Set to `true` to auto-pay via QuickNode x402 ($10 USDC for ~1M calls). Replaces `RPC_URL`. |
 | `CHAIN` | No | `base` | Network selector; auto-detects `baseSepolia` if RPC URL contains "sepolia" |
 | `SOLANA_RPC_URL` | No | `https://api.mainnet-beta.solana.com` | Solana RPC endpoint (only for `apow fund --chain solana`) |
 | `SQUID_INTEGRATOR_ID` | No | - | Squid Router integrator ID for deposit address flow (free at [squidrouter.com](https://app.squidrouter.com/)) |
@@ -545,7 +546,7 @@ Set `RPC_URL` in `.env` to any Base-compatible JSON-RPC endpoint. The `CHAIN` va
 
 ### Agent Wallet
 
-Each Miner NFT supports an on-chain agent wallet. This creates a one-rig-one-agent identity model: an NFT owner can delegate mining operations to a separate hot wallet without transferring ownership of the rig.
+Each Miner NFT supports an on-chain agent wallet. This creates a one-rig-one-agent model: an NFT owner can delegate mining operations to a separate hot wallet without transferring ownership of the rig.
 
 **Functions:**
 - `getAgentWallet(tokenId)`: returns the registered agent wallet address