Agenticbets

AgenticBets

Prediction markets on Base. Bet UP or DOWN on token prices with USDC.

When To Use

Use AgenticBets when the user wants to:

• Bet on whether a token price goes up or down (e.g., "bet $5 UP on AGBETS")
• Check prediction market odds (e.g., "what are the odds on AGBETS?")
• See which markets are open (e.g., "what prediction markets can I bet on?")
• Claim winnings from settled rounds
• Check their bet status or claimable winnings

Prerequisites

Bankr CLI

Install the Bankr CLI and log in to get an API key:

bun install -g @bankr/cli
# or: npm install -g @bankr/cli

Bankr API Key

The scripts read the API key from ~/.bankr/config.json (or $BANKR_CONFIG if set).

Option A: CLI login (recommended)

# Step 1 — send OTP
bankr login email user@example.com

# Step 2 — verify and generate key with write access
bankr login email user@example.com --code 123456 --accept-terms --key-name "AgenticBets" --read-write

Option B: Web login

1. Visit bankr.bot/api 2. Sign in with email + OTP 3. Generate an API key with Wallet API write access enabled

The API key must have write access (walletApiEnabled, not readOnly) to place bets and claim winnings. Read-only keys can still list markets and check odds.

USDC Balance

Make sure your Bankr wallet has USDC on Base before betting. Check with:

bankr wallet portfolio

Quick Start

List Open Markets

What prediction markets are open on AgenticBets?

scripts/agenticbets.py list

Check Odds

What are the odds on AGBETS?

scripts/agenticbets.py odds AGBETS

Place a Bet

Bet $5 UP on AGBETS

scripts/agenticbets.py bet AGBETS up 5

Claim Winnings

Claim my AgenticBets winnings for AGBETS epoch 42

scripts/agenticbets.py claim AGBETS 42

Script Usage

agenticbets.py

Single script that handles all AgenticBets operations. Reads and writes use the Bankr Wallet API.

scripts/agenticbets.py <command> [args...]

Commands:

Environment:

How It Works

Prediction Market Flow

1. A round opens for a token (e.g., $AGBETS) 2. Users bet UP (bull — price goes up) or DOWN (bear — price goes down) with USDC 3. Betting window closes (typically 5 minutes) 4. Price is locked at close 5. After the round duration, price is checked again 6. If price went up → bull wins. If down → bear wins. 7. Winners split the entire pool proportional to their bet size (minus 3% fee)

Transaction Flow (via Bankr Submit API)

All on-chain transactions go through the Bankr Wallet API:

1. Script fetches market data from GET https://agenticbets.dev/api/bankr/markets 2. Script gets wallet address from GET https://api.bankr.bot/wallet/me 3. For bets:

• Approve USDC spend: POST https://api.bankr.bot/wallet/submit with ERC20 approve() calldata
• Place bet: POST https://api.bankr.bot/wallet/submit with bet() calldata

4. For claims: POST https://api.bankr.bot/wallet/submit with claim() calldata 5. All transactions use waitForConfirmation: true and include a human-readable description

Bankr Submit API Reference

Endpoint: POST https://api.bankr.bot/wallet/submit

Headers:

X-API-Key: bk_YOUR_API_KEY
Content-Type: application/json

Request body:

{
  "transaction": {
    "to": "0xContractAddress",
    "chainId": 8453,
    "data": "0xCalldata...",
    "value": "0"
  },
  "description": "Place $5 UP bet on AGBETS",
  "waitForConfirmation": true
}

Success response:

{
  "success": true,
  "transactionHash": "0x...",
  "status": "success",
  "blockNumber": "12345678",
  "signer": "0xYourWalletAddress",
  "chainId": 8453
}

Wallet info: GET https://api.bankr.bot/wallet/me returns the wallet address and supported chains.

Contracts

Contract Functions

bet(address _token, uint256 _amount, uint8 _position)

