# DOGGO AGENT — whitepaper

**DOGGO / DOGGO AGENT · BEP-20 · BNB Smart Chain (56) · no owner keys · no transfer tax
· no upgrade · no refund · no deadline · treasury 30% of paid fares · LP burned at launch**

---

## 0. One paragraph

DOGGO is a fixed share board. 50,000 shares, each worth 100,000 DOGGO, sold through a
five-step price ladder that cannot move inside a step. The ladder *is* the curve — there
is no bonding math and no oracle, so the market cap at every point of the sale can be
read off a table before you spend anything. 1,000 of the shares are a free lane, outside
the ladder and outside the price. The other 49,000 climb 0.001 → 0.005 BNB per share in
four 10,000-share tranches and a closing 9,000-share one, which puts fully diluted value at
50 → 250 BNB across the sale.
The moment 10,000 paid shares are gone — the end of the first tranche — anyone, not the
team, can open the PancakeSwap V2 pool, and that pool's LP tokens go to `0x…dEaD` in the
same transaction. Opening the pool ends the sale; if nobody opens it, the ladder keeps
climbing and the pool opens at the last filled price whenever it does. After that the
contract is done: it cannot mint, cannot pause, cannot tax a transfer, cannot be upgraded,
and cannot take anything back.

---

## 1. Why a board instead of a curve

Bonding curves are honest but unreadable: the price at share 34,750 depends on fifteen
thousand prior buys, and nobody can promise what it will be when you press the button.
A board is the opposite. Five prices are written down, each one applies to exactly one
window of the ladder (10,000 shares, or 9,000 for the last), and the same table that
prices your buy also prices the whole supply.
That makes three things checkable before you sign:

1. **What you pay.** `quote(n)` walks the table. A 3-share buy at share 9,998 costs
   2 × 0.001 + 1 × 0.002 = 0.004 BNB, and you can compute that yourself.
2. **What the market cap is after your buy.** 50,000 × the current step price. It is a
   number on the board, not an estimate.
3. **What the pool will open with.** The last filled step price, and 70% of everything
   paid, because that ratio is a constant.

The trade-off is deliberate: a board cannot react to demand. If the fourth tranche is
slow, the price simply waits there. DOGGO would rather be legible than clever.

---

## 2. Supply, derived from the ladder

Supply is not a round number chosen first. It falls out of wanting each tranche to be an
exactly equal 10,000 shares and wanting the ladder to end on a clean multiple:

```
free lane            1,000 shares   (outside the ladder, outside the price)
paid ladder         49,000 shares   (4 x 10,000, then a 9,000 close)
                    -----------
total               50,000 shares
1 share               100,000 DOGGO
total supply       5,000,000,000 DOGGO   at a full sale
hard cap           8,500,000,000 DOGGO   (3.5B unissued headroom, never minted)
```

Four steps of 10,000 and a closing step of 9,000 are what make 1,000 free + 49,000 paid
land exactly on 50,000. Padding the free lane on top of a full 50,000 ladder would have
made the board 51,000, which is the number this design refuses: the board is 50,000 and
the free lane is the last thousand that fits inside it.

### Market cap per step

Market cap is 50,000 × price, because the free lane also exists and is never priced:

| tranche | paid shares | price / share | market cap | raised by end of tranche |
|---|---|---|---|---|
| 1 | 0 – 9,999 | 0.001 BNB | 50 BNB | 10 BNB |
| 2 | 10,000 – 19,999 | 0.002 BNB | 100 BNB | 30 BNB |
| 3 | 20,000 – 29,999 | 0.003 BNB | 150 BNB | 60 BNB |
| 4 | 30,000 – 39,999 | 0.004 BNB | 200 BNB | 100 BNB |
| 5 | 40,000 – 48,999 | 0.005 BNB | 250 BNB | 145 BNB |

Market cap at a step means *"if the sale stopped here"*. It is the same number for every
share in the step, which is the point: the ladder prices the whole float, not one lot.

---

## 3. Where the money goes

A paid fare is split in the same transaction it arrives:

```
30%  -> treasury          immutable 0x4061a3815f08d5daC1D1f3FdddBf760986E31279, paid immediately
70%  -> held in contract  cannot leave except through _launch()
```

The 70% is the pool seed. It is not a team balance: there is no function that can send
it anywhere except the Pancake pair, and only once, at launch. This is also why there is
no refund. After a buy, 30% of that money is already someone else's and 70% is already
promised to the pair; a refund path would have to break one of those two facts.

That 30% is the only cut in the system, and it goes to the treasury: there is no owner key
to call, no team token allocation, and no second fee anywhere. The treasury is paid by the
sale itself, not by a privilege held over the contract.

The free lane is different in kind. Its fare leaves the moment it arrives — 100% to the
treasury, in the same transaction, and if the treasury refuses the transfer the whole
mint reverts (`FeeStuck`). No free-lane value ever enters the pool accounting, which is
why claiming a free share does not move the ladder price.

---

## 4. Launch

Launch is the only event after which the token can move.

