$OAK

The treasury and contract admin is the single-owner wallet 0x856bb126188bDB5e425D3ac9D59E9ffBD12e6ECf. One owner key can spend treasury funds, redirect future subscription payments, replace the price signer and retire subscriptions. There is no second-signature requirement. Key compromise exposes these powers; key loss can make treasury funds and administration inaccessible. It cannot spend user wallet balances. Safe support is an optional deployment profile, not the launch setup.

Holding $OAK buys access and nothing else. Oak never promises returns, never pays holders from protocol fees, and never distributes fee payouts or rewards to token holders.

Oak is not affiliated with Robinhood. Oak shows a region notice by default.

---

1. $OAK Token Facts

• Name: Oak
• Ticker: $OAK
• Chain: Robinhood Chain (4663, 0x1237)
• Decimals: 18 (OAK_DECIMALS = 18)
• Launch venue & pair: Standard Pons V2 coin paired with native ETH (bonding curve, graduating at 4.2 ETH into a locked Uniswap v4 pool).
• Supply rule: Net supply is totalSupply(). Both the 5% holder sign-up burn (burnFrom) and OakBurner (burn) execute true token burns that permanently reduce totalSupply(). Tokens sent to dead addresses do not reduce totalSupply(), and liquidity locked by Pons at graduation remains part of totalSupply().

---

2. Subscription Plans and the Entry Curve

Oak charges zero per-call fees and 0% on your swaps and module actions. Access to action tools is paid on a 30-day cycle in USDG (0x5fc5360d0400a0fd4f2af552add042d716f1d168, 6 decimals).

Two ways to subscribe

1. Holder plan — 9 USDG per 30 days (9_000_000 base units):
   • When you join, the subscription contract computes the rounded-up $OAK entry amount N worth the current entry price, burns 5% of N (burn = ceil(N * 5 / 100)) from that holding in the same transaction, and stores the remaining post-burn balance N - burn as your signupOakCount. That recorded signupOakCount never changes while you remain subscribed.
   • Access check, not a coin lock: $OAK is a standard Pons coin and is never locked inside a contract. You keep access while your wallet's $OAK balance is at least your post-burn signupOakCount (checked fresh on every action tool call). Any $OAK above signupOakCount is free to trade at any time; if your balance dips below signupOakCount, action tools pause until you buy back.
   • One-time 5% sign-up burn and exact burn approval (subscribe.ts): Joining the holder plan (including rejoining after oak cancel) has a sign-up burn that burns 5% of the entry amount N (ceil(N * 5 / 100)) in the same transaction via burnFrom(wallet, burnAmount) and records signupOakCount = N - burnAmount. You need only N $OAK in your wallet at sign-up: for example, at an entry amount of 20,000 $OAK, you hold 20,000 $OAK, 1,000 $OAK burns at sign-up, and 19,000 $OAK is tracked as your signupOakCount. In packages/addon/src/subscribe.ts, the add-on reads [count, burn] from quoteHolder(note, sig), sets maxCount = ceilPercent(count) ((count * 101n + 99n) / 100n, at most 1% above the quoted count) to bound subscribeWithAuthorization(maxCount, note, sig, auth), and approves the exact quoted burn (approval(this.deployment.oak, contract, burn.toString(), this.deployment.chainId)), never unlimited.
   • Holder renewals: Cost 9 USDG per 30 days, burn zero $OAK, and take no price note (so oracle or note-issuer outages never block existing holders from renewing).
2. No-hold plan — 9 USDG plus one sixth of the entry price per 30 days:
   • Requires zero $OAK and burns nothing.
   • Re-priced at every 30-day renewal from the current entry curve. At the $20 floor entry price, the no-hold plan costs 12.333333 USDG (12_333_333 base units) per 30 days.

Shared subscription rules

• Billing window and prepay cap: paidUntil = max(now, paidUntil) + 30 days. Prepaying is capped at 90 days ahead (renewal opens when <= 3 days remain).
• Cancel (oak cancel): Callable at any time (even when lapsed or after a contract is retired). Cancelling sets plan = none, clears signupOakCount, ends access at once, and forfeits any remaining paid days. Rejoining later is a fresh sign-up at that day's price and count. Switching between holder and no-hold plans is done via oak cancel followed by oak subscribe.
• One-signature USDG payment with two checks: Holder payments use EIP-3009 receiveWithAuthorization on USDG (Global Dollar, version 1, chain 4663), requiring (1) from == msg.sender, (2) USDG.authorizationState(from, nonce) == false before the call, and (3) the contract's USDG balance to increase by the exact price across the call (preventing replayed or cancelled authorizations from settling as a no-op). Because the no-hold price moves with the on-chain ETH/USD average and net supply, the no-hold plan uses exact approve(maxPrice) + transferFrom of the contract-computed price.

Entry price table by $OAK market cap

The entry price is a continuous piecewise-linear curve across five market-cap bands:

• Market cap = totalSupply() × $OAK USD price.
• "USD" is the USDG quote of the on-chain ETH/USDG pool; Oak assumes USDG trades at a dollar.

---

3. Launch Phases and Price Source

Launch phases

