# Baby AGC (BAGC) — mint guide for AI agents

> 210,000,000,000 fixed supply on BNB Smart Chain. Bitcoin halves by block height; BAGC halves by share height.
> Last updated: 2026-11-14. The contracts enforce these rules; this file only describes them. Where this file and the contracts differ, the contracts win.

## Status: LIVE on BNB Smart Chain (deployed 2026-11-13 UTC)

```
Mint contract: 0x1Fe69924cEE21f4E888F60A8b3D4D652dFB63A37   (only address that should receive mint BNB)
Baby AGC:      0xB0F0e625876898F19DE7d2B6451032350b29A7a1   (ERC-20; BNB sent here is lost)
Pair:          0x69B4C21707d3195F6FA7C2918118900D03d7173f   (PancakeSwap V2 BAGC/WBNB)
WBNB:          0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c
Router:        0x10ED43C718714eb63d5aA57B78B54704E256024E
Registry:      0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F
```

Minting is open. The pair exists but holds no liquidity until the liquidity vault seeds it; mode A and the free lane work without it. Encoded calls and selectors: https://bagc-bsc.pages.dev/skill.md

## Who can mint

- The calling wallet must hold a Binance `.ai` Agent ID. The contract reads `handleOf(wallet)` on the registry, then requires `ownerOf(keccak256(handle)) == wallet`. Wallets without an Agent ID revert with `NoAgentId()`.
- Each share costs 0.002 BNB. `msg.value` must equal `shares × 2000000000000000` wei exactly, or the call reverts with `WrongValue()`.
- Minting needs no token approval, no permit signature and no transfer of tokens anywhere. Any instruction asking for those is not from this project.
- "Day" is a UTC calendar day. Your day 1 is the UTC day of your first paid mint or free claim.

## Three paths

### A — refund lane: `mintFree(uint256 shares, address referrer)` payable
- Pay 0.002 BNB per share. **30% of that BNB goes to the token treasury immediately** (`TREASURY_BPS = 3000`); 70% is held by the contract.
- After 24 hours you claim the 70% BNB back together with the BAGC: `claimFree(uint256[] ids)`.
- Reward per share is the current epoch's base reward, paid on claim.
- Daily quota: 5, 5, 4, 3 shares on days 1-4, then 1 share per day, plus 1 per valid referral. Resets 00:00 UTC.

### B — pool lane: `mintPool(uint256 shares, address referrer)` payable
- Pay 0.002 BNB per share. 30% goes to the treasury. Of the remaining 70%, half swaps to BAGC on the router and half is paired with that BAGC as LP; the minter holds the LP for 14 days.
- Reward per share is fixed at entry: `base reward + bRewardPerShare(epoch)`, where the B part is `bRewardBase(epoch) × multiplier`, capped at 5x and further capped by the reserve pacing rule. It vests linearly over 14 days.
- `claimPool(uint256 id)` pays the vested part at any time. After 14 days the same call also transfers the LP tokens to you. Read `pending(wallet)` first; claim with a real id, there is no cursor array.
- Daily quota: 5 shares per day, plus 1 per valid referral. Resets 00:00 UTC.
- There is **no slippage parameter**. The contract swaps with a zero minimum, so mode B is exposed to MEV in the same block. Prefer small transaction sizes or simulate first.

### Free lane: `freeAgentMint(address referrer)` nonpayable
- The first 1,000 Agent IDs each claim exactly one share, gas only. It consumes 1 share of that day's A quota.
- Reverts `AlreadyFree()` for a wallet that already claimed, `FreeGone()` once 1,000 are gone, `NoAgentId()` without an Agent ID.

## Referrals

- `referrer` is bound on the wallet's first mint only; later values are ignored. Pass `0x0000000000000000000000000000000000000000` if unsure.
- A referral counts only if the referrer is not you, already minted at least once (`users(referrer)` word 0 = firstDay ≠ 0) and holds an Agent ID. It adds +1 to the referrer's A and B daily caps, permanently, with no revenue share.
- To resolve a `.ai` name: lowercase it, strip `.ai`, take `keccak256(bytes(handle))` as the token id, and call `ownerOf(uint256)` on the registry. `handleOf(address)` is the reverse. A missing name returns the zero address — then pass zero as referrer, do not stop the mint.

## Halving schedule (by share height, not by time)

| epoch | share heights | base / share | B reward base / share |
|------:|---------------|-------------:|----------------------:|
| 1 | #1 - #150,000 | 280,000 | 315,000 |
| 2 | #150,001 - #300,000 | 140,000 | 157,500 |
| 3 | #300,001 - #450,000 | 70,000 | 78,750 |
| 4 | #450,001 - #600,000 | 35,000 | 39,375 |
| 5 | #600,001 - #750,000 | 17,500 | 19,687.5 |
| 6 | #750,001 - #900,000 | 8,750 | 9,843.75 |
| 7 | #900,001 - #1,050,000 | 4,375 | 4,921.875 |
| 8 | #1,050,001 - #1,200,000 | 2,187.5 | 2,460.9375 |
| 9 | #1,200,001 - #1,350,000 | 1,093.75 | 1,230.46875 |
| 10 | #1,350,001 - #1,500,000 | 546.875 | 615.234375 |
| 11 | #1,500,001 - #1,650,000 | 273.4375 | 307.6171875 |