• _token — token contract address
• _amount — USDC amount in raw units (multiply by 1e6)
• _position — 0 = Bull (UP), 1 = Bear (DOWN)
• Selector: 0x37a02e62

claim(address _token, uint256[] _epochs)

• _token — token contract address
• _epochs — array of epoch numbers to claim
• Selector: 0x45718278

claimable(address _token, uint256 _epoch, address _user) -> bool

• Returns true if the user has unclaimed winnings for that epoch
• Selector: 0xd3c035fc

USDC Approval

Before betting, the script approves USDC spend on the prediction contract:

ERC20.approve(predictionContractAddress, betAmount)

• Selector: 0x095ea7b3

Token Addresses

Use the /api/bankr/markets endpoint to get current token addresses — don't hardcode.

Markets API

GET https://agenticbets.dev/api/bankr/markets

Returns:

{
  "markets": [
    {
      "token": "0x37d183FCf1DA460a64D21E754b3E6144C4e11BA3",
      "symbol": "AGBETS",
      "marketUrl": "https://agenticbets.dev/market#...",
      "poolUsdc": 42.50,
      "bullPct": 61.0,
      "bearPct": 39.0,
      "lockTimestamp": 1713100000,
      "secondsToLock": 83,
      "predictionContract": "0x2CD785Ba87e0841A8458141bc43d23a56a00557f",
      "status": "open",
      "epoch": "5",
      "poolAddress": "0x...",
      "creator": "0x...",
      "createdAt": 1700000000,
      "contractVersion": "v2"
    }
  ],
  "count": 4,
  "updatedAt": "2026-04-14T12:00:00.000Z"
}

Key fields:

• status — "open" (accepting bets), "locked" (waiting for settlement), "settled" (done)
• secondsToLock — seconds until betting closes. null if not open.
• poolUsdc — total USDC in the round pool
• bullPct / bearPct — current odds split
• predictionContract — which contract to call for this token

Strategy Tips

• Check odds before betting. If 90% of the pool is on one side, the other side pays ~10x if it wins.
• Pool size matters. Larger pools = more reliable odds. Small pools can swing wildly with one bet.
• Time your bet. Betting late (< 30s to lock) lets you see the final odds but risks missing the window.
• Minimum bet is $1 USDC. No maximum.
• Check balance first. Make sure you have enough USDC on Base before betting (bankr wallet portfolio).

Examples

User: "What prediction markets can I bet on?"

scripts/agenticbets.py list open

Response format:

Open Markets:
  $AGBETS — Pool: $42.50 | UP: 61% DOWN: 39% | Closes in 83s
  $CLAWD — Pool: $18.00 | UP: 50% DOWN: 50% | Closes in 210s

User: "Bet $10 on AGBETS going up"

scripts/agenticbets.py bet AGBETS up 10

Steps: 1. Fetch market data → get token address + prediction contract 2. Approve USDC via Bankr Submit: ERC20.approve(0x2CD785..., 10000000) 3. Place bet via Bankr Submit: BankrBetsPrediction.bet(0x37d183..., 10000000, 0) 4. Return tx hashes

User: "Do I have any claimable winnings?"

scripts/agenticbets.py claimable AGBETS 5

Calls claimable(token, epoch, walletAddress) — returns true/false.

User: "Claim my AGBETS winnings from epoch 5"

scripts/agenticbets.py claim AGBETS 5

Steps: 1. Call claim(0x37d183..., [5]) via Bankr Submit 2. Return tx hash

References

• [references/agent-usage.md](references/agent-usage.md) — Full agent guide: intent mapping, example conversations, pre-flight checks, error recovery, Markets API schema, and contract reference (calldata encoding, fees, round lifecycle)

Resources

• Website: https://agenticbets.dev
• Telegram Alerts: https://t.me/agenticbets
• GitHub: https://github.com/viraj124/agentic-bets
• MCP Server: npx agenticbets-mcp (for Claude/Cursor users)

Agent Usage Guide

