The Complete Manual.

STRC is a fair-launch token where every trade pays its holders in WBTC.

The model is simple: buy on a price curve, hold through graduation to Uniswap, then keep collecting a share of every swap for as long as you hold. There is no presale, no team allocation cliff, no hidden mint. All 1,000,000,000 tokens exist from block one.

Two flows put value in holders' pockets:

• WBTC dividends. Every swap on the live Uniswap v4 pool pays a 5% fee in ETH that the protocol periodically converts to WBTC and credits to all holders pro rata. Holders claim their share whenever they want.
• A self-strengthening LP. The standard 1% Uniswap LP fee gets recycled back into the pool's tight bucket on every harvest, so liquidity gets structurally deeper with every trade. Tokens become easier to sell over time, not harder. An AI-managed keeper extends this further by rebalancing the four dynamic LP buckets to follow price as the chart moves.

Hold the token, get a slice. Pull WBTC whenever, with no schedule, no vesting, no claim window. The supply cannot inflate. The locked LP cannot be withdrawn before its unlock date. The math runs onchain.

• One contract, one job. Each piece of the protocol — the token, the price curve, the dividend pool, the LP vault, the compound vault — is its own small contract with its own narrow purpose. There is no master contract that can flip everything. Nothing can be upgraded or rewritten after launch.
• The launch is automatic. Graduation happens the moment raiseTargetEth has been raised, not on a date a team picks. No countdown to game, no team button to push.
• Holders claim on their own schedule. Dividends pile up automatically. There is no requirement to be online when fees arrive: show up whenever, take a share.
• Liquidity stays inside the protocol. Once the Uniswap pool opens, the LP positions are sealed in a vault contract until a fixed unlock date. The protocol's AI-managed keeper can shift the four dynamic positions to a new tick range to follow price, but only within hard contract-level guardrails. The LP capital itself never leaves the locker.

  +-------------+   +-------------+   +-------------+   +-------------+
  |   PHASE 1   |   |   PHASE 2   |   |   PHASE 3   |   |   PHASE 4   |
  |    CURVE    |-->|  GRADUATE   |-->|   MIGRATE   |-->|   FOREVER   |
  |             |   |             |   |             |   |             |
  | bonding buy |   | raise hit + |   |  v4 pool +  |   |  trade on   |
  | + sell with |   |  curve      |   |  6 LPs +    |   |  Uniswap,   |
  | anti-snipe  |   |  closes     |   |  hook live  |   |  WBTC divs, |
  | window      |   |             |   |             |   |  AI-LP runs |
  +-------------+   +-------------+   +-------------+   +-------------+
    takes weeks      1 transaction     1 transaction       permanent

Phase 1 — The Curve. Trading opens on a bonding curve. Buyers transact directly with a smart contract: no order book, no MEV bots front-running entries. Each trade pays a fee back to the protocol (5% on buys, 10% on sells). The 5% buy fee splits 2% to the developer wallet (bootstrap funding for protocol expenses — RPC, infra, audits, keeper gas) and 3% to the dividend lane that pays holders in WBTC. The 10% sell fee splits 2% developer + 8% dividend, so flipping subsidizes long-holders. A decaying anti-snipe fee starts at 80% in the block after launch and walks down linearly to the 5% floor over the next 300 blocks (~1 hour at 12s/block). During the decay window the developer slice is zeroed and all decay-window fees route to holders via the dividend lane. During that window each non-exempt wallet can spend at most 2% of raiseTargetEth per buy, forcing snipers to fragment across many wallets.

Phase 2 — Graduation. The instant the curve's raiseTargetEth has been hit, the curve closes itself and migration kicks off, all inside the same transaction as the buy that crossed the line. No pause, no team button, no countdown.

Phase 3 — Migration. The remaining tokens and raised ETH move out of the curve, a Uniswap v4 pool opens at the same price the curve closed at (no dump), and six concentrated LP positions are minted: four dynamic locker bands (tight / narrow / medium / wide) plus a 2-NFT compound vault (a centered band and a single-sided STRC tail). The four locker NFTs are sealed in a vault; the two compound-vault NFTs are owned by the auto-compounder. Start to finish: one transaction.

Phase 4 — Forever. Trading continues on Uniswap. Every swap pays 5% to the dividend lane through the protocol's hook (paid out in WBTC after a periodic conversion), plus a 1% LP fee split 50/50 between the developer wallet and the compound vault. An AI-managed keeper continuously rebalances the four dynamic locker bands and the compound vault's two NFTs to follow price as the chart moves. Holders claim their WBTC whenever they want, and the LP gets structurally deeper with every trade.

The curve uses the same constant-product math any AMM uses: when more people buy, the price goes up.

The clever part is how the curve starts. A brand-new pool with zero liquidity would have an undefined price. The first buyer would either pay infinity or get free tokens. Neither works. So instead of seeding the pool with real ETH (which would require somebody to put money in upfront), the curve pretends there is already virtualEth ETH and virtualToken STRC sitting inside it. Phantom liquidity. None of it actually exists. Both numbers are deploy-time constants — the live values for this token render in the HUD next to the curve.

The phantom liquidity is just there to set a sensible starting price. As real buyers come in with real ETH, the price moves up the same way it would on any AMM. The phantom numbers stay frozen: they never grow, they never get withdrawn.

Starting state

What the price actually does

Earlier buyers get more STRC per ETH than later buyers. This is a real bonding curve, not a batch auction or pro-rata sale. Each individual buy moves the price up the curve in the same transaction it lands in, and the next buy starts from that new price. There is no "everyone settles at the final price" mechanic. If the curve never reaches raiseTargetEth, it just stays open — there is no settlement, no refund pool, no pro-rata sweep.

Concretely:

So the buyer who puts in 1 ETH at the start walks away with about 4× more STRC than the buyer who puts in 1 ETH at the end. That difference is the bonding curve doing its job: it auctions the supply by demand, in real time, in price order.

The Uniswap pool opens at the same price the curve closed at — so the last buyer on the curve is not getting dumped on at migration. It is the same number going one block past graduation.

About 600 million STRC (60% of total supply) will have been sold by graduation. The remaining ~400 million plus the raised ETH get deployed as Uniswap liquidity (see how graduation works).

