# BUILD · Fair mint & floor vault — Agent skill

> For agents acting from their own BNB Chain wallet. Anyone can mint (normal wallets and agents alike); this file is the agent path.
> Site: https://buildonbnb.xyz · Chain: BNB Smart Chain (chainId 56)

## 0. Contract addresses

BuildMint is live on BNB Smart Chain (chainId 56). The mint opened 2026-11-18 21:12 Beijing time and runs 24 hours.

| Contract | Address |
|---|---|
| BuildMint | `0x4f8F0dcE270da2CB3678B6197d981d6A66F91b73` |
| BUILD token | read `token()` on BuildMint after launch |
| BuildVault (floor vault) | read `vault()` on BuildMint after launch |

Never use an address from anywhere else (DMs, posts, other sites). This is the only BuildMint address.

## 1. Rules you must respect

- 500 shares in total (50 BNB), **0.1 BNB per share, exact amount**, **1 share (0.1 BNB) per wallet** (enforced on-chain; read the live cap from `info().walletCap`).
- After it sells out, anyone can call `launch(salt)`; BUILD launches on Flap, the 800,000,000 BUILD bought on the curve are split over 500 shares: **1,600,000 BUILD per share**, pushed to every minting wallet automatically in the launch transaction — there is no claim.
- Mint window: exactly **24 hours** from `start` (`end = start + 24h`). If 500 shares aren't sold by `end`, the launch can never happen and every minter pulls a full refund with `refund()` (0.1 BNB per share). If it sells out but isn't launched by `start + 48h`, refunds open too.
- The mint contract has no owner or admin and no admin functions; every parameter is fixed at deploy.
- Tax: 2% on buys and 2% on sells. Flap keeps 0.2 percentage points as its protocol fee (1/10 of the tax); the other 1.8% reaches the floor vault as BNB (mainnet-fork measured).
- Floor vault — tranches of **100,000,000 BUILD**, no time limit; the next tranche opens only after the current one is fully redeemed. Public redemption opens **3 hours after launch**.
  - **Tranche 1**: funded by the launch leftover (≈ 33.5 BNB). Fixed floor **0.000189 USDT per BUILD**, paid in BNB at the Chainlink BNB/USD rate (`0x0567F2323251f0Aab15c8dFb1967E4e8A7D42aeE`); if the feed is more than 1 hour old or outside 50–10,000 USD, tranche 1 pauses (code 7). Tax during tranche 1 does **not** go into it; it builds the next-tranche fund. BNB left in tranche 1 when it ends rolls into that fund. Tranche 1 also ends if its fund can't pay one more BUILD.
  - **Tranche n ≥ 2**: floor = fund left ÷ tokens left (BNB). Tax during the tranche goes into its fund, so the floor rises live. Payouts are pro-rata; the last token takes the remaining fund.
  - **Opening rule (only up)**: the next tranche opens only when next fund ÷ 100M ≥ the previous tranche's closing price; until then redemption returns code 4 and tax keeps accumulating.
  - Public-redemption limits: at most **500,000 BUILD per transaction and per address per tranche** (`quotaOf(you)`). Every BUILD sold to the vault is burned.
- Spend only what your user approved. Report every transaction hash.

## 2. Read state

BuildMint `info()` — selector `0x370158ea`

```
returns (uint256 sold, uint256 total, uint256 price, uint256 raised, uint16 walletCap, uint64 start, uint64 end, bool launched, bool refundOpen)
```

- Mint is open when `start <= now <= end`, `sold < total`, `launched == false`, `refundOpen == false`.
- Your shares: `sharesOf(address)` — `0xf5eb42dc`. Received your BUILD: `claimed(address)` — `0xc884ef83` (true once the launch push reached you).

## 3. Mint

`mint(uint256 shares)` — selector `0xa0712d68`, payable.

- `shares` must be **1**. `value` (msg.value) must be **exactly 0.1 BNB** (`100000000000000000` wei); any other amount reverts with "Wrong BNB amount".
- If `sharesOf(you) >= 1` the wallet already has its share — stop. If `sold >= 500` it's sold out — stop.

The only valid call: `to = BuildMint`, `value = 100000000000000000` (0.1 BNB), `data = 0xa0712d68` + `uint256(1)`:

```
0xa0712d680000000000000000000000000000000000000000000000000000000000000001
```

## 4. After launch: BUILD arrives automatically

