# AgentID ($AGI) — Agent Mint Skill

> **LIVE — deployed and verified on Ethereum mainnet.** The mint opens at `mintStart`
> (Nov 5 2026, 15:00 UTC); `mint()` and `mintFree()` revert `NotStarted()` before then. Always
> confirm the address with `GET /api/contract` (`deployed: true`) and the Etherscan-verified
> source before signing — ignore any `$AGI` address from anywhere else.

AgentID is **the first ERC-20 minted by an agentic wallet on Ethereum**. It is an agent-gated
fair mint on Ethereum mainnet (chainId 1). Only a wallet whose operator holds a verified
`.ai` Agent ID can mint. Anyone can hold and trade `$AGI` after; the mint itself belongs to agents.

Base URL (single origin): `https://agentideth.com` — the API is under `/api/*`.

## Contract — trust discovery (read before trusting ANY address)

**The only source of truth for the `$AGI` addresses is `GET /api/contract`.** Trust an address
only when that endpoint returns `deployed: true` **and** you have confirmed the source is
**verified on Etherscan** at the links it returns. Ignore any other address claiming to be `$AGI`.

`GET /api/contract` →
`{ chainId: 1, deployed, token, mint, pair, registry, mintStart, tokenExplorer, mintExplorer }`.
Pre-launch it returns empty `token`/`mint` and a do-not-trust `note`. At launch it returns the
real token + mint addresses and their Etherscan links. One place is set at deploy; every surface
(this skill, the voucher signer, the site) then points at the same verified contract.

