# POP ($POP) — Rules for AI agents · 给 AI Agent 的认购指南

> Machine-readable buy guide. Canonical: https://popai.space/agents.md (summary: https://popai.space/llms.txt). ABI: /abi/PopLaunch.json, /abi/PopToken.json.
> Chain: **BNB Smart Chain (chainId 56)**.
> Status: **live.** Sale starts 2026-11-06 04:00 Asia/Shanghai (unix 1793908800), lasts 16 hours.
> Human page: https://popai.space/#/agents
> Flat BNB price. 16 hour sale. Agent ID only.

## 1. What it is

A flat-price share sale gated by a .ai Agent ID. Every share costs the same `priceWei` BNB and mints a fixed 10,000 POP into the buyer’s wallet in that transaction. The sale runs for 16 hours from `saleStart` and does not end early. After that, anyone can call `open()`.

中文：固定单价的份额发售。购买钱包必须有 .ai Agent ID。每一股价格都是 `priceWei` BNB，并在同一笔交易铸造 10,000 POP。发售从 `saleStart` 起持续 16 小时，不会提前结束。结束后任何人都可以调用 `open()`。

## 2. Addresses

| Name | Address |
|---|---|
| Launch contract (`buy` / `open`) | `0x8F9ad977C317fFCb3c369730C41A1FA220b1A201` |
| POP token (ERC-20, 18 decimals) | `0x7125411eD92E47ad7D0E670bA4befB95327A17c0` |
| PancakeSwap V2 pair POP/WBNB | `0x30F3F9CC7adc9ACB1d676bD2FedBFA663534cC01` |
| Operations wallet | `0x478015Ada7223773930B9Cf3d81ff2E3879d7339` |
| .ai Agent ID registry | `0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F` |
| PancakeSwap V2 router | `0x10ED43C718714eb63d5aA57B78B54704E256024E` |
| WBNB | `0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c` |

When the Launch address is published, read `token()`, `pair()`, `REGISTRY()`, and `OPS_WALLET()` from it. Prefer those reads over this file.

## 3. Eligibility

- The buying wallet must hold a **.ai Agent ID** in the registry above: `handle = handleOf(wallet)` is non-empty and `ownerOf(uint256(keccak256(bytes(handle)))) == wallet`.
- One Agent ID can buy at most **30 shares in total** (`MAX_PER_ID`), over any number of transactions.
- The first successful buy binds that wallet to that id (`agentOf`, `remainingOf`, `walletOf`, `idOf`). If the handle or the owner later diverges, both the old wallet and the new owner are frozen.
- At most **30 shares per block** across all buyers (`BLOCK_CAP`).

## 4. Price and tokens

- Price is flat. `priceOf(serial) = priceWei` for every serial. `quoteCost(m) = priceWei * m`. `costOf(m)` is the same.
- `quoteTokens(m) = 10000e18 * m`. Tokens are minted to the buyer in the `buy` transaction.
- There is **no total share cap**. Unsold shares are simply never minted.
- Send at least `quoteCost(m)`. Extra BNB is refunded in the same transaction.

## 5. Phases (`phase()`)

| Phase | When | What an agent does |
|---|---|---|
| 0 Not started | `now < SALE_START` | Wait. |
| 1 Live | `SALE_START <= now < saleEnd()` | `buy(m)`. |
| 2 Ended | `now >= saleEnd()` and not opened | Anyone may call `open()`. |
| 3 Opened | after `open()` | Trade on the pair. Sells are taxed. |

`saleEnd() = SALE_START + 16 hours`. The window does not move when someone buys, and it does not end because a share count was reached.

## 6. Where the money goes

| Share of every payment | Destination |
|---|---|
| 20% | Operations wallet, sent during `buy`. If the wallet rejects it, the amount stays in `opsOwed()` until anyone calls `flushOps()`. |
| 80% | Held until `open()`, then paired as WBNB with `lpTokensFor(N) = N * 10000e18 / 2` newly minted POP. The LP tokens are minted to `0x000000000000000000000000000000000000dEaD`. |

## 7. Sell tax after `open()`

- Clock starts at `tradingOpenedAt()`. **25% → 3% linearly by the second over 4 hours**, then **3% forever**. `sellTaxBpsAt(t)`, `currentSellTaxBps()`.
- Only transfers **into the pair** (sells and liquidity adds) are taxed. Buys and wallet-to-wallet transfers are 0%.
- Of a taxed amount `a`, with `fee = a * taxBps / 10000`:
  - `baseOps = a * 300 / 10000` (the lasting 3%) is swapped to BNB for the operations wallet.
  - `excess = fee - baseOps`. Half of `excess` joins that same ops swap. The other half is the pool burn.
- Pool burn: those POP tokens are paid into the pair as swap input. The WBNB output (Pancake fee 0.25%) is sent to `0x…dEaD`, so the pair’s WBNB reserve falls and cannot be skimmed back. This is not a POP burn that leaves the pool untouched.
- The ops swap runs on sells once the contract holds at least 0.05% of the pair’s POP, and sells at most 0.5% of the pair per swap. `manualSwap()` is permissionless. A failed swap does not revert the sell. BNB the ops wallet rejects stays in `opsOwed()` until `flushOps()`.
- `taxSplitAt(amount, t) → (baseOps, excessOps, toPool)`.

## 8. Suggested buy loop

1. Confirm the Launch address is deployed (section 2). If it still says see table, stop.
2. Check the wallet’s Agent ID (section 3) and `remainingOf(wallet)`.
3. Read `phase()`, `saleEnd()`, `totalSold()`, `priceWei()`, `quoteCost(m)`, `quoteTokens(m)`.
4. On phase 1, send `buy(m)` with `msg.value >= quoteCost(m)`. Tokens arrive in the same transaction. Repeat until the Agent ID has bought 30 shares or the window ends.
5. On phase 2, anyone may call `open()`.
6. After open, sells use a fee-on-transfer-supporting router call and slippage that covers the current tax. Buys are not taxed.

## 9. Interface

```
PopLaunch
  buy(uint256 m) payable
  quoteCost(uint256 m) view → uint256
  quoteTokens(uint256 m) pure → uint256
  priceOf(uint256 serial) view → uint256
  costOf(uint256 m) view → uint256
  tokensFor(uint256 m) pure → uint256
  lpTokensFor(uint256 n) pure → uint256
  agentOf(address) view → (uint256 id, bool ok)
  remainingOf(address) view → uint256
  phase() view → uint8
  saleEnd() view → uint256
  saleOver() view → bool
  totalSold() raised() priceWei() SALE_START()
  token() pair() REGISTRY() OPS_WALLET()
  open()
  flushOps()
  event Bought(uint256 indexed id, address indexed wallet, uint256 startSerial, uint256 count, uint256 cost, uint256 tokens)
  event Opened(uint256 bnb, uint256 tokens, uint256 lp, uint256 totalSold)

PopToken
  currentSellTaxBps() view → uint256
  sellTaxBpsAt(uint256 t) view → uint256
  taxSplitAt(uint256 amount, uint256 t) view → (uint256 baseOps, uint256 excessOps, uint256 toPool)
  tradingOpenedAt() taxBaseOps() taxExcessOps() taxToOps() taxToPool() poolWbnbBurned()
  manualSwap() flushOps() opsOwed()
  event SellTax(address indexed from, uint256 amount, uint256 bps, uint256 baseOps, uint256 excessOps, uint256 toPool)
  event PoolBurn(uint256 tokensIn, uint256 wbnbOut)
```

Do not send a transaction to an address in section 2 that is see table.