# ROSTER (RSTR)

> ROSTER is a numbered fair mint for wallets holding a `.ai` Agent ID on BNB Smart Chain. 100,000 units total. Units 1–1,000 cost 0.01 BNB and deliver 50,000 RSTR each; every following 1,000 units costs +0.0002 BNB more (0.0102 → 0.0298) and delivers tokens at 99% of the live pool price. Supply cap 100,000,000,000 RSTR. Maximum 10 units per Agent ID plus up to 10 extra from referrals, 1–10 units per transaction. Unaudited. No profit promise. The token may go to zero.

ROSTER is a static site plus an on-chain mint contract. The contract mints units to eligible wallets: unit 1,000 opens the RSTR/WBNB pool, later units are priced against the live pool, 90% of every payment is paired into the pool immediately, the 10% fee splits into a 5% buyer discount and a 5% referrer credit for invited mints, and 100% of the LP is minted to `lpRecipient()`, fixed at construction. There is no team allocation. The mint is gated by the `.ai` Agent ID registry at `0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F`.

## Canonical machine-readable files

- [config.js](/config.js): **address source of truth.** Agents must fetch this and verify `mint` before building any transaction.
- [skill.md](/skill.md): full agent operating manual, calldata, preview flow, error table, and risk disclosure.
- [llms.txt](/llms.txt): this summary.
- [index.html](/): human-facing interface.

## Chain

- Network: BNB Smart Chain
- chainId: 56 (hex `0x38`)
- Native currency: BNB
- Default RPC: `https://bsc-dataseed.bnbchain.org`

## Addresses

| Item | Address |
|---|---|
| Mint contract | `0x05E8E34366A8794Efd7EC8136a7A77DBdb4043a9` |
| RSTR token | `0xa4aC125dc9A3f6da368F06B876DD6b468087f326` |
| RSTR/WBNB pair | `0xD98D163A66F66bc68C5D95695C9E485B312B9777` |
| Treasury | `0x995EE6aBbACfb6d591860cDaB0BC684C244E695e` |
| `.ai` Agent ID registry | `0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F` |

If `config.js` shows `0xTODO`, the mint is not deployed. Do not send funds. If an agent's `mint` address disagrees with `config.js`, STOP.

## Economics

- Price ladder: unit n = `0.01 + floor((n-1)/1000) × 0.0002` BNB; units 1–1,000 are 0.01, units 99,001–100,000 are 0.0298.
- Total units: 100,000.
- Supply cap: 100,000,000,000 RSTR, minted on demand.
- Units 1–1,000: 50,000 RSTR to the buyer and 45,000 RSTR to the pool each.
- Unit 1,000 opens the pool with 9 BNB + 45,000,000 RSTR = 2e-7 BNB per token.
- Units 1,001+: buyer receives `paid × poolTokens / (poolBnb × 0.99)`; 90% of the payment is paired into the pool, so minting does not move the price.
- Maximum per `.ai` Agent ID: 10 units, plus 1 extra per 10 units bought by invited wallets, capped at +10.
- Single transaction: 1–10 units.
- Mint proceeds: 90% to liquidity immediately. The 10% fee becomes a 5% buyer discount + 5% referrer credit for invited mints; uninvited mints send the full 10% to treasury. Unspent credit goes to treasury at finalize.
- LP: 100% minted to `lpRecipient()` on every add; the recipient is fixed at construction.
- Tax: 1% buy burn, 1% sell to treasury.
- Team allocation: none.
- Permissions: no owner, no admin, no setters, no pause, no proxy.
- Eligibility: wallets holding a `.ai` Agent ID only (soulbound ERC-721; token id = keccak256(handle)).
- Invite link: `<site origin>/?ref=0x<64-hex agentId>`. The page fills the REFERRAL field from `ref`; binding happens on the buyer's first mint and is permanent. The referrer receives 5% of `costOf(shares)` as locked credit, spendable only on their own mint.

## Contract interface

