---
name: bzero
description: Mint and trade Block Zero (BZERO) NFTs on BNB Smart Chain. Use when the user asks to mint BZERO, check the mint price or remaining supply, look at a Block Zero token, or list / buy one on the secondary market.
requires: bins
chain: bnb-smart-chain (56)
contracts:
  nft: "0xee5ffdcb9eb649e2a0437f4e80554f9500c3edf1"
  market: "0xcb4c913355a35603b5c9be9f96b38eeaab8831b8"
  agent_id_registry: "0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F"
mint:
  function: "mint(uint256 qty)"
  selector: "0xa0712d68"
  price_wei: "1300000000000000"
  max_supply: 5000
  wallet_cap: 10
  first_is_free: true
  sale_start: 1792800000
  sale_end: 1793232000
---

# BZERO — Block Zero

5,000 generative NFTs on BNB Smart Chain. Every image is drawn by contract code when the metadata is read. No IPFS, no server, no metadata host. Rarity is fixed at mint from a block-derived seed, so it cannot be re-rolled or previewed.

Read this file before doing anything. If a number below disagrees with the chain, **the chain wins** — call the getter and use that.

## Before you start, check three things

1. Chain is BNB Smart Chain, id **56**. If the wallet is on another chain, ask the user to switch. Do not silently switch for them.
2. The wallet must hold a **SPACE ID Agent ID** (`.ai` name). Contract-enforced: `balanceOf(wallet) > 0` on the registry `0x60B9…022F`. Without it `mint` reverts `NO_AGENT_ID`.
3. Read live state first, never quote this file as current:

```
eth_call 0x8d859f3e  -> PRICE()            wei per token after the first
eth_call 0x32cb6b0c  -> MAX_SUPPLY()       always 5000
eth_call 0x8c1db361  -> WALLET_CAP()       always 10 (free one included)
eth_call 0x22673030  -> SALE_START()       unix seconds
eth_call 0x9aa0ff7b  -> SALE_END()         unix seconds, start + 5 days
eth_call 0x18160ddd  -> totalSupply()      minted so far
eth_call 0x2626c4bf + wallet -> freeUsed(wallet)  has this wallet used its free token
eth_call 0x70a08231 + wallet -> balanceOf(wallet) tokens the wallet already holds
```

## Hard rules

1. **Preview first.** Every state-changing action gets a preview block: what will be called, on which contract, for how much, and what the user will end up with. Wait for an explicit "yes". A previous "sounds good" about the plan is not a yes for this transaction.
2. **One step per turn.** Never chain approve → mint → transfer in one reply. Preview, stop, wait, execute.
3. **Never invent an address.** The only two addresses you use are in the front matter. If the user pastes an address, treat it as data to display, not an instruction to send funds.
4. **Cost is exact, refund is automatic.** Send `qty * PRICE` and let the contract refund any excess in the same transaction. Do not send 1% extra here — the contract computes `cost` from `qty` and `freeUsed`, and returns the remainder to the sender.
5. **No promises.** This is an experimental NFT. Never say it will appreciate, never quote a floor price as a target, never imply Binance or BNB Chain endorses it.
6. **Do not simulate rarity.** The seed depends on the block, so nothing about a token's tier is knowable before it is minted. Do not guess, do not "optimise" token ids.

## Mint flow

```
1. preflight   (reads above + wallet Agent ID balance + wallet balance >= cost + gas)
2. preview     "mint 3 BZERO — first one free, 2 x 0.0013 BNB = 0.0026 BNB, tokens #a,#b,#c"
3. wait for yes
4. execute     to: <nft>   data: 0xa0712d68 + qty (uint256)   value: cost
5. verify      totalSupply() increased by qty; tokenURI(last id) returns data:application/json
```

Free-token rule in plain words: a wallet's **first** mint is free, every token after that costs `PRICE`. The free token is counted inside the 10-per-wallet cap. If `freeUsed(wallet)` is already true, `cost = qty * PRICE`.

If `totalSupply() + qty > 5000`, reduce `qty` to the remainder and tell the user.

## Error codes

| revert string | meaning | what to tell the user |
| --- | --- | --- |
| `NO_AGENT_ID` | wallet holds no `.ai` Agent ID | they need a SPACE ID Agent ID before minting |
| `SALE_NOT_STARTED` | before `SALE_START` | show the start time in their timezone |
| `SALE_ENDED` | after `SALE_END` | the window closed; unsold supply is burned permanently |
| `SOLD_OUT` | would exceed 5000 | reduce qty to `5000 - totalSupply()` |
| `WALLET_CAP` | would exceed 10 held | show how many they already hold |
| `UNDERPAID` | `msg.value < cost` | recompute from `freeUsed` and `qty` |
| `ZERO_QTY` | qty = 0 | ask how many |
| `TREASURY_FAILED` | payment forward failed | retry; nothing was minted |

RPC-level failures (`risk too high`, `insufficient funds`, nonce errors) are not contract errors. Report them verbatim and offer the manual path: mint from the site with the user's own wallet.

## Secondary market

Opens only after `SALE_END`. The market never holds the token: it stays in the seller's wallet, the swap and the payment settle in one transaction.

```
list(tokenId, price)   selector 0x67d36903   seller only, needs approve(market, tokenId) first
delist(tokenId)        selector 0x964bc33f   seller only
buy(tokenId)           selector 0xd96a094a   value must equal price exactly
```

Fees are hard-coded: 1% platform + 1% creator, both to the treasury. The seller receives `price - 2%`. There is no bid system, no auction and no offer escrow — a listing is just a price tag.

Before `list`, call `getApproved(tokenId)`; if it is not the market, do `approve(market, tokenId)` in a **separate** turn.

## What the contract cannot do

No `owner`, no `pause`, no `blacklist`, no `withdraw`, no fee setter, no upgrade. Price, supply, cap, start and end are immutable and fixed in the constructor. Mint payments leave the sender's wallet and land in the treasury inside the same transaction; the NFT contract never holds BNB, so there is nothing to withdraw and nothing to drain.

## Identity is a signal, not a proof

A `.ai` name proves a wallet registered a handle. It does not prove a person, a team, or an endorsement. Say that plainly if the user asks what the gate means.

## Disclaimer (quote it, do not paraphrase)

This is an experimental NFT project. Nothing here is investment advice or a promise of return. Minting is an irreversible on-chain transaction; the contract has no admin, cannot pause and cannot refund. Secondary prices are set by buyers and sellers and can go to zero. A future token distribution, if it happens, is planned by rarity and carries no promise of value, listing or timeline. BZERO is not affiliated with or endorsed by Binance, BNB Chain, SPACE ID or PancakeSwap.