outcomes

the previous pages described the machine. this one describes what the machine produces and refuses to produce. each rule maps to one or more outcomes someone might wish for, and one or more they cannot engineer.

what is possible

• buy along the curve. deposit eth in any size up to 5 eth per swap, receive sato priced by the forward curve, with a ±10% entropy roll during the first 100 blocks and exactness after.
• exit at any time.burn sato along the inverse curve to receive eth. the price depends only on the curve's current position, not on the order book or anyone's willingness to buy.
• trade on a secondary pool. once a normal v3 or v4 pool is spun up post-launch, you can swap sato vs. eth (or anything) at market price. the bonding pool keeps acting as a price floor, since you can always exit it at the inverse-curve price.
• verify the contract.every constant is a public getter. every immutable is on-chain. the manifesto is decodable. you can confirm the deployed bytecode matches the audited source by hashing the source against the deployed code, and confirm the deployment's genesis with GENESIS_HASH.
• observe the curve. ethCum, totalMintedFair, feesAccrued, curveReserveEth(), selfDeprecated — all readable any time. no privileged information.

what is impossible

minting without paying

no airdrop, no allocation, no pre-mine. SatoToken exposes exactly one minter address (the hook), and the hook only mints inside the swap path with eth flowing in.

front-running the curve

two buys in the same block see the same starting ethCum, but the curve is path-independent: the second buy is priced at the first buy's endpoint. mev bundlers can reorder, but each buy still pays its slice of the integral.

buying after exhaustion

once selfDeprecated = true, every buy reverts with SelfDeprecatedNoBuys. this is permanent. the chain itself enforces it.

same-block round-trip

a buyer who bought in block N cannot sell in block N. the cooldown is per-address. an arbitrageur must spread across at least two blocks, by which time the curve, the entropy roll, and the rest of the world have moved.

exact-output trades

the hook rejects amountSpecified ≥ 0. you cannot ask “give me exactly N sato, charge me whatever it takes.” you have to commit eth, and the curve decides the sato.

adding liquidity

beforeAddLiquidity reverts forever. the bonding pool can never carry conventional amm liquidity. no LP can ever exit with a slice of reserves.

draining the hook

there is no withdraw function. no rescue function. the contract's eth balance can only decrease through the inverse curve, paid out to sellers in exchange for burned tokens. feesAccrued is never paid out.

changing a parameter

no setter exists for any constant in SatoHook or SatoToken beyond the one-time setMinter. no governance, no admin, no oracle.

pausing trades

no pause modifier exists anywhere in the codebase.RESTRICTIONS_FORBIDDEN = true is a self-evident assertion of this.

blocking an address

no blocklist mechanism. transfers route through standard openzeppelin ERC20. the only mint/burn authority lives on the hook, which is itself code, not an operator.

upgrading either contract

no proxy. no implementation slot. the deployed bytecode is the final bytecode.

scenarios in detail

flash-loan buys during bootstrap

a buyer who flash-loans a large eth balance and tries to corner the cheap end of the curve must split into 5-eth slices (the per-swap cap), and each slice is priced sequentially up the curve. they cannot extract pure floor-price sato; they pay a marginal premium on each slice. entropy adds variance: any single slice may roll low, leaving them with less sato than the integral predicts.

even with the win, the cooldown forces them to hold for at least one block before they can sell. in that block, others have bought and the curve has moved.

price discovery after exhaustion

once buys are forbidden, the bonding pool turns into a one-way sink: it can absorb sellers and pay them eth at the inverse curve, but it cannot accept new entrants. price discovery moves to any secondary pool that exists. the inverse-curve price effectively sets a floor — selling into the bonding pool is always available — while the secondary pool determines the spot price above that floor.

the asymptote in practice

the curve never crosses K = 21,000,000. self-deprecation triggers at 99% of K against the fair curve, well before the saturation point at eth/S = 50 (= 25,000 eth cumulative). reaching 99% requires roughly S · ln(100) ≈ 2,303 eth cumulative absorbed by the curve.

what the protocol intentionally does not optimize for

• fairness. the curve is uniform, not equal. early buyers pay less per token. that is the design, not a bug.
• liquidity depth. the bonding pool is a one-sided ledger of cumulative eth-for-sato. depth on either side is unbounded in the trivial sense but the spread on real-world execution depends on the inverse curve slope, not on order-book density.
• yield. nothing in here pays for holding sato. there is no rebase, no staking, no fee distribution. the 0.3% fee accrues to nobody.
• upgrade flexibility. there is none, by construction. if anything is wrong, it is wrong forever.