architecture

when you buy or sell sato through the official path, the transaction flows through a uniswap v4 pool. the pool is special: it can never hold any liquidity. attempts to add liquidity revert forever.

instead, a hook attached to the pool intercepts every swap before it touches the amm, replaces the amm math with its own bonding curve, and acts as the counterparty itself. that hook is SatoHook.

┌────────┐ swap  ┌──────────────┐
│ wallet │ ─────▶│ v4 poolMgr   │
└────────┘       └──────┬───────┘
                        │ beforeSwap
                        ▼
                 ┌──────────────┐
                 │   SatoHook   │
                 │              │
                 │ ‒ curve math │
                 │ ‒ holds eth  │──┐
                 │ ‒ skims fee  │  │ mint
                 └──────┬───────┘  │ burn
                        │          ▼
                        │   ┌────────────┐
                        └──▶│ SatoToken  │
                            │  (erc-20)  │
                            └────────────┘

eth lives on SatoHook. sato lives on SatoToken. the v4 poolManager simply routes the swap deltas back and forth. the hook is the only address allowed to mint or burn sato, and that role is locked permanently at deployment time.

three contracts, three roles

• SatoToken— the erc-20. holds nobody's eth, runs no logic of its own beyond mint/burn gating. see satoToken.
• SatoHook— the bonding-curve engine. holds the eth reserves, runs the curve, enforces all guardrails. see satoHook.
• v4 PoolManager— uniswap's singleton swap router. invokes the hook's beforeSwap callback, settles the resulting deltas. not owned by sat0, not modified by sat0.

why a v4 pool at all

a bonding curve could be implemented as a standalone contract. deploying it as a v4 hook gets two things for free: a standard swap interface that any router or wallet already speaks, and a second “normal” pool can be deployed later for secondary trading without disturbing the curve. see lifecycle for how the two pools coexist.

the trust boundary

the poolManageris trusted to invoke the hook honestly — it is uniswap's code, audited and shared by every v4 pool. SatoHook guards the boundary with two checks: aNotPoolManager modifier on every entrypoint, and a strict validation of the pool key in beforeInitialize (correct currencies, correct fee, correct hook address). after that first init, no other pool can attach to the same hook.