apow-cli 0.1.2 → 0.1.4

package/dist/miner.js

@@ -265,21 +265,19 @@ async function startMining(tokenId) {
                 throw new Error("Mine transaction reverted on-chain");
             }
             txSpinner.stop("Submitting transaction... confirmed");
-            // Fetch post-mine stats
-            const [tokenMineCount, earnings] = await Promise.all([
-                wallet_1.publicClient.readContract({
-                    address: config_1.config.agentCoinAddress,
-                    abi: agentCoinAbi,
-                    functionName: "tokenMineCount",
-                    args: [tokenId],
-                }),
-                wallet_1.publicClient.readContract({
+            // Fetch post-mine earnings with retry (public RPC may lag)
+            let earnings = runningTotal;
+            for (let retry = 0; retry < 5; retry++) {
+                earnings = (await wallet_1.publicClient.readContract({
                     address: config_1.config.agentCoinAddress,
                     abi: agentCoinAbi,
                     functionName: "tokenEarnings",
                     args: [tokenId],
-                }),
-            ]);
+                }));
+                if (earnings > runningTotal)
+                    break;
+                await new Promise((r) => setTimeout(r, 2000));
+            }
             const delta = earnings - runningTotal;
             runningTotal = earnings;
             console.log(`  ${ui.green("+")} ${(0, viem_1.formatEther)(delta)} AGENT | Total: ${(0, viem_1.formatEther)(earnings)} AGENT | Tx: ${ui.dim((0, explorer_1.txUrl)(txHash))}`);

package/dist/mint.js

@@ -72,33 +72,6 @@ function deriveChallengeFromSeed(seed) {
         totalLength,
     ]);
 }
-async function findMintedTokenId(startTokenId, endTokenIdExclusive, owner, blockNumber) {
-    for (let tokenId = startTokenId; tokenId < endTokenIdExclusive; tokenId += 1n) {
-        try {
-            const [tokenOwner, mintBlock] = await Promise.all([
-                wallet_1.publicClient.readContract({
-                    address: config_1.config.miningAgentAddress,
-                    abi: miningAgentAbi,
-                    functionName: "ownerOf",
-                    args: [tokenId],
-                }),
-                wallet_1.publicClient.readContract({
-                    address: config_1.config.miningAgentAddress,
-                    abi: miningAgentAbi,
-                    functionName: "mintBlock",
-                    args: [tokenId],
-                }),
-            ]);
-            if (tokenOwner.toLowerCase() === owner.toLowerCase() && mintBlock === blockNumber) {
-                return tokenId;
-            }
-        }
-        catch {
-            // Ignore missing token ids while scanning the minted window.
-        }
-    }
-    throw new Error("Unable to determine minted token ID from post-mint contract state.");
-}
 async function runMintFlow() {
     const { account, walletClient } = (0, wallet_1.requireWallet)();
     console.log("");
@@ -184,14 +157,21 @@ async function runMintFlow() {
         throw new Error("Challenge request reverted on-chain");
     }
     challengeSpinner.stop("Requesting challenge... done");
-    const challengeSeed = (await wallet_1.publicClient.readContract({
-        address: config_1.config.miningAgentAddress,
-        abi: miningAgentAbi,
-        functionName: "challengeSeeds",
-        args: [account.address],
-    }));
+    // Read challenge seed with retry (public RPC may lag behind tx confirmation)
+    let challengeSeed = ZERO_SEED;
+    for (let retry = 0; retry < 5; retry++) {
+        challengeSeed = (await wallet_1.publicClient.readContract({
+            address: config_1.config.miningAgentAddress,
+            abi: miningAgentAbi,
+            functionName: "challengeSeeds",
+            args: [account.address],
+        }));
+        if (challengeSeed.toLowerCase() !== ZERO_SEED.toLowerCase())
+            break;
+        await new Promise((r) => setTimeout(r, 2000));
+    }
     if (challengeSeed.toLowerCase() === ZERO_SEED.toLowerCase()) {
-        throw new Error("Challenge seed was not stored on-chain.");
+        throw new Error("Challenge seed not found after 5 retries. The RPC may be lagging — try again.");
     }
     // Solve SMHL
     const challenge = deriveChallengeFromSeed(challengeSeed);
@@ -200,11 +180,6 @@ async function runMintFlow() {
         smhlSpinner.update(`Solving SMHL... attempt ${attempt}/5`);
     });
     smhlSpinner.stop("Solving SMHL... done");