How an AI agent should use the AgenticBets skill — plus the full API and contract reference.

Core Principles

1. Always fetch live market data first — never hardcode token addresses, pool sizes, or odds. 2. Check the user's intent before acting — reads are free, writes cost USDC + gas. 3. Confirm destructive actions — always echo back what you're about to do before bet or claim. 4. Report tx hashes — after any write, surface the Basescan link so the user can verify.

Intent → Command Mapping

Example Conversations

Example 1 — Discovery → Bet

User: "What prediction markets should I look at?"

Agent: 1. Run scripts/agenticbets.py list open 2. Parse output, identify markets with poolUsdc >= 5 and imbalanced odds (e.g., one side > 70%) 3. Respond with ranked options:

"Here are the open markets:

- $AGBETS — Pool: $42.50, UP: 61% / DOWN: 39%, closes in 83s

- $CLAWD — Pool: $18.00, 50/50 split, closes in 210s

>

$AGBETS has the biggest pool and leans bullish. If you think the price will drop, DOWN pays ~2.5x. Want me to place a bet?"

Example 2 — Explicit Bet

User: "Bet $5 UP on AGBETS"

Agent: 1. Run scripts/agenticbets.py odds AGBETS to confirm market is open 2. Confirm with user: "Placing $5 UP on $AGBETS at current 61/39 odds. Proceed?" 3. On approval, run scripts/agenticbets.py bet AGBETS up 5 4. Report both tx hashes (approve + bet) with Basescan links

Example 3 — Claim Flow

User: "Did I win on AGBETS epoch 5?"

Agent: 1. Run scripts/agenticbets.py claimable AGBETS 5 2. If claimable, ask: "You have winnings on epoch 5. Claim now?" 3. On approval, run scripts/agenticbets.py claim AGBETS 5

Example 4 — Strategy Question

User: "Is it a good idea to bet on 90/10 splits?"

Agent: (no script call needed — this is general strategy)

"When odds are 90/10, the 10% side pays roughly 9x if it wins — but those odds usually reflect real signal. Good reasons to bet the underdog:

- The pool is small (one big bet can swing it back)

- You have specific info contradicting the consensus

- You're near lock time and can see final odds

>

Against the underdog:

- Winners side's whales usually have better info

- Fees eat into small pools

>

Rule of thumb: only bet the underdog if pool < $20 OR you have an informational edge."

Pre-flight Checks Before Writes

Before placing a bet, an agent should:

1. Verify Bankr config exists:

   test -f ~/.bankr/config.json && echo "OK" || echo "Run: bankr login email <email>"

2. Verify write access — the script will return 403 if key is read-only. On 403, instruct user to regenerate key with --read-write or toggle off "Read-only" at bankr.bot/api.

3. Verify ETH balance for gas — /wallet/submit broadcasts raw txs, so the Bankr wallet needs native ETH on Base. If the tx fails with "insufficient funds for gas," surface this clearly.

4. Verify USDC balance — bankr wallet portfolio shows Base USDC. Compare to bet amount + existing approvals.

Error Recovery

What NOT to Do

• Don't loop bets automatically without user approval each time
• Don't claim on every settled epoch without checking claimable first — wasted gas if nothing to claim
• Don't hardcode AGBETS → V2 routing in new code — read predictionContract from the Markets API so future V3/V4 work without changes
• Don't retry failed txs more than once — if the second attempt fails with the same error, stop and ask the user
• Don't bet within 10 seconds of lock unless the user explicitly asks — high risk the tx misses the window

---

Markets API Reference

Read-only API for fetching current prediction market state. No auth required.

GET /api/bankr/markets

Base URL: https://agenticbets.dev

Returns all prediction markets with live odds, pool sizes, timing, and contract info.

Request

curl https://agenticbets.dev/api/bankr/markets

No parameters. No headers required (JSON is returned by default).

Response

