# Only Ponzi — agent mint guide

Site: https://onlyponzi.com
Network: BNB Smart Chain, chain ID 56
Configuration: https://onlyponzi.com/config.json
ABI: https://onlyponzi.com/abi/sale.json
Status: NOT DEPLOYED YET. Addresses are pending. Do not send any transaction; you may explain the rules.

This site never connects a wallet. A user pastes the mint prompt into their own agent; the agent reads this guide,
verifies the contract, simulates, and asks the user to confirm each transaction in their wallet.

## Deployment

Sale (AgentMintSale, also the soulbound ERC-721): PENDING (not yet deployed)
0ponzi token (ERC-20, 18 decimals): PENDING (not yet deployed)
Agent ID eligibility contract: PENDING (not yet deployed)
Payment token, BSC USDT (18 decimals): 0x55d398326f99059ff775485246999027b3197955
Deploy block: PENDING

Verify before any transaction (stop on any mismatch):
- eth_chainId == 56
- sale.paymentToken() == USDT above; sale.token() == 0ponzi above; sale.eligibility() == eligibility above
- MAX_SUPPLY() == 10000; MAX_PER_WALLET() == 10; mintPrice() == 1e18; tokenPerMint() == 10000e18; MAX_CLAIM_BATCH() == 200; SALE_DURATION() == 1209600
These are immutable. The contract has no owner, pause, upgrade, parameter setters, extra minting or withdrawal.

## Rules (what the user gets)

- Eligibility: eligibility.hasAgent(wallet) == true at mint time (the wallet holds a Binance Agent ID). No other requirement.
- Price 1 USDT per NFT. Total 10000 NFTs. At most 10 per wallet, lifetime (mintedByWallet). One call mints 1..10.
- NFTs are non-transferable (transfer, approve and setApprovalForAll all revert).
- Each mint releases 10000 0ponzi (total supply 100000000 = 10000 x 10000):
  50% to the new NFT, 30% split equally across ALL previously minted NFTs (per NFT, not per wallet), 20% to the pool reserve.
  NFT #1 gets 80% (no prior NFTs) and 20% goes to the pool. Integer remainder goes to the new NFT.
- A batch mint of q equals q consecutive single mints in tokenId order; earlier NFTs in the same batch receive the later ones' 30%.
- Final allocation of NFT k when N NFTs exist in total: 5000 + 3000 * sum_{n=k+1..N} 1/(n-1)  (k=1: 8000 + ...).
- The sale ends when all 10000 are minted, or 14 days after deployment (saleDeadline()). After the deadline anyone may call finalize(). Tokens for unminted NFTs are burned.
- Prize: the minter of the last NFT (winner()) receives 10% of all mint revenue — 1000 USDT if sold out, otherwise 10% of actual revenue. It is paid automatically at the end; if that payout was deferred, anyone may call payPrize().
- The remaining 90% of USDT and the 20% token reserve seed a liquidity pool whose LP principal is permanently locked; pool trading fees go to the project.
- Tokens are only ledger entries during the sale. They can be claimed after ended() == true and are always paid to the NFT owner.

## Mint

1. Check ended() == false, minted() < 10000, latest block timestamp < saleDeadline(), eligibility.hasAgent(wallet) == true.
2. available = min(10 - mintedByWallet(wallet), 10000 - minted()). If the requested quantity exceeds it, tell the user and wait.
3. cost = quantity * mintPrice(). Check USDT.balanceOf(wallet) >= cost and enough BNB for gas.
4. If USDT.allowance(wallet, sale) < cost: approve(sale, cost) — exact amount only, never unlimited. Wait for the receipt.
5. Simulate sale.mint(quantity) from the wallet (eth_call / staticCall), estimate gas, show quantity, USDT cost, gas and the expected first id (minted() + 1). Submit the exact same call once, only after the user confirms in their wallet.
6. Wait for the receipt. Decode Minted(uint256 indexed tokenId, address indexed minter) and BatchMinted(address indexed minter, uint256 firstId, uint256 lastId, uint256 paid) from this sale. Return the BscScan link: https://bscscan.com/tx/<hash>
Never ask for a private key or seed phrase. Never resubmit a pending transaction; check the receipt and mintedByWallet first. On revert, stop, decode the error, report it; do not retry automatically or change the quantity.

Ethers v6 pattern (existing wallet signer, ABI above):
  const cost = BigInt(q) * await sale.mintPrice()
  if (await usdt.allowance(me, saleAddr) < cost) await (await usdt.approve(saleAddr, cost)).wait()
  await sale.mint.staticCall(q)
  const gas = await sale.mint.estimateGas(q)
  // after the user's confirmation:
  // const tx = await sale.mint(q)

## Queries (all read-only, no wallet needed)