What "fair-launch" means here. It does not mean every buyer pays the same price (they don't — see above). It means there is no presale, no insider allocation, no team cliff, and no whitelist. The entire supply funds the curve, every buyer transacts on the same public contract under the same anti-snipe rules, and by graduation real holders own 60% of the float. The other 40% gets locked into Uniswap liquidity that nobody can pull.

While the curve is open

Curve fees route in the same transaction the trade lands in. The developer slice funds protocol expenses (RPC, infra, audits, keeper gas, dividend conversion gas). The dividend portion gets queued for the periodic ETH→WBTC conversion that pays holders. During the 300-block anti-snipe window the developer slice is zeroed and the entire decaying fee routes to holders. Curve fees are hard-capped at 10% per side onchain. That ceiling cannot be lifted post-launch.

After graduation, on the Uniswap v4 pool

Every swap on the live pool pays two fees that together total 6%, and both work for holders:

The hook is the unfair advantage. Because the protocol ships its own Uniswap v4 hook, it can take 5% of the ETH side of every swap and route it to the dividend lane in the same transaction the trade settles. The hook contract is immutable: the dividend lane address is hard-wired at deploy and can never be changed.

The LP grows itself. The standard 1% LP fee gets recycled back into the pool as fresh tight-bucket liquidity. Every swap permanently makes the chart deeper for the next swap.

Why WBTC and not ETH? BTC is the only crypto asset most holders want as long-term yield. By converting the dividend stream from ETH to WBTC at the protocol layer, holders accumulate sats automatically just by holding STRC.

  the buy that crosses raiseTargetEth
              |
              v
  +------------------------------+
  | 1. curve marks itself closed |
  +------------------------------+
              |
              v
  +------------------------------+
  | 2. tokens + ETH leave curve  |
  +------------------------------+
              |
              v
  +------------------------------+
  | 3. v4 pool opens at          |
  |    same price (no dump)      |
  +------------------------------+
              |
              v
  +------------------------------+
  | 4. mint 6 LP positions       |
  |    (4 locker + 2 vault)      |
  +------------------------------+
              |
              v
  +------------------------------+
  | 5. lock 4 locker NFTs        |
  |    in the vault timelock     |
  +------------------------------+
              |
              v
  +------------------------------+
  | 6. fee hook activates        |
  +------------------------------+
              |
              v
        all in 1 block

Most token launches die at the migration step. A team's multisig clicks something, the price gaps down 50%, the LP gets pulled, holders rage-quit. STRC has none of those failure modes because nobody touches the migration. The same transaction that crosses the raiseTargetEth line does everything:

1. The curve marks itself closed and stops accepting trades.
2. The remaining tokens and raised ETH move out of the curve.
3. A fresh Uniswap pool opens at the same price the curve was at.
4. Six concentrated LP positions get minted: four locker bands plus two compound-vault NFTs.
5. The four locker NFTs are sealed in the timelocked vault. The two vault NFTs land directly in the auto-compounder.
6. The fee hook activates. Every swap from this moment on feeds the WBTC dividend lane.

Total time: one block. Total human involvement: zero.

The 6-position LP layout

Most bonding-curve launches dump their entire LP into a single position at graduation. STRC instead deploys liquidity across six concentrated positions, sized for where price actually trades. The four locker positions hold the working trading surface; the two vault positions hold a wide passive bed plus a single-sided STRC tail that grows the vault every time price walks.

The four locker positions are dynamic — the keeper moves them with price. The two vault positions are also dynamic (the keeper rebalances both NFTs); together they form a 2-NFT compound-vault structure that grows with every swap. There are no frozen positions: the previous design's three specialty bands (pump_floor / pump_rocket / dump_abyss) were retired after empirical evidence showed real memecoin moves blow past any predetermined offset in minutes.

Migration only happens once

The protocol checks two onchain flags before doing anything migration-related. Once migration runs successfully, both flags flip to "done" and stay there forever. A second attempt instantly reverts. The curve is permanently closed: no buys, no sells, no rerun.

If a whale crosses the line

If a single buy is large enough to overshoot raiseTargetEth, the curve clips the buy to the exact graduation gap and refunds the surplus ETH to the recipient in the same transaction. The buyer never overpays past the threshold. The buy fills the curve to exactly raiseTargetEth, migration fires immediately, and the unused ETH lands back in the buyer's wallet — no excess gets stranded in the curve, no owner sweep needed.

STRC could not exist on Uniswap v3. Not because of math, not because of gas, but because of enforcement. Every economic property the protocol promises — the 5% fee that funds WBTC dividends, the locked LP, the auto-compounding vault, the MEV defense, the AI-LP keeper economy — depends on one mechanism: the hook.

Uniswap v3 is a public road with a "please pay toll" sign. You can ask drivers to stop and pay. Some will. Most won't. Aggregators like 1inch or 0x scan pools, find the cheapest route, and call pool.swap() directly. Your wrapper never runs. The user gets a better price by going around your contract — so your "official" route becomes the worst route, and nobody uses it. Your tax becomes vestigial the moment an aggregator indexes the pool.

Uniswap v4 with a hook is a tollgate built into the ground. A hook is a contract registered against the pool at creation time. The PoolManager always calls the hook's beforeSwap and afterSwap functions on every trade against that pool. The aggregator can't skip it — it doesn't own the PoolManager. The hook fee is part of the swap output the aggregator quotes to its user. Every car pays — the aggregator, the MEV bot, the user clicking the frontend, the raw script calling the pool from the command line. There is no detour, because the gate is the road.

What that hook can do, on every single swap, automatically:

• Charge a custom fee in either token, on top of the LP fee
• Reject the swap entirely
• Mutate the swap delta — return tokens, take extra
• Trigger external state changes — push dividends, ratchet locker fees, mint compound positions, pay keeper bounties
• Read or write its own state on every swap (per-trader, per-block, per-origin)

None of this is optional for the trader. There is no "skip the hook" mode. If you trade STRC on the v4 pool, the hook runs. Period.

What STRC uses hooks for

MEV defense built into the swap path

Most tokens fight MEV after the fact — they watch a block explorer, identify sandwichers, and complain on Twitter. STRC fights MEV during the swap, because the hook runs inside the trade itself and can see who is calling it. The defense is layered:

• Anti-snipe decay (Layer 0). A base fee on early post-graduation buys that decays toward zero as the pool ages. Block-number indexed, not opt-in. Funds dividends instead of going to the sniper.
• Per-origin same-block flip detection (Layer 2). The hook keeps a packed-slot record of tx.origin + last-block-buy. If the same origin flips BUY→SELL inside the same block — the textbook sandwich pattern — the hook adds a +300 bps surcharge on the sell side. Sandwichers either eat the cost or skip STRC entirely. Either outcome is a win for holders.
• Real-block-only writes. The state update is gated so reorgs don't corrupt the per-origin tracker, and the storage is one packed slot per origin (block# + last-action flag) so the gas overhead is a few hundred gas per swap, not a meaningful tax on regular traders.

This defense is impossible without hooks. v3 has no way to read tx.origin mid-swap and apply a surcharge — your only option is a token blacklist, which breaks composability across every other DEX. The hook keeps STRC fully composable while still punishing the specific patterns that hurt holders.

AI-LP management — the keeper economy hooks make possible

The AI-LP keeper is what keeps STRC's liquidity tight to price as the market moves. It works because the hook funds it:

• The hook is the revenue source. Every swap routes a 5% fee through the hook to the locker. The locker accumulates ETH + STRC fees on the four dynamic LP positions in real time.
• The locker pays a rebalance bounty. When the keeper repositions a locker NFT to follow price, the locker emits RebalanceBountyPaid and sends a small slice of accumulated fees to whoever submitted the rebalance tx. This is permissionless — anyone can be the keeper, and the protocol pays the gas back.
• The compound vault is hook-fed too. Two of the six LP positions live in the auto-compounder. Their fee earnings get reinvested into deeper LP every time price walks past them. None of this works without the hook routing fees in the first place.

The pattern: hook collects fees → locker holds fees → bounty pays keeper → keeper rebalances → repeat. The keeper doesn't need to be the team. It doesn't need to be online. The protocol is paying real on-chain bounties to whoever brings the next rebalance, and those bounties exist because hooks captured the swap fees in the first place. On v3, this loop has no economic engine.

Composability without bypass

v4 introduces a singleton PoolManager and flash accounting — every pool lives in one contract, and token settlements net out at the end of a transaction instead of moving on every hop. A hook can do complex multi-pool work atomically: swap on another pool inside its own callback, route part of the proceeds to a treasury, and settle everything in one final balance. For STRC, this is what lets the fee router accumulate ETH from every swap, batch it, swap it to WBTC on the same v4 PoolManager, and push it to the dividend tracker — all triggerable in a single keeper call, no off-chain coordination, no token bridges, no settlement risk.

The bottom line

Hooks are the difference between "our token has a 5% dividend if you use our website" and "our token has a 5% dividend, full stop." The first is marketing. The second is a property of the asset. Every promise STRC makes — locked LP, auto-compounding, WBTC dividends every swap, anti-snipe protection, MEV defense, permissionless AI-LP rebalancing — is enforced at the pool level by a hook the trader cannot route around. That is why STRC is built on v4 and not v3, and why the protocol is enforceable instead of optional.

A "keeper" in DeFi is a small piece of automation — a bot, a script, a server somewhere — that performs protocol-critical work on a schedule the protocol itself can't enforce. Smart contracts have no clock and no agency. An EVM contract is a state machine that only changes state when somebody pays gas to call it. If your protocol depends on something happening at a specific time — a liquidation, a rebalance, a harvest, a price update, a fee compounding — the only thing that makes it happen is a keeper.

Where keepers came from

• MakerDAO (2017–2018). Maker was the first major protocol to formalize keepers. Its CDP system needed someone to liquidate undercollateralized vaults the moment they crossed the threshold and someone to participate in collateral auctions when liquidations fired. Maker shipped reference keeper code and paid those bots in penalty fees. The role was defined here: rational, profit-seeking agents whose private incentive aligns with the protocol's public health.
• Yearn Finance (early 2020). When Andre Cronje launched Yearn, every vault strategy needed a periodic harvest() call to compound earned yield. The team built off-chain keepers to call those functions on a cron — and noticed that bundling this work was a real engineering problem with no good general solution.
• Keep3r Network (October 2020). Andre Cronje's answer was Keep3r — a decentralized registry where any protocol could list a "job" (a function needing periodic calling), any keeper could register and bid for jobs, and KP3R tokens rewarded the work. It was the first attempt to turn keeping into a public-utility infrastructure layer instead of every protocol building its own bot army. Cronje is widely credited with generalizing and popularizing the keeper pattern through Yearn and Keep3r, even though MakerDAO had keepers before him.
• Today. Keepers are everywhere. Chainlink Automation (originally Chainlink Keepers), Gelato Network, OpenZeppelin Defender Autotasks, and protocol-specific bot networks all run on the same fundamental pattern Maker and Cronje pioneered: protocol pays a bounty, anyone can claim it, the work gets done.

Why keepers are critical infrastructure

Without keepers, MakerDAO has no liquidations and bad debt insolvency-spirals every time ETH dumps. Yearn vaults never compound. Chainlink price feeds don't tick. Lending markets go stale. STRC's liquidity freezes — the chart moves and the LP stays where it was at graduation, becoming useless. Keepers are the heartbeat of every DeFi protocol that does anything time-sensitive. They are unglamorous, easy to overlook, and absolutely load-bearing.

STRC's keeper architecture

                  +------------------------+
                  |  Claude Opus 4.7       |   the brain
                  |  (off-chain advisor)   |   (paid by ops wallet)
                  +-----------+------------+
                              |
                              | rebalance plan (json)
                              v
   +---------------------------------------------------+
   |               STRC keeper fleet                   |
   |   permissionless · paid in ETH · runs on cron     |
   +-+----------+----------+----------+----------+-----+
     |          |          |          |          |
     v          v          v          v          v
  +-------+ +--------+ +--------+ +--------+ +--------+
  | LP-AI | | locker | | vault  | |  fee   | |  WSS   |
  |  loop | |harvest | |compound| | router | |mempool |
  +---+---+ +---+----+ +----+---+ +----+---+ +----+---+
      |         |           |          |          |
      v         v           v          v          v
  rebalance  harvest    harvest+    distribute  watch
  Locked()    ()       Compound()   Eth/Token   pending
                                                tx
      \         |          |          |         /
       \        |          |          |        /
        \       v          v          v       /
         \  +-----------------------------+  /
          \ |   LOCKER  /  COMPOUND VAULT | /
           \| / FEE ROUTER / DIV TRACKER  |/
            +--------------+--------------+
                           |
            three lanes split every harvest:
                           |
        +------------------+--------------------+
        |                  |                    |
        v                  v                    v
   +----------+      +----------+        +-------------+
   | compound |      |   div    |        | ops wallet  |
   | vault    |      | tracker  |        | (infra + AI |
   | (deeper  |      | (holders |        | + keeper    |
   |  LP)     |      |  paid in |        |  gas)       |
   |          |      |  WBTC)   |        +-------------+
   +----------+      +----------+         pays Railway,
                                          Vercel, RPC,
                                          Supabase, +
                                          Claude API
                          ^
                          |
                          | bounty payout (separate, per-call)
                          |
                  +---------------+
                  |   keeper EOA  |   gets paid in ETH
                  +---------------+   per successful tx

All keepers in STRC share the same shape: protocol pays the bounty, contract reverts if the call is unsafe, anyone can be the keeper. The team runs a default fleet on Railway so the network is always alive, but every contract method below is callable by any wallet that wants the bounty.

STRC ships five distinct keepers. Each handles one job, each is permissionless, each is paid by the contract it serves.

1. The AI-LP rebalance keeper

  Claude Opus 4.7  --plan-->  lp-ai-loop.mjs  --tx-->  Locker.rebalanceLocked(plan)
                                       |                        |
                                       |                        +-- emits RebalanceBountyPaid
                                       +-- private mempool       +-- pays keeper EOA in ETH
                                           (Flashbots-style)

What it does. The flagship keeper. Watches the pool every block, pulls a fresh rebalance plan from Claude, and submits it to V4PositionLocker.rebalanceLocked(). The locker re-positions one of the four dynamic LP NFTs (tight / narrow / medium / wide) so depth follows price. On success, the locker pays the keeper a small bounty in ETH and emits RebalanceBountyPaid.

Where it runs. scripts/keeper/lp-ai-loop.mjs on Railway, periodic loop. Plans are submitted through private-call.mjs which routes through a Flashbots-style private mempool to avoid front-running.

Failure mode. If the plan would violate any locker guardrail (cooldown not elapsed, drift below threshold, range outside policy bounds), the contract reverts and the keeper eats gas. Built-in incentive against bad plans.

2. The WSS mempool keeper

  WSS pending-tx feed --> wss-keeper.mjs --> Locker.rebalance(...)
                                |
                                +-- fast-fire when a large swap is detected
                                +-- pre-positions LP a tick ahead of impact

What it does. A faster sibling to the AI-LP loop. Subscribes to a WebSocket feed of pending transactions and triggers an immediate rebalance the instant it detects a large incoming swap that would push price out of the tight range. By the time the swap lands, depth has already moved.

Where it runs. scripts/keeper/wss-keeper.mjs, also on Railway. Coordinates with the AI-LP loop via a per-tokenId mutex so they don't double-fire on the same NFT in the same block.

Why it's separate. The AI loop optimizes for good; the WSS keeper optimizes for fast. Together they cover both regimes — patient repositioning on quiet markets, instant defense on incoming volume.

3. The compound auto-compound keeper

  cron tick --> run-strc-ops.mjs --> Locker.harvestAndCompound()
                                              |
                                              +-- collects fees on locker NFTs
                                              +-- mints those fees as new LP
                                              +-- pays keeper a bounty

What it does. Periodically calls V4PositionLocker.harvestAndCompound(). The locker collects fees accrued on the four dynamic LP NFTs, splits them per the configured BPS — operations wallet (which sustains keeper gas, Railway / Vercel infra, Supabase, RPC, and the Claude AI inference cost), dividend lane, and compound — then mints the compound slice as fresh liquidity directly into the compound-vault NFTs. The pool gets deeper without anyone adding new capital.

Where it runs. Same Railway host, called from run-strc-ops.mjs on a cooldown timer (compoundCooldownSec). Bounty pays the gas back.

What you see on chain. A HarvestAndCompound event with the breakdown of how much was harvested and how much got compounded.

4. The locker fee-harvest keeper

  cron tick --> run-strc-ops.mjs --> Locker.harvest()
                                              |
                                              +-- collects fees only (no compound)
                                              +-- routes to ops wallet + fee router + compound
                                                  (ops wallet = infra + AI cost)

What it does. The simpler sibling of harvestAndCompound. Calls V4PositionLocker.harvest(), which sweeps fees from the locker NFTs and pushes them to their three destinations — the operations wallet (covers keeper gas, Railway, Vercel, Supabase, RPC, Claude AI inference), the fee router (dividends to holders), and the compound vault — without minting new LP. Used when the operator wants to top up dividends faster than the compound cooldown allows.

Why the ops wallet exists. The protocol runs autonomous infrastructure: a Railway-hosted keeper fleet, Supabase database for plan history and metrics, Vercel-hosted dashboard, paid RPC, and on-demand inference from the Claude API for every rebalance plan. None of this is free. The ops wallet receives a small fixed BPS of every harvest so the system pays for itself indefinitely, instead of relying on the team to subsidize it out of pocket. It is a sustainability fee, not a personal yield stream.

Where it runs. run-strc-ops.mjs, on its own schedule.

5. The dividend distribution keeper

  cron tick --> run-strc-ops.mjs --> FeeRouter.distributeEth()
                                              |
                                              +-- ETH balance --> WBTC swap (v4 PM)
                                              +-- WBTC --> DividendTracker.distribute()
                                              |
                                          --> FeeRouter.distributeToken()
                                              |
                                              +-- residual STRC --> swap to WBTC
                                              +-- push to tracker

What it does. The closing keeper in the loop. Calls STRCEthFeeRouter.distributeEth() (and distributeToken() for any STRC residual). Inside, the router swaps the accumulated balance to WBTC on the same v4 PoolManager and pushes the WBTC into the STRCDividendTracker. Holders then pull-claim whenever they want — minimum claim is 0.001 WBTC.

Where it runs. Same orchestrator. Triggers when accumulated ETH crosses the configured floor or on a fixed cron, whichever fires first.

What you see on chain. EthDistributed, TokenDistributed, and (downstream) DividendsDistributed from the tracker.

The combined picture

                       trade fills
                            |
                            v
                   +-----------------+
                   |  v4 hook (5%)   |
                   +--------+--------+
                            |
                            v
              +---------+   |   +-----------+
              | LP-AI   |<--+-->|   WSS     |   keepers 1 & 2
              | loop    |       |  keeper   |   reposition LP
              +----+----+       +-----+-----+
                   |                  |
                   +----+   +---------+
                        v   v
                +-----------------+
                |     LOCKER      |
                +--------+--------+
                         |
                         | fees accrued
                         v
              +---------+----------+--------------+
              |                    |              |
              v                    v              v
        +----------+         +----------+   +-------------+
        |compound  |   3     |fee router|   |  ops wallet |
        | vault    |<--------+          |   |  infra+AI   |
        |(grows LP)|         +-----+----+   |  + keeper   |
        +----------+               |        |    gas      |
              ^                    |  4&5   +-------------+
              |  harvestAnd-       |        sustains
              |  Compound (3)      v        Railway,
              |              +----------+   Vercel,
              +--------------+   DIV    |   Supabase,
                             | TRACKER  |   RPC, Claude
                             +----+-----+   inference
                                  |
                                  v
                             holders pull
                             WBTC dividends

Five keepers, one consistent contract: protocol pays the work, anyone can do it, the system reverts if you propose something unsafe. Three lanes carry the proceeds — compound deepens the chart, dividends pay holders, and the ops wallet covers infrastructure and AI inference so the system pays for itself indefinitely. The AI is the brain. The hooks are the enforcement. The keepers are the muscles that make the system move, and the ops lane is the metabolism that keeps them fed.

  every swap pays 5% in ETH
              |
              v
  +-------------------------------+
  |   FEE ROUTER                  |
  |   batches ETH                 |
  +-------------------------------+
              |
              v   batch >= 1 ETH triggers swap
  +-------------------------------+
  |   ETH -> WBTC                 |
  +-------------------------------+
              |
              v   ~79.9% of WBTC flows here (4% of swap volume)
  +-------------------------------+
  |   DIVIDEND TRACKER            |
  |                               |
  |   one shared cumulative-index |
  |   walks up automatically;     |
  |   each holder's unclaimed     |
  |   share grows in the gap      |
  +-------------------------------+
              |
              v   when the holder calls claim()
  +-------------------------------+
  |   HOLDER WALLET (WBTC)        |
  +-------------------------------+

A holder's slice of every fee waits for them onchain until they decide to claim it. That is the entire mechanic.

How it works behind the scenes

Paying thousands of holders individually would be prohibitively expensive in gas. STRC instead uses a single shared counter that goes up every time fees come in. Each holder's share is calculated on the fly at claim time, based on how many tokens they have held and how much the counter has moved while they held them. The contract never has to walk through every holder. The pattern is the same one MasterChef-style staking pools use, applied to passive token holders.

What this means in practice

• Holders can be offline. Show up an hour later, a week later, a month later: the share has been accruing the whole time.
• STRC balance does not change when fees come in. Dividends are paid in WBTC. The protocol collects 5% of swaps in ETH, batches them, and a permissionless conversion swaps the batch to WBTC. STRC holdings are completely separate.
• Transfers preserve earned dividends. When STRC is sent to another wallet, the protocol settles the sender's earned-but-unclaimed share before the transfer goes through. That share remains claimable even after the STRC has moved.
• Selling cashes out unclaimed dividends too. The same settlement applies to sales. Unclaimed dividends are not lost on exit.

What does not earn dividends

Protocol infrastructure (the curve, the Uniswap pool, the locker, the migrator) holds STRC for plumbing reasons but earns zero dividends. Those addresses are flagged "excluded" so a holder's share is not diluted by tokens the system itself is holding.

Minimum claim

Claims are gated at 0.001 WBTC (~$80 at current BTC price). Below that threshold, the gas to claim would exceed the value being claimed. The contract waits until the dividend balance is worth more than the gas to send it.

STRC's dividend lane is denominated in WBTC, but the protocol collects fees in ETH (curve trades, hook swaps). The hand-off between those two facts is a contract called STRCEthFeeRouter. Every ETH-denominated dividend cut is sent there first; the router accumulates ETH and is converted to WBTC in batches by anyone who wants to.

  +--------------------------------------------------------+
  |   TRADE FEE (ETH)          every swap pays 5%          |
  |                            via the hook                |
  +--------------------+-----------------------------------+
                       |
                       v
  +--------------------------------------------------------+
  |   FEE ROUTER               holds ETH until balance     |
  |   (piggy bank)             >= 1 ETH AND cooldown ok    |
  +--------------------+-----------------------------------+
                       |
                       v   anyone calls swapAndDistribute
  +--------------------------------------------------------+
  |   swap ETH -> WBTC         through an allow-listed     |
  |                            Uniswap pool                |
  +--------------------+-----------------------------------+
                       |
                       v   splits the WBTC three ways:
  +--------------------------------------------------------+
  |   ~0.1%   caller           gas reimbursement (tip)     |
  |    20%    developer        1% of swap volume → ops     |
  |   ~79.9%  TRACKER          4% of swap volume → holders |
  +--------------------------------------------------------+

Why a router instead of swapping per trade

Swapping per trade would burn gas on every single buy/sell/swap that happens on STRC, and the slippage on tiny ETH→WBTC trades would eat the dividend itself. Batching turns a thousand small swaps into one decent-sized swap that gets near-spot pricing. The router is the buffer.

The permissionless trigger

Anyone can call swapAndDistribute on the router. There is no privileged keeper. The function checks two gates: the router has accumulated past minSwapThreshold ETH, and the cooldown (minSwapInterval + a random jitter window) since the last swap has elapsed. If both pass, the call proceeds.

What the call does

1. Swaps the router's ETH balance through an allow-listed swap target (a UniV3 ETH/WBTC pool adapter on mainnet; a mock swapper on testnet) into WBTC.
2. Pays the caller a small bounty in WBTC (callerBountyBps, on the order of ~0.1%) as gas reimbursement.
3. Pays the protocol's developer wallet a fixed cut (opsBps, ~10%) for ongoing infrastructure costs (RPCs, indexers, AI inference).
4. Sends 20% of the WBTC (= 1% of the underlying swap volume) to the developer wallet as protocol-bootstrap funding (RPCs, indexers, AI inference, audits, ongoing infra).
5. Deposits the rest (~79.9% of WBTC, = 4% of swap volume) into the dividend tracker, where every holder's share immediately starts earning against it.

Why the cooldown has random jitter

If the cooldown were a fixed interval, an MEV bot could pre-compute the exact block when the next call becomes valid and front-run every legitimate caller. The jitter window adds an unpredictable extra delay so the actual unlock time is in a band, not a point. Bots that try to land at the earliest possible block will revert with TOO_SOON; the bounty goes to whoever calls during the valid window.

Where you see this

The /lp-monitor page exposes a Distribute dividends button that calls swapAndDistribute from the connected wallet. Anyone reading these docs with a wallet and gas can collect the caller bounty.

  every Uniswap swap pays 1% LP fee (accrues in the locked positions)
              |
              v
  +-------------------------------+
  |   LOCKER                      |
  |   (locked LP NFTs)            |
  +-------------------------------+
              |
              v   anyone calls harvest (permissionless)
  +-------------------------------+
  |   strip fees only             |
  |   principal stays put         |
  +-------------------------------+
              |
              v   split:
  +-------------------------------+
  |  small bounty  -> caller      |
  |  ops slice     -> dev wallet  |
  |  remainder     -> mint LP     |
  +-------------------------------+
                                  |
                                  v
              +----------------------------------+
              |   COMPOUND VAULT                 |
              |   fresh tight-bucket NFT lands   |
              |   here (separate from launch LP) |
              +----------------------------------+
                                  |
                                  v
                        chart gets deeper
                        for the next swap

The 1% LP fee that Uniswap v4 collects on every swap gets re-minted right back into the tight bucket of the LP, automatically, on a schedule, forever. The chart gets structurally deeper for the next swap, every swap.

How it works

1. Every swap on the live pool pays the standard 1% LP fee, which accrues inside the locked positions.
2. A permissionless harvest function on the locker can be called by anyone, including MEV bots watching the pool. The function decodes its own calldata onchain to enforce that only fees are collected, never principal.
3. The accumulated fees are pulled out, the caller takes a small bounty in both ETH and STRC for the gas, a fixed cut goes to the operations wallet, and the remainder mints a fresh tight-bucket position centered at the current price.
4. The new LP NFT is sent to a dedicated compound vault, separate from the timelocked principal so the compounded layer can be rebalanced as the chart moves without ever touching the locked launch LP.

Because the harvest is permissionless, the loop keeps running even if the protocol's keeper goes offline. Anyone watching the pool can call it for the bounty.

The two-vault model

The four locker LP positions stay locked in the position locker until a fixed unlock timestamp. Before that timestamp, no party can withdraw the principal. The protocol's AI-managed keeper rebalances all four locker positions in place — the LP capital never leaves the locker.

The compound vault holds two NFTs of its own (a centered band and a single-sided STRC tail) plus all auto-compounded LP positions minted from harvested fees. Both layers are rebalanceable by the AI-LP keeper, with the compound vault running on looser constraints than the locker since it holds growth fees plus a passive backstop rather than launch principal.

• The locked principal is non-negotiable. Nobody can pull it before the unlock. Even rebalances cannot exfiltrate capital: the vault validates that any new minted NFT lands back in the locker.
• The compounded layer is flexible. Markets evolve, and a tight bucket at the launch tick eventually drifts as the chart moves. The compound vault's positions can be rebalanced freely within their guardrails to keep liquidity active.

Both vaults accept NFTs only from the canonical Uniswap v4 PositionManager. Every action on either vault is fully visible onchain.

What this means for holders

Holders see the pool get deeper every time someone trades. Tokens become structurally easier to sell, the chart becomes harder to wick, and the WBTC dividends keep flowing from the 5% hook fee on top, which is a completely separate income lane from the LP-deepening flow.

A static LP at launch eventually becomes dead weight. As price moves out of the original range, the position stops earning fees, stops absorbing volume, and creates a slippage wall that new buyers run into on every entry. Most memecoin launches accept this as the price of having locked liquidity at all.

STRC's AI-LP layer does not. An autonomous keeper, advised by Claude Opus 4.7, watches the pool continuously and proposes range adjustments as price moves. Approved plans execute through a private mempool. All four locker positions and both compound-vault NFTs stay centered where trading is actually happening, so the depth follows the chart instead of getting stranded behind it.

What this changes for the protocol

• The chart can run further before slippage becomes a tax. When liquidity tracks price, every dollar of new buy pressure gets matched by depth at the new level. Price action is smoother, and large entries don't immediately blow out the chart.
• The pool earns fees the whole time. Static LP positions earn zero fees once they go out of range. Active positions earn the full fee tier on every swap, no matter what level price is trading at.
• Those fees feed back in. Captured fees flow to dividends (paid out as WBTC) and to compound (more LP minted into the pool). Every trade during a run pays holders and deepens the pool simultaneously.

The AI-LP loop runs on a fixed cadence. Each cycle goes through five steps:

  +--------------------------------------------------------+
  |   POOL SNAPSHOT            current tick                |
  |                            6 LP NFTs                   |
  |                            recent swaps + volume       |
  +--------------------+-----------------------------------+
                       |
                       v
  +--------------------------------------------------------+
  |   CLAUDE OPUS 4.7          proposes which NFT to burn  |
  |   writes a plan            + tick range to mint at     |
  +--------------------+-----------------------------------+
                       |   JSON plan
                       v
  +--------------------------------------------------------+
  |   GUARDRAIL                no swaps, widths in band,   |
  |   contract checks          center <= launchTick, etc.  |
  +--------------------+-----------------------------------+
                       |   approved
                       v
  +--------------------------------------------------------+
  |   SIMULATE                 dry-run on a chain fork --  |
  |   chain fork               skip if it would revert     |
  +--------------------+-----------------------------------+
                       |   clean
                       v
  +--------------------------------------------------------+
  |   PRIVATE MEMPOOL          submit through Flashbots so |
  |   submit                   MEV can't sandwich it       |
  +--------------------+-----------------------------------+
                       |
                       v
                 pool rebalances
                 (loops every 5 minutes)

1. Snapshot. The protocol reads the current pool tick, the held LP positions, recent volatility, recent swap activity, and the fee router's pending balance. All of this becomes a structured input the AI consumes.
2. Plan. Claude Opus 4.7 receives the snapshot and writes a structured rebalance plan: which positions to burn, what new ranges to mint at, how much slippage to tolerate, why. Every plan comes with a plain-English explanation of the reasoning.
3. Guardrail. A deterministic safety layer checks every plan against the protocol's rules. No swaps, range widths within bounds, locker centers within ratchet limits, slippage caps within policy, and so on. Plans that fail any check are rejected outright.
4. Simulate. Approved plans run through a transaction-level simulation against the live chain state before submission. Any plan that would revert at execution gets dropped here, before paying for inclusion.
5. Submit. Plans that pass simulation are signed and broadcast through a private mempool, so the rebalance transaction itself cannot be sandwiched or front-run.

The AI does not sign transactions or hold funds. It is an advisor whose output is a structured plan. The keeper account signs, the guardrail validates, the simulation confirms. If any layer rejects the plan, the cycle ends with no action and the next snapshot triggers a fresh evaluation.

   STRC price (low <-------------------------------> high)

   ----+----------+--------------+--------------+----------+----
       |          |              |              |          |
     -50%       launch          +5x           +50x        +400x
                  ^
                  |
                  +-- LAUNCH TICK (frozen at migration)
                          rebalances must center HERE or ABOVE

   ALLOWED (can ratchet up):
                  +-------+    +-------+    +-------+
                  | dyn   |--->|       |--->|       |    higher
                  +-------+    +-------+    +-------+

   BLOCKED (re-anchor below launch reverts onchain):
   +-------+
   |  no   |  X
   +-------+

The locker stores an immutable launch tick: the exact pool tick at the moment the curve graduated and the Uniswap pool opened. The keeper can rebalance the four dynamic launch positions, but every new range must center at or above launch price.

This is a one-way design choice. If the protocol succeeds and price runs above launch, the dynamic positions follow price upward to keep liquidity active near the new trading range. If the project fails and price drops below launch, the dynamic positions stay where they last ratcheted to. The protocol does not waste gas re-anchoring liquidity into a death spiral.

What the ratchet enforces at the contract level

• The launch tick is set once, after migration, and can never be changed.
• Every locker rebalance reads the current pool tick from the canonical V4 StateView and verifies the new range center against both the launch tick and a configurable per-rebalance drift cap.
• The new range width is bounded between 120 and 60,000 ticks: too narrow and the position gets rebalanced out within minutes, too wide and the position earns negligible fees.
• Each dynamic NFT has a per-position cooldown, so even an authorized keeper cannot churn a position to extract MEV on every block.

Because the ratchet is enforced inside the locker contract, no off-chain bug or compromised keeper key can rebalance liquidity into sub-launch territory.

Six LP positions go into the pool at migration. All six are dynamic: the AI keeper shifts every one of them to follow price. The previous design's frozen specialty bands (pump_floor, pump_rocket, dump_abyss) were retired after empirical evidence showed real memecoin moves blow past any predetermined offset in minutes — frozen tail liquidity got eaten in the first round and offered zero coverage for the rest of the walk.

Lined up by price (low STRC value on the left, high STRC value on the right):

                       launchTick
                            |
                            v
  +-------------+   +-----+-----+-----+-----+   +-------------+
  | VAULT TAIL  |   |tight|narr | med |wide |   | VAULT       |
  | STRC-only   |   |     |     |     |     |   | CENTERED    |
  | absorbs     |   | <-- 4 locker --->     |   | wide passive|
  | leftover    |   |     dynamic           |   | ±277% range |
  +-------------+   +-----+-----+-----+-----+   +-------------+
        |                       |                       |
        +-------- both vault NFTs owned by the compound vault
                  (rebalanced by the keeper alongside the locker)

  <-- lower STRC price                              higher STRC price -->

The four locker positions hold the working trading surface, all dynamically rebalanced:

• tight — narrow band right around the trading price. Earns the most fees, gets rebalanced most often.
• narrow — slightly wider band. Less rebalancing, still meaningful fee capture.
• medium — broader coverage of the trading range.
• wide — broad window that stays in range across most price moves.

The two compound-vault positions act together as a passive backstop plus a tail catcher:

• vault_centered — wide passive band centered on launch tick covering ±277% of launch price. Holds 15% of migration capital. Rebalances with the locker on the same keeper logic; doesn't need to be tight because its job is depth, not fee maximization.
• vault_tail — single-sided STRC band below current tick. Absorbs any STRC inventory the locker bands and centered vault didn't consume at migration. As price pumps (tick falls), this STRC gets bought up and the vault accumulates ETH on the other side, deepening the compounding base.

Both vault NFTs are owned by the compound-vault contract, not the locker. The keeper rebalances all six (4 locker + 2 vault) on the same loop.

The deterministic safety layer between the AI and the keeper enforces a hard set of "no" conditions. If a plan trips any of them, it is rejected before reaching the chain.

• No swaps. The plan's action list is parsed and any swap opcode (V4 SWAP_EXACT_IN_SINGLE, SWAP_EXACT_OUT_SINGLE, etc.) is rejected outright. The keeper cannot trade.
• No NFT outside the locker / vault sets. Plans must operate on tokens the protocol owns through one of the two vaults. Anything else is rejected.
• No range center above launch tick (locker plans). Locker rebalances must center at or below the launch tick (in tick terms, which corresponds to at or above launch price for STRC).
• No range too narrow or too wide. Range widths must fall within 120 to 60,000 ticks. Outside the band, plans are rejected.
• No tick drift larger than the configured cap. The new range center cannot move further from current pool tick than the policy allows in a single rebalance.
• No slippage cap above policy. The plan's stated max slippage cannot exceed the on-chain slippage cap. If it does, either the plan is rejected or the slippage gets clamped down to the cap before execution.
• No reuse of an already-locked NFT id. Plans that try to mint a new position into a token id that the locker is already tracking get rejected.
• No principal exfiltration. Every minted position must list the locker (or compound vault) as the recipient. The contract verifies this on the action stream before forwarding the call to the PositionManager.

The AI never holds the keeper key. The keeper key cannot mint positions to arbitrary recipients. The locker contract cannot release principal before the unlock timestamp. None of those guarantees depend on the AI behaving correctly.

  +================================+   +================================+
  |     OWNER CAN TWEAK            |   |     OWNER CANNOT TOUCH         |
  +================================+   +================================+
  |  curve fee bps (within 10%)    |   |  total supply (fixed at 1B)    |
  |  min claim threshold           |   |  the hook on the pool          |
  |  dividend exclusions           |   |  fee ceilings (10% hard cap)   |
  |  fee router cooldown/threshold |   |  locked LP principal           |
  |  AI-LP policy params           |   |  launch tick (frozen)          |
  |  operator (keeper) address     |   |  migration (one-shot flag)     |
  +================================+   +================================+
              |                                       |
              v                                       v
       small lever set                      enforced by code
       (mostly tuning)                      (no override key)

STRC is built around a small handful of "no, you can't" guarantees. Each one is enforced by the contract, not by anybody's word.

Supply can never inflate

The token contract has no mint function. All 1B tokens exist from block one. There is no buyback-and-mint, no team unlock, no inflation lever.

The LP cannot be pulled

The four locker LP NFTs live in a vault contract until a fixed timestamp set at deploy. Before that timestamp, even the owner cannot withdraw the principal. The vault iterates all locked NFTs on withdrawal, so nothing gets forgotten or accidentally locked.

The protocol's AI-LP keeper can rebalance all four locker positions in place, but every minted NFT must land back in the locker, and the launch-tick ratchet prevents re-anchoring below launch price. Capital cannot leave the locker through any code path before the unlock timestamp. The compound vault's two NFTs (centered + tail) plus any auto-compounded positions sit in a separate vault contract with looser rules — they hold growth fees and a passive backstop rather than launch principal.

The hook cannot be removed

Uniswap v4 wires hooks into the pool when it is first opened, and that wiring can never be changed. The 5% dividend lane is live on every swap, forever, until the pool itself is abandoned by traders.

Fees have a hard cap

Curve fees (pre-graduation) are capped at 10% per side. Hook fees (post-graduation Uniswap swaps) are capped at 10% total. The owner cannot lift either ceiling.

Organic traders pay the base 5% on every swap. The other 5% of headroom only fires on MEV patterns: +2% if one transaction calls the hook twice on the same pool, +3% if the same wallet bought and is now selling in the same block. Worst case both stack to 10%. That is why the cap is 10% and not 5% — the protocol needs the headroom to surge on provable MEV, but the contract refuses to let the surge go any higher than the patterns it can prove.

Anti-snipe is buy-side only. The decaying 300-block anti-snipe fee applies only to buys, not sells. A coordinated sniper with deep capital could buy at a high decay fee, immediately sell at the normal sell fee, and probe the curve cheaply. The 80% block-zero buy fee makes this economically painful — every probe burns ~80% of the input — but the protocol does not surcharge the sell side. Documented as a known scope limit, not a bug.

Owner can sweep stuck ETH on the fee router

The fee router has a sweepStuckEth function callable by the owner that drains the router's full ETH balance. It exists for the case where ETH is sent directly to the router by mistake (bypassing the swap flow) or where the swap target becomes permanently broken. There is no time-lock and no minimum-stay requirement. A compromised owner key could use this to redirect pending dividend-lane ETH before the next swapAndDistribute conversion. Holders should factor this into their owner-trust assessment alongside the other owner-key risks below.

Migration is a one-shot

Two onchain flags ensure the migration can only happen once. A second attempt reverts before any state changes.

Re-entrancy is blocked

Every state-changing function on the curve, tracker, locker, fee router, and compound vault carries an EIP-1153 transient-storage guard. The lock auto-clears at the end of the transaction — no leftover state, lower gas than the legacy SLOAD/SSTORE mutex pattern. The classic "hook me into your callback while your state is half-updated" attack is blocked.

The AI-LP guardrail is deterministic

Every rebalance plan the AI produces passes through a pure off-chain validator before it touches the chain, and through onchain action-allow-list checks inside the vault contracts on the way in. The validator is deterministic: same input, same output, no flakiness. Plans that violate the rules are dropped, not flagged for review. There is no human override.

Operator and owner are split

The locker and the compound vault each have an operator address (the keeper's hot key) separate from the owner (cold). The operator can call rebalance and harvest functions but cannot withdraw principal, transfer ownership, or change configuration. If the operator key were ever compromised, the worst-case outcome is wasted gas on rejected plans, not loss of capital.

Dividends are pre-allocated to real holders only

Infrastructure addresses (the curve, the pools, the locker, the compound vault, the migrator) are pre-excluded from dividends before any STRC is sent to them. They never accrue shares. A holder's slice never gets diluted by the protocol's own plumbing.

STRC has an owner key with a small set of operational levers. Here is the full list of what that key can change, and the longer list of what it cannot touch.

The owner can — curve and tracker

• Pause curve trading via setCurveOpen(false) if something goes wrong during the launch phase. Dividend claims still work.
• Adjust the curve trade fees via setFeeBps() within the 10%-per-side hard cap.
• Tweak the minimum-claim threshold via setMinClaimAmount() (the 0.001 WBTC dust gate).
• Manage dividend exclusions via setExcluded(). Add new infrastructure addresses that should not earn dividends.

The owner can — fee router

• Tune swap cadence: setMinSwapThreshold(), setMinSwapInterval(), setJitterWindow() to balance gas efficiency vs. holder pay-out latency.
• Set the developer wallet that receives opsBps of every distribution: setDeveloperWallet().
• Tune ops + caller bounty splits: setOpsBps(), setCallerBountyBps(), both bounded by hard contract ceilings.
• Allow-list a new swap target: setAllowedSwapTarget() if the protocol switches from one ETH→WBTC venue to another.

The owner can — locker and compound layer

• Set the operator address on the locker and the compound vault. The operator can rebalance and harvest, never withdraw principal.
• Allow-list 4-byte selectors via setAllowedSelectors() on the locker. Only allow-listed function calls can be forwarded through the locker to PositionManager.
• Allow-list compound-vault swap targets via setAllowedSwapTargets().
• Re-tune the developer/dividend split on locker fee distributions via setDeployerSplit() within hard caps. (The on-chain function name retains its original spelling for ABI compatibility; the slice it controls routes to the developer wallet.)
• Set the launch tick on the locker after migration via setLaunchTick(), one-shot. Once frozen, never changes.
• Update the AI-LP policy registry via STRCLpPolicy.updatePolicy() — cooldowns, slippage caps, drift caps, mode flags. The keeper reads this contract on every rebalance plan; values are bounded by hard ceilings.

The owner cannot

• Mint, burn, or inflate STRC. The supply is fixed at 1B forever.
• Change the curve's launch parameters (graduation target, virtual reserves). All immutable.
• Change the hook fee or where it goes. The 5% rate and dividend lane address are baked into the hook contract at deploy.
• Remove or replace the hook on the live pool. Pool keys are immutable in Uniswap v4.
• Change the Uniswap LP fee. 1% is hardcoded on the migrator.
• Withdraw the locked LP principal early. Hard timelock. Even the owner cannot.
• Re-anchor a locker position above launch tick. The ratchet rejects.
• Move LP capital out of the locker before the unlock timestamp. Every minted NFT must land back in the locker, validated by the contract.
• Push curve fees above 10% per side. Hard contract cap.
• Push the fee-router or LP-fee operational caps higher. Hard ceilings enforced onchain.
• Send arbitrary instructions through the LP vaults to drain or modify them. Only clean fee collections, mint-to-vault, and ratchet-compliant rebalances are accepted.
• Retroactively change anything that's already been distributed. Settled is settled.
• Run migration twice. One-shot, period.
• Re-freeze the launch tick. One-shot. Whatever value gets set first stays.

Sepolia (chain ID 11155111) — latest verified deployment

Explorer: https://sepolia.etherscan.io/address/<address>. Each Sepolia rehearsal deploys a fresh stack, so addresses change between runs.

Ethereum mainnet: addresses will be published at launch. The mainnet chain config in lib/chains.ts is pre-wired and addresses populate on deploy.

When do dividends actually pay?

The moment a swap or curve trade settles, a holder's share of the fee is credited onchain. There is no schedule, no calendar, no daily snapshot. Hold, fees flow, the credit grows. Claim whenever, whether that's today or next year. The contract remembers.

What's the minimum claim?

0.001 WBTC, about $80 at current BTC price. Below that, the claim reverts to save gas. Dividends keep accruing until they're worth more than the gas to send them.

Why doesn't the STRC balance go up when fees come in?

Because dividends are paid in WBTC, not more STRC. Holding STRC entitles a wallet to a slice of every fee. The protocol collects fees in ETH, periodically converts them to WBTC, and credits the tracker. The token supply is fixed at 1B forever: no inflation, no buyback-and-mint, no rebasing. STRC balances only change when a wallet buys, sells, or sends.

Why WBTC and not ETH?

BTC is what most holders actually want as long-term yield. By converting the dividend stream from ETH to WBTC at the protocol layer, holders accumulate sats automatically just by holding STRC.

Can supply ever inflate?

No. The token contract literally does not have a mint function. All 1,000,000,000 tokens existed from block one. There is no path to more.

What if migration breaks?

If anything in the migration transaction reverts (bad pool init, token transfer fails, anything), the entire transaction unwinds atomically. The curve stays in its pre-migration state. The owner can fix the issue and the next eligible buy retries the migration. There is no half-migrated zombie state.

Can the LP be pulled?

Not before the timelock unlocks. The four locker LP NFTs live in a vault contract that physically refuses to release them until a fixed timestamp set at deploy. Until then, only fees can be harvested and the four positions can be rebalanced in place. Even rebalances cannot move capital out of the locker: the contract validates that any new minted NFT lands back in the same locker. The compound-vault NFTs live in a separate vault contract with looser rules — they hold growth fees and a passive backstop, not launch principal.

Who controls the WBTC conversion timing?

Nobody specifically. Once the fee router has accumulated enough ETH to cross a threshold and the cooldown has elapsed, anyone can call the swap function. The first caller earns a small bounty in WBTC to cover their gas. No keeper privilege required.

What if the AI-LP keeper goes offline?

The protocol keeps working. The 5% hook fee continues feeding dividends. The 1% LP fee continues accruing on the locked positions and can be harvested by anyone for a bounty. The AI-LP rebalance loop pauses, but the rest of the protocol's value flows do not depend on the keeper being online.

What if the AI proposes a bad rebalance?

The deterministic guardrail rejects it before it reaches the chain. If a malformed plan somehow slipped through, the on-chain action validators in the locker and compound vault would reject it at execution. Either the rebalance lands as a clean ratchet-compliant move or it does not land at all. There is no in-between.

Don't sells on the curve hurt holders?

Sells help holders. The sell fee is 10% — split 2% to the developer wallet (protocol bootstrap) and 8% to the dividend lane — and unlike the buy side there is no anti-snipe decay window: sellers pay the flat 10% from block one. Sells are taxed at the 10% per-side onchain cap on purpose, to punish flippers and convert short-term churn into permanent WBTC dividends for the holders who stayed.

What stops a rug?

A few things, all enforced by the contracts: (1) the LP timelock means no one can withdraw principal early; (2) the supply cap means no minting, ever; (3) the 10% per-side curve-fee cap means no fee-rug; (4) the hook cannot be removed, so the 5% dividend lane cannot be turned off; (5) the keeper bot is locked down to fee collection and rebalance operations only, with every instruction it sends checked onchain before it runs; (6) the launch-tick ratchet means even rebalances cannot park dynamic positions below launch; (7) the operator/owner split means a leaked operator key cannot exfiltrate principal; (8) hard ceilings on every operational parameter the owner can touch.

Has the code been audited?

Formal audit is in progress. The contracts are open-source, the deployment scripts are reproducible end-to-end on Sepolia, and the reconciliation tooling verifies zero stranded dividends after every test run. There's an internal 100-scenario stress test for vault rebalances and an adversarial sandwich-attack proof test, all passing.