- **Permissionless at 10,000 paid shares.** `launch()` is a public function. Anyone can
  call it; nobody has to be asked. Calling it closes the sale for good — a launch is also
  an exit from the ladder, not a pause.
- **Automatic at 49,000.** The last paid buy calls it itself.
- **What it does:** wraps the contract's whole BNB balance to WBNB, sends both sides to
  the PancakeSwap V2 pair, mints the token side to the pair, and calls `pair.mint(0x…dEaD)`.
  Then it opens transfers. There is no path back to a closed state.

The token side is sized from the BNB side and the last filled price:

```
tokenIn = balance * 100,000e18 / priceAt(paidSold - 1)
```

So the pool opens at exactly the price of the tranche that was last filled. Nobody sets
the opening price after the fact.

### The two checkpoints

**At 10,000 paid shares** — 10 BNB raised, 7 BNB into the pool, 0.7B DOGGO beside it,
pool opens at 0.001 BNB per share. This is the earliest possible open: a pool worth 14% of
the 50 BNB market cap it opens into, and the sale stops there.

**At 49,000 paid shares** — 145 BNB raised, 101.5 BNB into the pool, 2.03B DOGGO beside it,
pool opens at 0.005 BNB per share. 41% of the 250 BNB market cap, and 7.03B of the 8.5B
cap in existence (the rest is never minted — see §5).

---

## 5. What the contract cannot do

The privilege list is the product. In the deployed bytecode there is:

- **no owner**, no `Ownable`, no admin role, no pending owner;
- **no mint function reachable after the sale** — minting is minter-gated, and the minter
  is the sale contract, which only mints inside `freeMint`, `buy`, and `_launch`;
- **no pause, no blacklist, no cooldown, no trading gate** beyond the single launch lock;
- **no fee switch** — the 30% is a compile-time constant, not a state variable;
- **no proxy, no implementation pointer, no upgrade admin**;
- **no withdraw, sweep, or rescue** — the only value-moving path is `_launch()`;
- **no refund**, by construction, for the reason in §3.

The 8.5B cap exists only so the 5.0B + 2.03B accounting of §4 fits with room to spare. It
is never reached. A full sale leaves 3.5B permanently unminted.

The one lock in the system: `_update` reverts `Locked()` while `!live` and both endpoints
are non-zero. Buying and receiving are fine; moving to someone else is not, until launch.

---

## 6. The two doors

### Free lane — 1,000 shares

- One per wallet, one claim, exact value, agent-gated like everything else.
- 1 share = 100,000 DOGGO.
- Outside the ladder: does not change the price, does not enter the pool accounting.
- The lane closes when its 1,000 shares are gone, permanently.

### Paid ladder — 49,000 shares

- `buy(n)` for any `n` up to the remaining window, subject to the 10-share wallet cap.
- A single buy may cross a boundary; each share pays its own tranche price, which is
  exactly `quote(n)`.
- 30% to treasury, 70% held, same transaction.

Both doors share one gate: `agentOk(wallet)`, true when the wallet holds at least one
Binance .ai Agent ID. A wallet that holds no ID cannot use either door — the sale is for
agents, and the gate is read from the registry, not from a signature this team controls.

**10 shares per wallet, free lane counted.** The cap is total, not per door.

---

## 7. Risks, stated plainly

- **The ladder may never reach 10,000.** Below the checkpoint there is no pool and nothing
  to call. The 70% sits in the contract, immovable, and no token can move. This is the
  main failure mode and it is not hypothetical.
- **The pool opens at the tranche price, not at a "fair" price.** If the last filled step
  was 0.002, the pool opens at 0.002 — for everyone, including sellers.
- **A burnt LP does not make a price safe.** It removes one specific attack (a pull) and
  nothing else. Price after launch is whatever the pair says.
- **The board is not a curve, so it does not defend a floor.** A slow tranche is slow;
  there is no mechanism that reacts.
- **The free lane fare is real money.** It leaves the wallet in the same transaction that
  mints the share, and it is not returned by any path.
- **Nothing here is investment advice, and the contract has no guarantee of returns.**
  Read the source before you sign; every claim in this paper points at a constant in it.

---

## 8. Questions we expect

**Why 49,000 paid plus 1,000 free, instead of a round 50,000 paid?**
Because 50,000 is the whole board, not the paid half: 1,000 free shares plus 49,000 paid
land exactly on it. The ladder then closes on a 9,000-share step, the raise lands on
145 BNB, and the market cap steps are the round 50 / 100 / 150 / 200 / 250 BNB.

**Why not let the team launch, like a normal project?**
A team that can launch can also not launch, or launch at a price that suits it. Here the
function is public and the price is the last filled step — there is nothing to negotiate.

**What happens to the 70% if the last buy is at 48,999?**
It seeds the pool with 101.5 BNB at 0.005 per share. That 49,000th buy triggers it itself.

**Can the team mint more later?**
No. The minter is the sale contract, and every mint path inside it is bounded by
`TOTAL_SHARES`. There is no owner to call anything else.

**Can a buy be undone?**
No. See §3 — 30% is already forwarded and 70% is already promised to the pair.

**Is there a deadline?**
No. The board stays open until the shares are gone or the launch threshold is met.
