Base Buds Mint

intent

mint a base bud nft from the agent-only collection on base mainnet. use this skill when you have an evm wallet with at least 0.00025-0.000415 eth for gas and 1 usdc on base (chain id 8453), and you can solve challenge puzzles. the flow is deterministic: request challenge, solve it, prepare payment signature, settle payment, sign mint tx, broadcast. all signing happens locally; your private key never leaves your machine.

inputs

evm wallet:

• wallet address (public)
• private key (0x prefixed 64 hex chars, kept local only)
• minimum balance: 0.00025-0.000415 eth on base mainnet for gas
• minimum balance: 1.00 usdc on base mainnet for mint fee

external service:

• base URL: https://budsbase.xyz/api
• endpoints: /challenge, /prepare, /complete, /broadcast (all http post)
• no auth token required
• x402 payment protocol integration (facilitator settles usdc transfer)

local runtime:

• node.js with ethers library (v5 or v6)
• if ethers not installed, install to temp: npm install --prefix /tmp ethers

context:

• base mainnet chain id: 8453
• total collection supply: 6,000 nfts
• per-wallet mint limit: 20 nfts
• challenge expiration: 5 minutes
• eip-712 for usdc payment authorization
• eip-1559 for mint transaction

procedure

step 1: request challenge

input: wallet address (public).

execute:

curl -X POST https://budsbase.xyz/api/challenge \
  -H "Content-Type: application/json" \
  -d '{"wallet": "YOUR_EVM_ADDRESS"}'

output: json object with challengeId (string), puzzle (string), expiresAt (unix timestamp ms). example:

{
  "challengeId": "0xabc123...",
  "puzzle": "What is 347 * 23 + 156?",
  "expiresAt": 1699999999999
}

step 2: solve challenge and prepare payment signature

input: wallet private key, challenge id, challenge answer (string representation of numeric or text solution).

execute: single node script that submits challenge answer to /prepare, then signs usdc payment locally via eip-712. do not split into curl + node steps. script pattern:

import { ethers } from "ethers";

const PK = "YOUR_PRIVATE_KEY";
if (!/^0x[0-9a-fA-F]{64}$/.test(PK)) throw new Error("Invalid private key ,  must be 0x + 64 hex chars");
const wallet = new ethers.Wallet(PK);

// 2a. Submit challenge answer, get payment data
const res = await fetch("https://budsbase.xyz/api/prepare", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ wallet: wallet.address, challengeId: "CHALLENGE_ID", answer: "ANSWER" }),
});
const { prepareId, payment } = await res.json();

// 2b. Sign USDC payment (EIP-712)
const paymentSignature = await wallet.signTypedData(payment.domain, payment.types, payment.values);

console.log(JSON.stringify({ prepareId, paymentSignature }));

before running, check ethers availability: node -e "require('ethers')". if missing, install: npm install --prefix /tmp ethers, then run with NODE_PATH=/tmp/node_modules.

output: json with prepareId (string) and paymentSignature (0x prefixed hex string).

step 3: settle payment and get unsigned mint transaction

input: prepareId and paymentSignature from step 2.

execute:

curl -X POST https://budsbase.xyz/api/complete \
  -H "Content-Type: application/json" \
  -d '{
    "prepareId": "0x<from_step_2>",
    "paymentSignature": "0x<from_step_2>"
  }'

output: json with success (boolean), settleTxHash (0x prefixed tx hash), transaction (unsigned tx object with keys: to, data, chainId, nonce, type, etc.), message (string). example:

{
  "success": true,
  "settleTxHash": "0x...",
  "transaction": { "to": "0x...", "data": "0x...", "chainId": 8453, "nonce": 5, "type": 2 },
  "message": "Payment settled. Sign the transaction and POST to /api/broadcast."
}

step 4: sign mint transaction and broadcast

input: unsigned transaction object from step 3, wallet private key.

execute: single node script that signs the transaction locally, then curl to post signed tx.

import { ethers } from "ethers";

const PK = "YOUR_PRIVATE_KEY";
if (!/^0x[0-9a-fA-F]{64}$/.test(PK)) throw new Error("Invalid private key ,  must be 0x + 64 hex chars");
const wallet = new ethers.Wallet(PK);
const transaction = /* transaction object from Step 3 */;

const signedTransaction = await wallet.signTransaction(transaction);
console.log(JSON.stringify({ signedTransaction }));

then:

curl -X POST https://budsbase.xyz/api/broadcast \
  -H "Content-Type: application/json" \
  -d '{"signedTransaction": "0x<from_above>"}'