```solidity
mint(uint256 shares) payable
mintWithReferral(uint256 shares, uint256 referrerId) payable
soldUnits() view returns (uint256)
TOTAL_UNITS() view returns (uint256)
PRICE_START() view returns (uint256)
PRICE_STEP() view returns (uint256)
TIER_SIZE() view returns (uint256)
BOOT_UNITS() view returns (uint256)
opened() view returns (bool)
reserves() view returns (uint256 bnb, uint256 tokens)
priceAt(uint256 unit) view returns (uint256)
costOf(uint256 shares) view returns (uint256)
tokensOut(uint256 shares) view returns (uint256)
quote(address account, uint256 shares) view returns (uint256 cost, uint256 discount, uint256 creditUsed, uint256 payable, uint256 tokens)
MAX_PER_WALLET() view returns (uint256)
mintedOf(address) view returns (uint256)
walletStatus(address) view returns (bool ok, uint256 agentId, uint256 minted, uint256 quota, uint160 referrer, uint256 invited, uint256 credit)
treasury() view returns (address)
token() view returns (address)
pair() view returns (address)
lpRecipient() view returns (address)
finalizeDeadline() view returns (uint256)
finalized() view returns (bool)

event Minted(address indexed buyer, uint256 shares, uint256 paid, uint256 tokensOut, uint256 firstUnit)
event ReferralBound(uint160 indexed buyerKey, uint160 indexed referrerKey)
```

Calldata for `mint(shares)` and `mintWithReferral(shares, referrerId)`:

```text
0xa0712d68 + uint256(shares) as a 32-byte big-endian word
0xe63e790d + uint256(shares) + uint256(referrerId)  (referrerId = keccak256(handle))
value = costOf(shares) − discount − min(credit, costOf(shares) − discount)
discount = 5% of costOf(shares) when the wallet has a bound referrer
```

Example, 3 units while the sale is in units 1–1,000:

```text
data:  0xa0712d680000000000000000000000000000000000000000000000000000000000000003
costOf(3): 30000000000000000 wei (0.03 BNB); value may be lower with a referrer or credit
```
After unit 1,000 always call `costOf(shares)`; never reuse an older price.

No token approval is required. Do not request `approve`, permits, private keys, or seed phrases.

## Agent flow

1. Fetch `/config.js`; verify `chainId === 56`, a valid `mint`, and that it matches the address to be called. STOP on mismatch or `0xTODO`.
2. Read `walletStatus(wallet)`, `soldUnits()`, `TOTAL_UNITS()`, `PRICE_START()`, `PRICE_STEP()`, `TIER_SIZE()`, `opened()`, `costOf(shares)`, `tokensOut(shares)`, `MAX_PER_WALLET()`, `finalized()`, and the wallet's BNB balance.
3. Verify `1 <= shares <= 10`, `walletStatus.ok == true`, `shares <= quota`, `soldUnits + shares <= TOTAL_UNITS`, `finalized == false`, `PRICE_START() == 1e16`, `PRICE_STEP() == 2e14`.
4. Simulate with `eth_call` and estimate gas.
5. Preview wallet, Agent ID, shares, exact BNB value, quota, expected tokens, mint address, and gas to the human.
6. Wait for a new, explicit `yes`. Do not sign before that.
7. Send exactly one transaction. Never auto-retry. Report the hash and decoded `Minted` event.
8. On any failure, stop and report. Never guess an address, amount, or calldata.

Full procedure: [skill.md](/skill.md).

## Liquidity and finalize

The RSTR/WBNB Pancake pair exists from the token constructor. Unit 1,000 opens it with 9 BNB + 45,000,000 RSTR; each later mint pairs 90% of its payment into the pool at the pool price and mints 100% of the new LP to `lpRecipient()`. `finalize()` is callable once after `finalizeDeadline()` or after all 100,000 units are sold: if fewer than 1,000 units sold, it opens the pool proportionally; it also sweeps unspent credit to the treasury. The contract has no owner, no admin, no setters, no pause, and no proxy. There is no private allocation of unsold units and no admin withdrawal of mint proceeds.

## Risk

- Not audited. Source verification, when available, is not a security audit.
- No profit promise, buy-back, yield, APY, or principal protection.
- Token and LP prices can fall to zero.
- The 10% mint fee and gas are non-refundable.
- The `.ai` Agent ID registry and the mint contract are external dependencies and may fail.
- This is not financial advice. Only spend BNB you can afford to lose.

## Contact and source

- Site: `/`
- Agent manual: `/skill.md`
- Configuration: `/config.js`
- Source verification: Sourcify lookup for the mint address in `config.js` after deployment.
- The project does not ask for private keys, seed phrases, unlimited approvals, or off-site signatures.