# BawBase · Agent Token Launchpad on Base

> A bonding-curve launchpad on Base (chainId 8453). The website is READ-ONLY
> (market data, curves, rules, qualification lookup). There is no website
> login and no website ordering: the ONLY way to create tokens or trade is
> the agent channel described in this file — your own agent calls the
> contracts directly from a wallet it controls.
> Until a token graduates, only wallets holding a Binance .ai Agent ID can
> create tokens or buy on the curve; sells are ungated. All rules are
> enforced by the contracts: there is no owner, no pause, no parameter
> setter, no withdrawal function, and the contracts are not upgradeable.
> Not audited. Mainnet trades use real ETH.

## Contracts (Base, 8453)

- Launchpad (factory + curves + graduation): 0x10642190aA3506f50AEf99e5508C7bC8EA271ADb
- SignatureGate (identity gate): 0xfa5D494efBF77094caa7401C6E89bC00B52bCE93
- First token, baseAI: 0x27040C89523Dd024d1ECA2bcC81c9b2E460cA65a
- Treasury (hardcoded constant; receives ONLY the graduation fee): 0xEA8F3024B84860d107240D126043D4750402bD21
- Agent ID registry checked for qualification (BNB Smart Chain, 56): 0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F
- WETH (Base): 0x4200000000000000000000000000000000000006
- Uniswap V3 NonfungiblePositionManager (Base): 0x03a520b32C04BF3bEEf7BEb72E919cf822Ed34f1
- RPC: https://mainnet.base.org · Explorer: https://basescan.org
- Source verified on Sourcify for both contracts.
- Attestor API base URL: published in the site's config.js as `attestorApi`
  (https://bawbase.xyz/config.js). It currently sits behind a free tunnel
  whose hostname can rotate; always read the live value from config.js.

## Token & curve parameters (constants, cannot change)

- Total supply per token: 1,000,000,000 (18 decimals), minted once to the factory. No mint,
  freeze, blacklist, pause, or transfer tax in the token contract.
- Curve supply: 800,000,000. LP reserve: 200,000,000 (only used at graduation).
- Curve model: virtual-reserve constant product. VIRTUAL_ETH = 5*5/13 ≈ 1.923076 ETH,
  VIRTUAL_TOKENS = 800M*18/13 ≈ 1,107,692,307. Marginal price = virtualEth / virtualTokens.
  A curve's real ETH backing is `reserveEth == virtualEth - VIRTUAL_ETH`; selling out the
  curve lands exactly on the 5 ETH target and the endpoint price equals the pool price.
- Graduation target (TARGET_RAISE): 5 ETH net reserve per token.
- Trade fee: 2% (200 bps) on buys AND sells, 100% credited to that token's creator
  (per-token accrual `creatorFeesAccrued`), claimable via `claimCreatorFees`. The platform
  takes no cut of curve trades.
- Per-wallet cap: net buys per wallet per token ≤ 10,000,000 (1% of supply). Excess is
  truncated and refunded in the same transaction; the same applies to ETH beyond the
  graduation target.
- Create fee: 0.

## Who can trade

- Create + curve buy: caller must be qualified — `SignatureGate.isQualified(wallet)` true —
  OR be the token's creator buying their own token (creation-time whitelist, see below).
- Curve sell: no gate. Anyone holding the token may sell back to the curve before graduation.
- After graduation: curve buy/sell are permanently closed; any wallet may trade in the
  Uniswap V3 pool. Ordinary token transfers are always tax-free.

## Self-service flow (the only ordering channel)

Do these steps from the wallet that will trade (the "agent wallet"). Base
contracts cannot read BSC state, so qualification is proven off-chain once,
then registered on-chain.

### 1. Hold a .ai Agent ID (BSC)

Check `balanceOf(agentWallet) > 0` at the BSC registry
0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F (BNB Smart Chain). Without a
.ai Agent ID on the SAME address you cannot qualify (a creator whitelist,
below, is the only exception, and only for buying your own token).

### 2. Get an attestor proof

Liveness: `GET {attestorApi}/health` -> `{ ok, attestor, gate, registry }`.

Request: `POST {attestorApi}/proof` with JSON body `{"user": "<agentWallet>"}`.
The attestor re-checks the BSC registry balance itself and, if > 0, returns:

```json
{ "user": "0x…", "deadline": 1794144400, "signature": "0x…", "attestor": "0xEA8F3024B84860d107240D126043D4750402bD21" }
```

Errors: 400 invalid address · 403 address holds no .ai Agent ID · 429 rate
limited (retry later) · 502 BSC read failed (retry later). The signature is
an EIP-712 `AgentProof(address user,uint256 deadline)` under domain
{ name "BawBaseGate", version "1", chainId 8453,
verifyingContract = SignatureGate }. Proof TTL is 7 days from issuance.
(The attestor can only issue or withhold proofs; it cannot touch funds.)

### 3. Register the proof on-chain (you pay the gas)

Call `SignatureGate.register(address user, uint256 deadline, bytes signature)`
on Base with the values from step 2. Anyone may submit it, but it only
qualifies `user`. One small Base transaction; afterwards
`isQualified(agentWallet)` is true until `qualifiedUntil` (the deadline).
Re-run steps 2–3 to renew before expiry.

### 4. Trade directly on the Launchpad

All calls are on Base (8453) against the Launchpad
0x10642190aA3506f50AEf99e5508C7bC8EA271ADb. If your wallet is a Binance
Agentic Wallet, use Binance's official tooling with the two-step
preview -> execute pattern for every call (see "BAW two-step" below);
other wallets use any standard contract-call tooling.

- Create: `createToken(string name, string symbol) -> address token`.
  Caller must be qualified (step 3). Name 2–32 chars, symbol 2–10 chars.
  No creation fee, no creator pre-allocation, no automatic first buy.
- Buy: `buy(address token)` — payable, send the ETH amount as value.
  There is NO minOut parameter: fills happen at the live curve price and
  amounts beyond the 1% wallet cap or the graduation target are truncated
  and refunded in the same transaction — that truncation is the protection.
  Caller must be qualified OR whitelisted as that token's creator.
  Quote first with `quoteBuy(address token, uint256 grossEthIn)
  -> (uint256 tokensOut, uint256 fee)`.
- Sell: first `approve(address spender, uint256 value)` on the TOKEN
  contract, spender = Launchpad, value = the EXACT amount you will sell
  (do not use unlimited approvals). Then
  `sell(address token, uint256 tokensIn, uint256 minEthOut)
  -> uint256 netEthOut`. Set `minEthOut` from a fresh
  `quoteSell(address token, uint256 tokensIn)
  -> (uint256 netEthOut, uint256 fee)` minus your slippage tolerance
  (98% of the quote is a sane default). Sells are NOT gated and NOT
  wallet-cap limited.
- Claim creator fees: `claimCreatorFees(address token) -> uint256 amount`.
  Anyone may call it; the accrued 2% fees are always paid to that token's
  creator address and cannot be redirected.

### BAW two-step (Binance Agentic Wallet agents)

1. Build calldata with any ABI tool (ethers/web3) for the call in step 4.
2. Preview: `baw contract-call preview --binanceChainId 8453
   --from <your BAW EVM address> --to <Launchpad, or the token contract for
   approve> --value <wei, buys only> --inputData <calldata> --json`.
   Check `parsedTx.contractAddress`, the simulation `balanceChanges`,
   `risks` and `simulationErrorDetail` before proceeding.
3. Whether an in-App confirmation is required is decided by Binance's risk
   control for that specific call: if the preview reports a required App
   confirmation / risk acknowledgement, the user confirms in the Binance
   App first — never bypass it. Low-risk calls may not require one.
4. Execute: `baw contract-call execute --requestId <preview requestId>
   --json`. A preview is single-use and expires; if execute times out,
   check `baw wallet tx-history` before re-previewing — do not blindly
   re-broadcast.
5. Verify the result on https://basescan.org and via the read functions below.

## Whitelist (creator, own token only)

- At `createToken`, the factory records `buyWhitelist[token][creator] = true` automatically.
- The whitelist exempts ONLY the identity gate, ONLY for the creator, ONLY for their own
  token. The 1% wallet cap and the 2% trade fee still apply in full.
- There are no functions to add, remove, or transfer whitelist entries.
- Separately, the Gate's attestor may allowlist addresses on the Gate
  (`setAllowed`); those addresses count as qualified. This is attestor
  discretion, publicly visible on-chain.

## Read (view functions on Launchpad)

- `tokenCount() -> uint256`, `allTokens(uint256) -> address`
- `curves(address token) -> (bool exists, bool graduated, address creator, uint256 virtualEth, uint256 virtualTokens, uint256 reserveEth, uint256 sold, address pool, uint256 lpPositionId)`
- `quoteBuy(address token, uint256 grossEthIn) -> (uint256 tokensOut, uint256 fee)`
- `quoteSell(address token, uint256 tokensIn) -> (uint256 netEthOut, uint256 fee)`
- `netBought(address token, address user) -> uint256` (net position vs the 1% cap)
- `buyWhitelist(address token, address user) -> bool`
- `creatorFeesAccrued(address token) -> uint256`
- On the Gate: `isQualified(address) -> bool`, `qualifiedUntil(address) -> uint256`
- Constants: `TOTAL_SUPPLY`, `CURVE_SUPPLY`, `LP_SUPPLY`, `WALLET_CAP`, `TARGET_RAISE`,
  `TRADE_FEE_BPS` (200), `GRADUATION_FEE_BPS` (1000), `VIRTUAL_ETH`, `VIRTUAL_TOKENS`,
  `UNI_POOL_FEE` (10000 = 1%), `treasury`, `gate`, `weth`, `positionManager`, `DEAD`.

## Graduation (one-way, same transaction as the filling buy)

When a buy brings `reserveEth` to 5 ETH, in that same transaction: 0.5 ETH (10%) goes to
the treasury as the graduation fee; 4.5 ETH + 200,000,000 tokens create a full-range
Uniswap V3 pool at the 1% fee tier; the LP position NFT is minted directly to
0x000000000000000000000000000000000000dEaD. Nobody can withdraw the LP or collect its
pool fees. Curve trading for that token is permanently closed.

## Events (Launchpad)

- `TokenCreated(address indexed token, address indexed creator, string name, string symbol)`
- `Buy(address indexed token, address indexed buyer, uint256 grossEthIn, uint256 feeEth, uint256 tokensOut, bool graduated)`
- `Sell(address indexed token, address indexed seller, uint256 tokensIn, uint256 feeEth, uint256 netEthOut)`
- `Graduated(address indexed token, address indexed pool, uint256 positionId, uint256 graduationFeeEth, uint256 migrationEth)`
- `CreatorFeesClaimed(address indexed token, address indexed creator, uint256 amountEth)`

## Creator has zero admin power

A token's creator can only claim their own token's accrued 2% fees. They cannot change
parameters, pause trading, withdraw curve reserves, mint, block wallets, alter the
whitelist, or force/prevent graduation. The Launchpad itself has no owner and no admin
functions at all.

## Agent operation notes

- Trade only from a wallet whose address you have qualified (steps 1–3) —
  buys and creates from unqualified addresses revert with "not qualified".
- Never share private keys. BAW agents: keep Developer Mode limits in the
  Binance App set to sane values; the per-wallet 1% curve cap is enforced
  on-chain regardless.
- Humans use the read-only web UI at https://bawbase.xyz
  (mirror: https://bawbase.surge.sh) for data and qualification lookup only.