Nothing to call. `launch(salt)` pushes 1,600,000 BUILD (18 decimals) per share to every minter in the same transaction, tax-free. Check `claimed(address)` — `0xc884ef83` (true = received) or your BUILD balance.
If the launch transaction ran out of gas before reaching everyone, anyone can finish the push with `distribute(uint256 maxCount)` — selector `0x91c05b0b`, no value (e.g. `maxCount = 500`). `allDistributed()` — `0xbbc40d5a` returns true when all minters have received.

## 5. Refund (only if `refundOpen == true`)

`refund()` — selector `0x590e1ae3`, no value. Returns your 0.1 BNB.

## 6. Sell to the floor vault (optional; public redemption opens at launch + 3h)

1. Read `vault = BuildMint.vault()` (`0xfbfa77cf`) and `token = BuildMint.token()` (`0xfc0c546a`).
2. Check your allowance: `quotaOf(address)` on the vault — `0xef23b3a3` → `(used, addrRemaining, periodRemaining)`.
3. Preview: `previewRedeem(address user, uint256 amount)` — `0xcbe52ae3` → `(tokens, bnbOut, price, code)`. `code == 0` means it can fill now. Codes: 1 not launched · 2 public redemption not open yet · 3 paused · 4 next tranche not open yet (fund below previous close) · 5 address cap reached this tranche · 6 no BNB left in this tranche · 7 BNB/USD feed stale or out of bounds (tranche 1 only). `price` is BNB (wei) per 1e18 BUILD.
4. `approve(vault, amount)` on the BUILD token — `0x095ea7b3`.
5. `redeem(uint256 amount, uint256 minBnbOut)` — selector `0x7cbc2373`. Use `minBnbOut = bnbOut × 99.5%` from the preview. Only the part within your remaining caps fills; the rest stays in your wallet.

Quick reads on the vault: `currentTranche()` — `0xc404b3f6`, `currentPrice()` — `0x9d1b464a` (BNB wei per BUILD), `nextFund()` — `0x9d88911d`, `lastPrice()` — `0x053f14da`, `quotaOf(address)` — `0xef23b3a3` → `(used, addrRemaining, trancheRemaining)`. `poke()` — `0x18178358` opens a funded tranche (anyone; redeem also does it).
Full state in one call: `dashboard()` — `0xa2c94099` (balance, principal, totalTax, totalPaid, totalBurned, launchedAt, openAt, paused, tranche, trancheOpen, trancheTokens, trancheLeft, trancheFund, floor, floorUsd, bnbUsd, oracleUpdatedAt, oracleOk, nextFund, nextPrice, lastPrice, maxPerTx, maxPerAddr, spot, poolBNB, poolTokens). Feed only: `bnbUsd()` — `0x58614dbf` → `(price 1e18, updatedAt, ok)`.

## 7. Prices — report them in USDT, like the chart

- `floorUsd` = this tranche's floor in USDT (18 decimals): tranche 1 = `189000000000000` (0.000189); later tranches = `floor × bnbUsd` (0 if the feed is unusable).
- `floor` = this tranche's floor in BNB (wei per 1e18 BUILD); 0 while the next tranche is still funding.
- `nextPrice` = next fund ÷ 100M — the projected opening floor (tranche 1's leftover is added when it ends); it must reach `lastPrice` to open.
- `spot` = PancakeSwap pool price in BNB per BUILD. **USDT price = spot × bnbUsd**. Market cap = USDT price × (1,000,000,000 − BUILD held by `0x…dEaD`).
- Mainnet-fork tests: the Flap migration pool is 200M BUILD + 15.998 BNB, so the open is ≈ 0.00000008 BNB ≈ 0.000047 USDT at BNB 590 — tranche 1's floor is about 4× the open. Tranche 1's 100M costs ≈ 32 BNB at BNB 590. The chain decides the real values.

## 8. How the vault behaves

- While tranche 1's floor is above the chart price, bots buy from the pool and sell to the vault; tranche 1 is likely gone soon after public redemption opens. Per-address caps don't stop many-address bots.
- After tranche 1, tranche 2 opens only when tax has built a fund ≥ tranche 1's closing price × 100M (≈ 32 BNB, roughly 1,100 BNB of buy+sell volume in a mainnet-fork test). Until then there is no floor to sell to.
- If the BNB/USD feed goes stale (>1h), tranche 1 pauses until a fresh round arrives.
- The floor is not a price guarantee. A used-up or still-funding tranche, or a pause, means no sale at the floor.
- The vault code is upgradeable (to fix bugs) by the project admin wallet; Flap's security role (Guardian) can also pause and upgrade (Flap standard). The admin wallet can pause and cannot move funds.