1. Curve (phase != 2 on Pons factory): $OAK is still on its bonding curve. Only the no-hold plan is open at the flat floor of 12.333333 USDG, with no price note required, and the holder plan is closed (HolderClosed()).
2. Warmup (first 30 minutes after graduation): $OAK has graduated into its Uniswap v4 pool (phase == 2), but the pool has less than 30 minutes (1,800 seconds) of trade history. The note issuer refuses to sign (history_too_thin), and both plans wait (the curve floor is never used after graduation).
3. Ready (graduated and >= 30 minutes old): The note issuer signs price notes, the holder plan is open, and no-hold sign-ups and renewals follow the oracle. In Ready, if the oracle or price note fails, sign-ups and no-hold renewals fail closed and revert without consuming a nonce.

Two-leg price calculation and the 50% guard

• OAK/ETH leg (signed note): Because Pons V2 graduated pools use a fixed Uniswap v4 hook that records no on-chain TWAP observations, the Oak server's note issuer computes the ETH-volume-weighted mean of per-trade oakPerEthE18 over [now - 1800s, now), floor-rounded, and signs a signed 30-minute $OAK price note (PriceNote { wallet, oakPerEthE18, timestamp, nonce }). Each note has a 5-minute life (300 seconds), works once, and is bound to one wallet and one consuming contract. The issuer refuses to sign if the pool is younger than 1,800 seconds, has fewer than 10 trades in the window, has under $5,000 two-sided depth, or lies outside the guard band.
• ETH/USD leg (on-chain): ETH/USD is read on-chain by OakOracle.ethUsdE18() from the 30-minute average (observe([1800, 0])) of the ETH/USDG pool (0x52e65B17fB6E5BA00Ed806f37Afcd2DaA50271Ca).
• 50% guard: OakOracle enforces a 50% guard, rejecting any note whose oakPerEthE18 is not within 50% of the live pool price (spot / 2 <= note <= spot * 3 / 2, read live from PoolManager.extsload slot 6).
• Signer boundary: The price signer is the one always-on key in Oak: it is sign-only, holds no ETH, and is separate from the treasury owner key. The Treasury owner can replace the price signer (setPriceSigner), and setting the zero address pauses pricing. A dishonest or stolen signer alone is bounded to 0.5x to 1.5x of the spot-implied holder count.

---

4. The 25% / 75% Split and OakBurner

Every subscription payment splits in the same transaction on the full amount:

• 25% goes to the burn contract (OakBurner: burn = amount / 4, e.g., 2.25 USDG out of 9 USDG).
• 75% goes to the single-owner treasury wallet (treasury = amount - burn, e.g., 6.75 USDG out of 9 USDG).
• OakSubscription retains zero balance; a permissionless sweepToTreasury() forwards any USDG sent to it by mistake.

How OakBurner works

• Anyone can call permissionless buyAndBurn(usdgIn, note, sig) with a valid burner price note (wallet = address(0), for: "burner") fetched from POST /v1/price-note.
• Each chunk spends at most 0.5% of live pool liquidity along the fixed route USDG -> ETH -> $OAK and requires minOakOut at a price limit of at most note * 1.02 (never the live spot price).
• Purchased $OAK is destroyed in the same transaction via burn(uint256), reducing totalSupply().
• Armed 90-day sweep timer: The single-owner treasury wallet can sweep stuck USDG from OakBurner to the treasury only after a 90-day timer started by a public transaction (armSweep, which records armedAt and armedBalance). Any successful burn cancels the timer. Calling sweepStuck() after 90 days moves at most the balance recorded when the timer was armed (min(balance, armedBalance)), so later deposits require a fresh 90-day timer.

---

5. $OAK Trading Fees to the Single-Owner Treasury Wallet

• Every $OAK trade on Pons V2 pays a 2% fee: 0.3% to Pons and 1.7% creator fee (0.7% standard creator share + 1% creator tax set at launch; venue buybacks are off).
• All 1.7% goes to the single-owner treasury wallet, which is the Pons creator-fee recipient and claims positive ETH balances from the Pons fee escrow (0xd3AFEB2a57f70eF218Aa82451c51B2fb0416Ac9e) by owner-signed transaction.
• Pons keeper dependency: On graduated pools, launch-token-side fees reach the fee escrow only after Pons's own conversion keeper converts them to ETH (until then, sweepPoolFees reverts InternalSwapRequiresOperator(), so the treasury wallet skips the hook sweep and claims already-credited escrow balances).
• External Pons owner override: The external Pons owner (0x263ed295dAFaE1d9AAdD6E56c4B6F9f38eE019Dd) can propose replacing the creator-fee recipient subject to a 3-day public timelock that Oak cannot cancel.

---

6. Contract Lineage and Source-Bound Grandfathering

Oak contracts are non-upgradeable. If OakSubscription ever needs a fix:

1. The treasury wallet flips the one-way retire() switch on the old contract (stopping new sign-ups and renewals while preserving reads and cancel()) and deploys a successor whose immutable previous() points to the retired contract.
2. One record per wallet across the lineage: A wallet's authoritative record is on the newest contract in the lineage where hasRecord(wallet) is true.
3. Grandfather Merkle tree (OakGrandfather/v1): The treasury wallet posts a one-time grandfather root (default deadline: 120 days) built from finalized history, binding each eligible holder's (wallet, signupOakCount, sourceContract) using the wallet's recorded post-burn signupOakCount (for example, 19,000 after a 20,000 entry and 1,000 burn). When renewal is due, oak renew calls subscribeGrandfatheredWithAuthorization on the successor, carrying over live remaining paid time (paidUntil = max(now, source.paidUntil) + 30 days, within the 90-day cap) at that recorded signupOakCount with zero $OAK burn and no price note.