output: json with success (boolean), tokenId (integer), minter (0x address), txHash (0x tx hash), minted (total mints by this wallet), remaining (remaining mints allowed for this wallet), message (string). example:

{
  "success": true,
  "tokenId": 9,
  "minter": "0x...",
  "txHash": "0x...",
  "minted": 2,
  "remaining": 18,
  "message": "Successfully minted Base Bud #9! You have minted 2 Base Buds. You can mint up to 18 more."
}

decision points

challenge request fails with 409 (mint limit reached): wallet has already minted 20 nfts (per-wallet limit). ask user for a new wallet address and private key. restart from step 1.

challenge request fails with 410 (collection fully minted): the 6,000 nft collection is sold out. skill cannot proceed.

challenge request fails with 400 (invalid wallet address): wallet address is malformed or missing. ask user to verify the address format (0x + 40 hex chars).

challenge request fails with 500 (server error): budsbase.xyz api is down. retry after 30 seconds or check https://budsbase.xyz/status.

step 2 (prepare) fails with 403 (challenge answer incorrect or expired): either the answer is wrong, or the 5-minute challenge window closed. restart from step 1 to request a new challenge.

step 2 (prepare) fails with 400 (missing fields): wallet address or challengeId missing from request. verify both are present and correct format.

step 3 (complete) fails with 400, code: prepare_session_expired: the prepareId is no longer valid (expired or consumed). call /prepare again from step 2.

step 3 (complete) fails with 400, code: authorization_expired or authorization_not_yet_valid: usdc authorization window has passed or not yet started. this is a time-sync issue or malformed payment data. restart from step 2.

step 3 (complete) fails with 400, code: insufficient_usdc_balance: wallet has less than 1 usdc on base. ask user to top up usdc and retry.

step 3 (complete) fails with 402 (payment_verification_failed or payment_settlement_failed): x402 facilitator rejected the payment signature or usdc transfer failed. this usually means signature was malformed or wallet is blocked. ask user to check usdc allowance or try a different wallet from step 1.

step 4 (broadcast) fails with 400, code: nonce_too_low: wallet has pending transactions on base. wait for pending txs to confirm, then call /complete again from step 3.

step 4 (broadcast) fails with 400, code: insufficient_eth: not enough eth for gas (need 0.00025-0.000415). ask user to add eth and restart from step 3.

step 4 (broadcast) fails with 409 (already_known): transaction was already submitted. this is likely a duplicate. check the blockchain for the tx hash or contact support.

step 4 (broadcast) fails with 400, code: mint_reverted: mint transaction reverted on-chain. this is a contract-level failure (wallet not whitelisted, nft unavailable, etc.). contact budsbase.xyz support.

step 4 (broadcast) fails with 500 (broadcast_failed): network broadcast failed. retry once; if it persists, the tx may still confirm on-chain (check etherscan for the tx hash).

ethers library not found: before running step 2 or step 4 scripts, check: node -e "require('ethers')". if it fails, install to temp: npm install --prefix /tmp ethers, then run script with NODE_PATH=/tmp/node_modules node script.js.

network timeout or dns failure: if any curl or fetch fails due to network, retry up to 2 times before escalating. base mainnet rpc is stable but x402 facilitator may be under load.

output contract

on success:

• txHash: 0x prefixed transaction hash of the broadcast mint tx
• tokenId: positive integer, the nft id assigned to the wallet
• minter: 0x prefixed evm address of the minter (same as input wallet)
• minted: total count of nfts minted by this wallet so far (1-20)
• remaining: count of mints still allowed for this wallet (0-19)
• settleTxHash: 0x prefixed hash of the usdc payment settlement tx from step 3

format: log or display all fields from the final /broadcast response. do not expose private keys in any output or logs.

file location: no files written. all state is in-memory or stored on budsbase.xyz (challenge sessions, prepare sessions).

data format: all responses are json. all hashes, addresses, and signatures are 0x prefixed hex strings. all numeric values (tokenId, nonce, chainId, etc.) are integers or strings per the api response.

outcome signal

user successfully minted a base bud when:

1. step 4 (broadcast) returns http 200 with success: true
2. response includes txHash (0x prefixed, non-empty string)
3. response includes tokenId (positive integer)
4. response includes message containing "Successfully minted"
5. remaining count is less than 20 (showing the wallet is now 1 mint closer to the limit)

user can verify on-chain:

• visit https://basescan.io, search for the txHash
• confirm tx status is "success"
• search for the minter address on opensea or nft marketplace to view the nft

if broadcast returns success but remaining does not decrement, or txHash is invalid, ask user to manually check basescan. the nft may still be in mempool.

---

credits: original skill by tron04736-star (clawhub). enriched per implexa qc standards.