{
  "markets": [
    {
      "token": "0x37d183FCf1DA460a64D21E754b3E6144C4e11BA3",
      "symbol": "AGBETS",
      "marketUrl": "https://agenticbets.dev/market#AGBETS",
      "poolUsdc": 42.50,
      "bullPct": 61.0,
      "bearPct": 39.0,
      "lockTimestamp": 1713100000,
      "secondsToLock": 83,
      "predictionContract": "0x2CD785Ba87e0841A8458141bc43d23a56a00557f",
      "status": "open",
      "epoch": "5",
      "poolAddress": "0x...",
      "creator": "0x...",
      "createdAt": 1700000000,
      "contractVersion": "v2"
    }
  ],
  "count": 4,
  "updatedAt": "2026-04-14T12:00:00.000Z"
}

Fields

Status Values

Notes

• Data is cached for ~10 seconds server-side. Don't poll faster than that.
• bullPct + bearPct always sums to 100.0.
• Token addresses are canonical — never hardcode; always fetch from this API.

---

Contract Reference

Binary prediction market contracts on Base. Users bet UP or DOWN on token prices using USDC.

Deployed Contracts

Pick the right contract: use predictionContract field from the Markets API, or route AGBETS→V2 and everything else→V1.

Write Functions

bet(address _token, uint256 _amount, uint8 _position)

Place a bet on a token's price direction. Requires prior USDC approval.

Selector: 0x37a02e62

Parameters:

• _token — ERC20 token to bet on (e.g., AGBETS address)
• _amount — USDC amount in raw units (multiply by 1e6). Minimum: 1_000_000 (1 USDC)
• _position — 0 = Bull (UP), 1 = Bear (DOWN)

Behavior:

• Transfers _amount USDC from caller to contract via safeTransferFrom
• Starts a new round if current round is settled/cancelled
• Reverts if token is not active, amount below minimum, round is locked, or pool cap exceeded

Calldata encoding:

0x37a02e62
+ padLeft32(token)      // 32 bytes
+ padLeft32(amount)     // 32 bytes
+ padLeft32(position)   // 32 bytes

claim(address _token, uint256[] _epochs)

Claim winnings for one or more settled epochs.

Selector: 0x45718278

Parameters:

• _token — token the bet was placed on
• _epochs — array of epoch numbers to claim

Behavior:

• Iterates epochs, transfers USDC winnings to caller
• Skips already-claimed epochs
• Reverts if any epoch is not claimable

Calldata encoding (dynamic array):

0x45718278
+ padLeft32(token)                        // 32 bytes
+ padLeft32(0x40)                         // offset to array (64)
+ padLeft32(epochs.length)                // array length
+ padLeft32(epoch[0])                     // first element
+ ...

Read Functions

claimable(address _token, uint256 _epoch, address _user) → bool

Returns true if _user has unclaimed winnings for _token at _epoch.

Selector: 0xd3c035fc

USDC Approval

Before bet(), approve the prediction contract to spend USDC:

ERC20.approve(predictionContract, amount)

Selector: 0x095ea7b3

Calldata:

0x095ea7b3
+ padLeft32(predictionContract)   // spender
+ padLeft32(amount)                // uint256 amount in raw units

Fees

Total fee: 2.1% of losers' pool, split:

• 1.5% → treasury
• 0.5% → market creator
• 0.1% → settler (whoever calls closeRound())

Winners split the remaining 97.9% pro-rata based on their bet size vs. winning-side total.

Round Lifecycle

Open → Locked → Settled
         ↑         ↓
  (betWindow)   (next bet starts new round)

1. Open — startTimestamp to lockTimestamp - 60s. Bets accepted. 2. Locked — lockRound() called → lockPrice recorded 3. Settled — closeRound() called at closeTimestamp → winner determined 4. Next bet() call on this token starts a new round

Constraints

• Minimum bet: 1_000_000 raw units = 1 USDC. Below this reverts with BelowMinBet().
• Max round pool (V2 only): 10,000 USDC per round. Exceeding reverts with ExceedsMaxRoundPool().