-    const nextTokenIdBefore = (await wallet_1.publicClient.readContract({
-        address: config_1.config.miningAgentAddress,
-        abi: miningAgentAbi,
-        functionName: "nextTokenId",
-    }));
     // Mint
     const mintSpinner = ui.spinner("Minting...");
     const mintTx = await walletClient.writeContract({
@@ -221,12 +196,15 @@ async function runMintFlow() {
         throw new Error("Mint transaction reverted on-chain");
     }
     mintSpinner.stop("Minting... confirmed");
-    const nextTokenIdAfter = (await wallet_1.publicClient.readContract({
-        address: config_1.config.miningAgentAddress,
-        abi: miningAgentAbi,
-        functionName: "nextTokenId",
-    }));
-    const tokenId = await findMintedTokenId(nextTokenIdBefore, nextTokenIdAfter, account.address, receipt.blockNumber);
+    // Parse token ID from Transfer event in receipt (avoids stale RPC reads)
+    const TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+    const mintLog = receipt.logs.find((log) => log.address.toLowerCase() === config_1.config.miningAgentAddress.toLowerCase() &&
+        log.topics[0] === TRANSFER_TOPIC &&
+        log.topics[1] === "0x0000000000000000000000000000000000000000000000000000000000000000");
+    if (!mintLog || !mintLog.topics[3]) {
+        throw new Error("Mint tx confirmed but Transfer event not found in logs. Check tx on Basescan.");
+    }
+    const tokenId = BigInt(mintLog.topics[3]);
     const [rarityRaw, hashpowerRaw] = await Promise.all([
         wallet_1.publicClient.readContract({
             address: config_1.config.miningAgentAddress,

package/dist/smhl.js

@@ -59,8 +59,8 @@ function validateSmhlSolution(solution, challenge) {
         return issues;
     }
     const len = Buffer.byteLength(solution, "utf8");
-    if (Math.abs(len - challenge.totalLength) > 5) {
-        issues.push(`length ${len} not within ±5 of ${challenge.totalLength}`);
+    if (Math.abs(len - challenge.totalLength) > 4) {
+        issues.push(`length ${len} not within ±4 of ${challenge.totalLength}`);
     }
     if (!/^[\x20-\x7E]+$/.test(solution)) {
         issues.push("solution must use printable ASCII only");
@@ -82,8 +82,8 @@ function validateSmhlSolution(solution, challenge) {
  */
 function adjustSolution(raw, challenge) {
     const requiredChar = String.fromCharCode(challenge.charValue);
-    const minLen = challenge.totalLength - 5;
-    const maxLen = challenge.totalLength + 5;
+    const minLen = challenge.totalLength - 4;
+    const maxLen = challenge.totalLength + 4;
     const maxWords = challenge.wordCount + 2;
     // Clean: lowercase, letters and spaces only, collapse whitespace
     let words = raw

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apow-cli",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Mine AGENT tokens on Base L2 with AI-powered proof of work",
   "keywords": [
     "apow",

package/skill.md

@@ -53,6 +53,8 @@ npx apow-cli wallet new
 # Captures address + private key from output (also saved to wallet-<address>.txt)
 
 # 2. Write .env directly (no interactive prompts needed)
+#    IMPORTANT: Use an API-based provider (openai/anthropic/gemini), NOT claude-code/codex.
+#    Session-based providers are too slow for the 20-second mint challenge window.
 cat > .env << 'EOF'
 PRIVATE_KEY=0x<from step 1>
 RPC_URL=https://mainnet.base.org
@@ -237,15 +239,17 @@ CHAIN=base
 
 ### LLM Provider Recommendations
 
+> **For AI agents:** Always use an API-based provider (OpenAI, Anthropic, or Gemini). Session-based providers (`claude-code`, `codex`) spawn a CLI subprocess to solve challenges and are too slow to reliably complete the 20-second mint window. They may work for mining (which has no time limit) but will frequently fail during minting.
+
 | Provider | Model | Cost per call | Notes |
 |---|---|---|---|
-| OpenAI | `gpt-4o-mini` | ~$0.001 | Cheapest cloud option |
-| OpenAI | `gpt-4o` | ~$0.005 | Default; good reliability |
+| OpenAI | `gpt-4o-mini` | ~$0.001 | **Recommended for agents.** Cheapest, fastest, reliable |
+| Gemini | `gemini-2.5-flash` | ~$0.001 | Fast, good accuracy |
 | Anthropic | `claude-sonnet-4-5-20250929` | ~$0.005 | High accuracy on constrained generation |
+| OpenAI | `gpt-4o` | ~$0.005 | Higher quality, slightly slower |
 | Ollama | `llama3.1` | Free (local) | Requires local GPU; variable accuracy |
-| Gemini | `gemini-2.5-flash` | ~$0.001 | Fast, good accuracy |
-| Claude Code | `default` | Subscription | Use your existing Claude Code session — no API key needed |
-| Codex | `default` | Subscription | Use your existing Codex session — no API key needed |
+| Claude Code | `default` | Subscription | **Not recommended for minting** — CLI startup too slow for 20s window |
+| Codex | `default` | Subscription | **Not recommended for minting** — CLI startup too slow for 20s window |
 
 ### RPC Recommendations
 
@@ -272,7 +276,7 @@ npx apow-cli mint
 5. On success, an ERC-721 Miner NFT is minted to your wallet with a randomly determined rarity and hashpower.
 6. The mint fee is forwarded to the LPVault (used for AGENT/USDC liquidity — initial LP deployment at threshold, then ongoing `addLiquidity()` to deepen the position).
 
-**Challenge expiry:** 20 seconds from `getChallenge` to `mint`. The LLM must solve quickly.
+**Challenge expiry:** 20 seconds from `getChallenge` to `mint`. The LLM must solve quickly. Use an API-based provider (openai/anthropic/gemini) — session-based providers (claude-code/codex) are too slow and will fail.
 
 ### Mint Price
 
@@ -479,7 +483,7 @@ LLM_PROVIDER=codex
 - The CLI must be available in your PATH
 - Your subscription must be active
 
-**Trade-off:** Session-based solving may be slightly slower than direct API calls due to CLI startup overhead, but eliminates the need for separate API keys and billing. The 15-second timeout ensures challenges are still submitted within the contract's 20-second window.
+**Warning:** Session-based providers (`claude-code`, `codex`) spawn a CLI subprocess for each SMHL challenge. The startup overhead frequently exceeds the 20-second mint challenge window, causing mints to fail with `Expired`. **For minting, always use an API-based provider** (openai, anthropic, or gemini). Session providers may work for the mining loop (which has no time limit per challenge) but are unreliable and not recommended for autonomous operation.
 
 ### Custom RPC Endpoints
 
@@ -522,7 +526,7 @@ Use the corresponding testnet contract addresses.
 | `LLM_API_KEY is required for openai.` | Missing API key for cloud provider | Set `LLM_API_KEY` (or provider-specific key like `OPENAI_API_KEY`) in `.env`, or switch to `ollama` |
 | `Insufficient fee` | Not enough ETH sent with mint | Check `getMintPrice()` and ensure wallet has enough ETH |
 | `Sold out` | All 10,000 Miner NFTs minted | No more rigs available; buy one on secondary market |
-| `Expired` | SMHL challenge expired (>20s) | Your LLM is too slow; use a faster model or provider |
+| `Expired` | SMHL challenge expired (>20s) | Switch to an API-based provider (openai/gemini/anthropic). Session providers (claude-code/codex) are too slow for the 20s mint window |
 | `Invalid SMHL` | LLM produced an incorrect solution | Retry; if persistent, switch to a more capable model |
 | `Not your miner` | Token ID not owned by your wallet | Verify `PRIVATE_KEY` matches the NFT owner; check token ID |
 | `Supply exhausted` | All 18.9M mineable AGENT has been minted | Mining is complete; no more rewards available |