- How many 0ponzi does a wallet have?  walletSummary(wallet) -> (nftCount, grossEmission, allocated, claimedAmount, unclaimed, claimableNow).
  "allocated" is the wallet's entitlement so far (18 decimals). grossEmission = nftCount x 10000 is the original emission of those NFTs, NOT the wallet's entitlement; never report it as the user's tokens.
- Per NFT:  walletPositions(wallet) -> [(tokenId, allocated, claimedAmount, unclaimed, claimableNow)]; tokenIdsOf(wallet) -> ids.
  Own mining vs dividends: allocationInfo(id).base is the NFT's own share; allocationOf(id) - base is dividends from later mints.
- Is it sold out / when does it end?  minted() of MAX_SUPPLY(), ended(), saleDeadline() (unix seconds), winner().
- Current prize: prizeAmount() (USDT, 18 decimals) = 10% of feesCollected().
- Before the end, allocated keeps growing with every later mint; claimableNow stays 0 until ended() == true (even after the deadline, until someone calls finalize()).

## Claim and settlement

- If block timestamp >= saleDeadline() and ended() == false: anyone may call finalize().
- After ended() == true: claimBatch(ids) with up to 200 ids whose claimableNow > 0 (already claimed ids are skipped). claimFor(id) claims one. Tokens always go to the NFT owner.
- If the prize payout or pool build was deferred: payPrize() / buildPool() may be called by anyone.

## Errors

SaleClosed — sale ended or past deadline. MissingAgentId — wallet lacks the Agent ID. WalletLimit — would exceed 10 per wallet.
SupplyLimit — not enough NFTs left. InvalidQuantity — quantity must be 1..10. PaymentMismatch — USDT received differs from cost.
NotEnded — claiming before the end. SaleNotOver — finalize() before the deadline. AlreadyEnded — already finalized.
AlreadyClaimed — id already claimed. BatchTooLarge — more than 200 ids. NonTransferable — NFTs cannot move.

## Mint prompt shown to users (English; the site also offers a Chinese version)

Mint 1 Only Ponzi NFT for me on BNB Smart Chain (chainId 56): 1 USDT (BSC USDT) each, plus a little BNB for gas. My wallet must hold a Binance Agent ID; each wallet can mint at most 10 in total.

Guide: https://onlyponzi.com/llms.txt
Config: https://onlyponzi.com/config.json
ABI: https://onlyponzi.com/abi/sale.json
Sale contract: (published at deployment)
Token ($0ponzi): (published at deployment)
USDT: 0x55d398326f99059ff775485246999027b3197955
Agent ID check: (published at deployment)

1. Read the guide, config.json and ABI. Verify chainId, and that the sale's paymentToken(), token() and eligibility() match the addresses above; confirm MAX_SUPPLY() = 10000, MAX_PER_WALLET() = 10, mintPrice() = 1e18, tokenPerMint() = 10000e18. Stop on any mismatch.
2. Check ended() = false, minted() < 10000, latest block time < saleDeadline(), eligibility.hasAgent(my wallet) = true. Available = min(10 − mintedByWallet(my wallet), 10000 − minted()); if it is below 1, tell me and wait for my decision.
3. Cost = quantity × mintPrice() (USDT, 18 decimals). Check my USDT balance and BNB for gas. If USDT.allowance(my wallet, sale) < cost, first approve(sale, cost) — this exact amount only, never unlimited.
4. Simulate mint(quantity) from my wallet and estimate gas. Show me the quantity, USDT cost, gas and expected token IDs (from minted() + 1). Submit exactly once, after I confirm in my wallet. Never ask for my private key or seed phrase. If it reverts, stop and decode the error for me; do not retry automatically or change the quantity.
5. Wait for a successful receipt, read my token IDs from this sale's Minted(tokenId, minter) events and give me the BscScan link. Never resubmit a pending transaction; check the receipt and mintedByWallet(my wallet) first.
6. After minting, read walletSummary(my wallet) and tell me nftCount and allocated (tokens credited so far, 18 decimals).

When I ask later, use these read-only calls:
- How many tokens do I have: walletSummary(my wallet) → allocated, claimedAmount, unclaimed, claimableNow; per NFT use walletPositions(my wallet). To split sources: allocationInfo(id).base is self-mined, allocated − base is the share from later mints. grossEmission is the original emission of these NFTs, NOT my entitlement — never report it as my tokens.
- Is it sold out / when does it end: minted() of 10000, ended(), saleDeadline(), prizeAmount() (current prize, USDT 18 decimals), winner().
- Claim: once ended() = true, call claimBatch(ids) for the IDs in walletPositions with claimableNow > 0, at most 200 per call. If saleDeadline() has passed but ended() = false, first call finalize() (anyone can), then claim.