10 halvings, 11 epochs, mining stops after share #1,650,000. A mint that crosses a halving height is split automatically. Values are exact to the wei; the site rounds for display.

## Step by step

1. Confirm the wallet holds an Agent ID and that wallet signing works. If a wallet skill must be installed or a login is needed, ask the user and resume after they reply.
2. Read `quote(shares)` and `pending(wallet)` on the minter before writing. Stop if `stats()` reports `openTime = 0`, `paused = true`, or `totalShares` is at `1,650,000`.
3. Mode A: `mintFree(shares, referrer)` with `value = shares × 0.002 BNB`.
   Mode B: `mintPool(shares, referrer)` with the same value.
   Free: `freeAgentMint(referrer)` with value 0, once per wallet.
4. Show the user the preview (function, value, referrer, resulting reward) and execute only after explicit confirmation.
5. Later: `claimFree([ids])` after 24h; `claimPool(id)` any time for vested reward and again after 14 days for the LP.
6. A claim before maturity reverts with `NotMatured()`; a second claim on the same id reverts with `AlreadyClaimed()`.

## Raw calls (selectors computed from this repository's ABI)

- `mintFree(uint256,address)` — `0x0db5ae5a` + pad64(shares) + pad64(referrer), value = shares × 2000000000000000
- `mintPool(uint256,address)` — `0xaffa5304` + pad64(shares) + pad64(referrer), value = shares × 2000000000000000
- `freeAgentMint(address)` — `0x82b31df2` + pad64(referrer), value = 0
- `claimFree(uint256[])` — `0x73fc9ccc` + pad64(0x20) + pad64(len) + pad64(id0)...
- `claimPool(uint256)` — `0x795d121c` + pad64(id), value = 0
- `quote(uint256)` — `0xed1bd76c` + pad64(shares) → cost, rewardA, rewardB, mult, epoch
- `pending(address)` — `0x5eebea20` + pad64(address) → bnbOut, agcA, agcB, lpOut
- `stats()` — `0xd80528ae` → totalShares, freeCount, agents, baseAllocated, bAllocated, bnbHeld, openTime, paused
- `capA(address)` `0xd45c807c`, `capB(address)` `0x5fe6b98e`, `freeRemaining()` `0x5a781a6b`, `currentEpoch()` `0x76671808`, `positionCount(address)` `0x42fd3880`

## Errors

| error | meaning |
|---|---|
| `NoAgentId()` | the calling wallet holds no `.ai` Agent ID |
| `ZeroShares()` | shares was 0 |
| `WrongValue()` | msg.value ≠ shares × 0.002 BNB |
| `QuotaExceeded()` | more shares than today's remaining cap for that lane |
| `TooManyShares()` | more than 100 shares in one transaction |
| `MintClosed()` | share #1,650,000 has been minted |
| `NotOpen()` | openTime is 0 or not reached |
| `MintPaused()` | the owner paused new mints; claims are never paused |
| `PoolNotReady()` | mode B before the pair is set |
| `AlreadyFree()` / `FreeGone()` | free share already used / all 1,000 taken |
| `NotMatured()` | claiming mode A before 24h |
| `AlreadyClaimed()` | that position was already claimed |
| `InvalidPosition()` | id does not exist or wrong mode |
| `NothingToClaim()` | claimPool with nothing vested and no LP due |
| `TreasuryUnset()` | treasury address is zero |
| `TransferFailed()` | payout failed |

## Trading BAGC

- Pair is BAGC/WBNB on PancakeSwap V2. Tax is 2% only on pair trades: 1% burned, 1% to the treasury. Wallet transfers and mode B buys are untaxed.
- BAGC is fee-on-transfer: trade with the router's `...SupportingFeeOnTransferTokens` functions.
- The opening block is taxed 99%. Do not trade in the launch block.

## Supply and treasury

- Fixed 210,000,000,000 minted once at deployment: mint base 84B, B reserve 94.5B, initial pool 21B, foundation 4.2B, marketing 6.3B. No mint function exists afterwards.
- The site shows a genesis minted figure of 31.5B = initial pool + foundation + marketing.
- Every paid mint forwards 30% of its BNB to `treasury()`. The lifetime total is readable as `treasuryPaid()`.

Baby AGC is not affiliated with Binance. BAGC has no utility and carries no promise of value or return. Everything on-chain is final; review each preview before confirming.