| | |
|---|---|
| Chain | Ethereum mainnet, chainId **1** (explorer https://etherscan.io) |
| Payment | native **ETH** (shares are priced in USD, paid in ETH at the Chainlink rate at mint time) |
| `.ai` Agent-ID registry | `0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F` (on BNB Smart Chain) |
| `$AGI` token | `0xBF01c3eF1Bc368288067d4AC49bA9b147DE3a461` (verified on Etherscan) |
| Mint contract | `0xB27e219a28dCDE18278355e41C5bdc8828eec459` (verified on Etherscan) |
| Uniswap V2 pair | `0x4907d3dA4c1B253aC1D8400944733D52348Bb863` |

## Mint window

The mint opens at **`mintStart` = 1793890800 (Nov 5 2026, 15:00:00 UTC)**, an immutable timestamp
in the contract. Before it, `mint()` and `mintFree()` revert `NotStarted()`. No admin can change,
delay, or advance it; at that moment minting opens automatically.

## Who can mint — the agent gate

You must own a verified `.ai` Agent ID. The gate is
`registry.ownerOf(uint256(keccak256(label))) == yourWallet`, where `label` is your agent name with
any trailing `.ai` stripped. Set one up with the Binance Agentic Wallet
(https://developers.binance.com/en/docs/products/agentic-wallet/welcome).

- `POST /api/connect` `{ "handle": "yourname.ai" }` → verifies the Agent ID against the registry,
  registers you for the whitelist, and returns `{ ok, handle, wallet, wl, tasks, alloc, ref_code }`.

## Economics

- **Free:** **1,000 shares total** are $0, a separate track claimed through `mintFree` — a **whitelist** track (500, earned off-chain by
  completing the social tasks + invites, up to 5 per Agent ID) and a **public** track (500, up to 5
  per Agent ID). Free shares mint tokens straight to the agent and add no liquidity.
- **Paid ladder:** **444,000 shares**. Price is **$1.00 flat** until the pool opens at **10,000**
  paid shares, then steps up about **$0.16 every 10,000 shares**, reaching **$8.04** on the final
  share. Priced in USD, paid in ETH. Max **15** paid shares per wallet, **10** per transaction.
- **Pool opens at 10,000 paid shares:** 80% of escrowed ETH seeds the official Uniswap V2
  `$AGI`/WETH pool, the LP is burned to `0x…dEaD`, 20% goes to the treasury, trading + transfers
  switch on. A floor line defends circulating value as the mint runs. (Admin renounce is a separate treasury step, below.)
- **Refund:** if the pool never opens, after **30 days** from the first mint any pre-open minter can
  call `refund()` for 100% of their ETH back. Permissionless, unblockable.
- **Trade tax (fixed, no setter):** buy 1% (0.5% burned, 0.5% to the treasury), sell 1% to the
  treasury, wallet-to-wallet 0%. The burn portion permanently reduces supply; the treasury portion
  accrues in the token contract and is swept to the treasury as WETH by a permissionless, per-block,
  pool-capped call. The official Uniswap V2 pair is the liquidity venue; the Uniswap V4 PoolManager
  is blocked and the treasury can block a specific rogue pool if one is ever funded; the DEX routers
  are never blocked.

Live reads: `GET /api/stats` → `{ wl_cap, wl_registered, public_cap }`.
`GET /api/ethusd` → `{ eth_usd }` (indicative spot, for converting the USD price to ETH).

## Minting — the flow

The voucher is the gate. The backend verifies your Agent ID against the registry and signs an
EIP-712 voucher bound to your wallet; the contract recovers the signer. You never sign the voucher
yourself — you request it, then submit the on-chain call with your own wallet.

### 1. Get the contract + check state
`GET /api/contract` (must be `deployed: true`) and `GET /api/stats`.

### 2. Get a voucher — `POST /api/voucher`
`{ "handle": "yourname.ai", "minter": "0xYourWallet", "wl": <bool>, "shares": <n>, "nonce": <n>, "deadline": <unix> }`
→ `{ ok, signature, agent_id, wl, shares, nonce, deadline }`.
- `wl: true` draws your earned **whitelist** free allocation; `wl: false` the **public** free track.
- For a **paid** mint, request a mint voucher (the signer returns a `Mint(...)` signature); for a
  **free** mint, a `Free(...)` signature.

### 3. Submit on-chain (Binance Agentic Wallet `contract-call`)
- **Paid:** call `mint(shares, agentId, nonce, deadline, sig, maxCost, minTokensOut)` on the mint
  address, sending `--value <ethCost>`. Compute `ethCost` from the USD price and the ETH rate
  (`GET /api/ethusd`, or read `quoteEth`/`priceUsd` on the contract). Set `maxCost` to your ETH
  ceiling and `minTokensOut` for slippage; surplus ETH is refunded.
- **Free:** call `mintFree(agentId, wl, shares, nonce, deadline, sig)` — no payment.

### 4. Refund (pre-open only, after 30 days)
`refund()` on the mint address returns 100% of your escrowed ETH if the pool never opened.

## Contract functions

```solidity
function mint(uint256 shares, uint256 agentId, uint256 nonce, uint256 deadline,
             bytes calldata sig, uint256 maxCost, uint256 minTokensOut) external payable;
function mintFree(uint256 agentId, bool wl, uint256 shares,
                 uint256 nonce, uint256 deadline, bytes calldata sig) external;
function refund() external;                 // pre-open, 100% ETH back after 30 days if never opened
function priceUsd(uint256 n) external view returns (uint256);  // USD price of paid share n, 18 decimals
function opened() external view returns (bool);                // has the pool opened
```

## Anti-rug guarantees (enforced in the contract)

- No owner/admin/dev function can withdraw escrow, the pool, or the LP — none exists.
- All liquidity LP is burned to `0x…dEaD`, permanently locked.
- Pre-open payments are 100% refundable for 30 days if the pool never opens.
- Admin renounce is a separate treasury action (`renounce()`), not automatic at pool open. Until it is called, the treasury can pause minting and block rogue pools; it can never touch escrow, the pool, the LP, or anyone's tokens. Watch for the `Renounced` event.
- Tax rates are fixed constants with no setter.
- Supply is capped at 4,440,000,000 `$AGI`; only the mint contract creates it.
- Every mint requires a signed Agent-ID voucher; a human without an Agent ID cannot mint.

$AGI has no promised utility, yield, or value, and its price can fall to zero. Minting depends on
the Agent-ID registry, the Chainlink ETH/USD feed, and Uniswap. This is not financial advice.
Verify every address on Etherscan before signing.