The protocol,in prose.

> 01 / What it is

A launchpad that opens the market itself.

Stonk.Fi pools USDG for a token that has no market yet, then creates that market and makes the first purchase in it — pool creation, liquidity and the opening buy in one transaction, in one block.

A backer holds a position in a raise, not a claim on a promise. Everything a backer receives is produced by that single launch transaction: the coin bought in the opening swap, split by contract-defined weight. There is no pre-launch price, no fixed allocation and no guaranteed outcome.

The inaugural raise is the protocol's own token and is special in several ways: it can never be cancelled, it is the only raise that mints founder tranches, and its launch window is measured from its own creation rather than from the last launch. Until it launches, no one can create a second raise. Once it launches, anyone can, for any of four quote assets — the same rules apply to all of them, except that a stock-quoted raise is capped at 5,000 USDG of total backing.

There is no owner.No contract in the protocol has an admin key, a pause switch, an upgrade path or a migration. The only privileged callers are a raise's own rights holder and fee recipient, the keeper contract, the memento collection and the controller itself. That cuts both ways: nobody can seize or redirect a raise, and nobody can rescue one either. The protocol cannot be paused — though the issuer of a centralised quote asset can pause that asset, which stops the raises using it.

Nothing in the protocol runs on a schedule. Launches, fee collection, buybacks, burns, price warming and token delivery all happen because someone sent a transaction and paid for it. Every interval below is an earliest-possible time, never an appointment.

> 02 / Lifecycle

Funding, then one of two endings.

A raise is Funding, Launched or Cancelled. There is no paused state, no expiry and no automatic close — a raise stays open until it launches or its creator cancels it.

While a raise holds at least the viability floor it sits in a queue ordered by total backing, largest first. A keeper takes the top of that queue when the cadence allows: once for the inaugural raise, 24 hours after it was created, and then at most once every eight hours across the entire protocol.

Eligibility is not a deadline. Reaching the 24-hour mark makes a launch possible, not scheduled: it still needs a keeper to call, a passing price reference at that moment, and — unless the crank is reviving a quarantined raise by id — no larger raise ahead of it. A small raise can wait behind larger ones indefinitely. Repeated failed attempts drop a raise out of the queue entirely — the third candidate-attributable revert, or the fifth unclassified one — until its rights holder calls retryLaunch eight hours later, while a price-feed failure only parks it for eight minutes in a queue the crank alone can revive. And a raise that dips below the floor loses its place and rejoins behind everything that stayed viable.

Cancellation belongs to whoever holds creator rights — the creator, until they transfer them — and only while Funding. It needs no backer consent, and it can happen after significant backing has accumulated — at which point every backer claims their own refund, in the raise's quote asset. The inaugural raise is the exception: it cannot be cancelled at all, and because public raise creation only unlocks when it launches, a permanently failing inaugural launch leaves the launchpad closed.

> 03 / Quote assets

Backed in USDG, denominated in something else.

Every raise is backed in USDG, but it is denominated in one of four quote kinds: native ETH, USDG itself, a tokenised stock, or STONKFI. The quote is what the pool is paired against, what the launch buys with, and what a withdrawal returns.

Which assets qualify is decided in code, not by curation. Native ETH must be the zero address; USDG and STONKFI must be the exact addresses fixed at deployment; a stock token must prove its own provenance by resolving back to itself through the stock factory. WETH is rejected outright, whichever kind is claimed.

Stock quotes carry the most outside dependency. They need a price feed that matches a pinned proxy codehash, owner, decimals and description, bound once and never rebindable. They stop working whenever the issuer pauses the token or its oracle, or schedules a share-multiplier change. And they are capped: 5,000 USDG of total backing per raise. A STONKFI-quoted raise has the opposite problem — no external feed exists for it at all, so both its floor and its valuation come from the same market the backer is trading into.

> 04 / Backing

One position per wallet.

Backing is always paid in USDG. A wallet's position must total at least 5 USDG; above that it can be topped up any number of times, up to 128 deposits per raise.

If the raise's quote asset is not USDG, the deposit is converted into that asset on the way in, at the moment you deposit, through a guarded route. That conversion is what a withdrawal returns: you get back the quote acquired at deposit time, not the USDG you paid. Where the quote is USDG the two are identical; for an ETH-, stock- or STONKFI-quoted raise a withdrawal can be worth materially more or less than the deposit.

Every deposit carries its own minimum output and deadline, and both are enforced. A deposit can also fail for reasons that have nothing to do with you: a stale or off-peg USDG reading, an unavailable route price, or a protocol floor above what the route can deliver will revert it rather than fill it badly.

Exit is all-or-nothing, and only before launch.There is no partial withdrawal — leaving means leaving completely, which also destroys that wallet's queue contribution, memento units, referral attribution and deposit count. After a raise is Launched there is no exit at all; from that point the only way out is the market.

> 05 / Referrals

A rebate, not just a reward.

A referrer is recorded on the deposit, not on the wallet. Two deposits from the same address can name different referrers, or none. No later deposit rewrites an earlier one, though a full exit deletes a deposit and its attribution with it.

Referred backing pays one extra 6.67% lane at launch — and that lane is not a payment to the referrer alone. It is split roughly in half: one half is claimable by the referred backer as a rebate, the other by the referrer, pro rata across everyone they brought. The odd unit rounds to the backer. Both halves settle in the raise's quote asset and both are claimed rather than pushed.

None of it exists unless the raise launches — the referral pool is only sized inside the launch transaction, so a cancelled raise pays neither side. And a referrer's share can shrink without their involvement: when a referred wallet withdraws in full, the contract walks its deposits and decrements the referrer's recorded basis.

> 06 / Routing

Three lanes, all the same size.

At launch the pooled quote is split into lanes of 667 basis points — 6.67% — each. An unreferred deposit pays two of them, so 86.66% reaches the opening purchase. A referred deposit pays a third, leaving 79.99%.

The two lanes every deposit pays are the creator lane and the Stonk Pipe lane. The Pipe's is transferred immediately; the creator's is credited as a dated lot to be claimed, on the same terms as pool fees later on.

Because a referred deposit sends less into the opening purchase, it earns proportionally less of it — a weight of 7,999 against 8,666, or about 92.3%. Referral changes routing and weight. It does not change the token price, withdrawal rights or any deadline.

The opening price itself is derived, not chosen: the planner values the whole supply at roughly 2.43 times the value of the raise and derives the opening price from that. The multiplier is computed as though every raise took the maximum three lanes and the opening purchase paid the pool's 1% fee. It is not a floor, an appraisal, or a statement about where the coin will trade afterwards.

> 07 / Launch

One transaction, or none.

The launch is a single call that either lands completely or reverts completely. There is no state in which the pool exists but the opening purchase has not happened, which is the gap a launch sniper would otherwise occupy.

1. The raise is sealed

   Status moves to Launched, the raise leaves the queue, coin transfers unlock, and the creator and Stonk Pipe lanes are taken out of the pooled quote. On the inaugural raise the three founder tranches move here too.

2. The pool is created

   A Uniswap v4 pool is initialised at the planned price with the Damper hook attached. If the pool comes back at a different tick than the plan, the whole call reverts PriceMismatch.

3. Liquidity is seeded

   One coin-only position is minted inside the pool manager, spanning from the launch tick outward. The settlement delta must be exactly the coin principal with nothing on the quote side.

4. The pool is registered

   A one-USDG-equivalent buy runs first and must match its own simulation exactly, which proves the pool prices the way the plan said it would before the real money moves.

5. The opening purchase executes

   The pooled backer quote is swapped as exact input. Returned amounts must equal the simulated amounts or the launch reverts OpeningSwapMismatch.

6. The result is re-checked

   The controller independently re-reads the pool price through StateView, checks the hook registration and anchor, and requires that it ends the transaction holding no coin at all. Any disagreement reverts InvalidLaunchResult.

7. The launch is recorded

   Allocation is configured on the coin, the memento id is registered, public raise creation unlocks on the inaugural launch, the Pipe inflow is recorded, and the next eight-hour window starts.

Every step is checked against a simulation run in the same transaction, and the controller re-derives the result independently of the adapter that produced it. The launch is not trusted because the adapter says it worked; it is accepted because two readings of the pool agree.

A failed attempt does not cancel anything. The raise is quarantined out of the queue and stays in Funding with every position intact and still withdrawable; its rights holder can return it to the queue, and the crank can revive one due retry per window. Failures are recorded as a selector and a hash, so the chain does not carry a human-readable reason.

> 08 / Keepers

Someone has to press the button.

StonkCrank is the only contract allowed to drive the protocol's recurring work, and anyone at all is allowed to drive StonkCrank. There is no allowlist, no bond and no registration: the caller becomes that call's keeper.

A crank call does at most one useful job, chosen by a fixed priority ladder — fresh distribution, price warming, launch, artwork, then a twelve-slot maintenance rotation covering fee collection, stock drips, distribution, price warming and Pipe settlement. Every external call is made with an explicit gas cap and a reserve, so a job that fails is recorded as deferred or failed rather than reverting the whole transaction.

The incentive is thin and it is honest about it. A rewarded maintenance job credits STONKFI worth 0.10 USDG; a launch or artwork job credits 1.00 USDG of it. Nothing is paid in USDG itself, and the reserve behind it is fed only by the 20% of STONKFI-side pool fees held back from the burn — while the recommended gas limit for a crank transaction is 32,000,000. Payment is exact or nothing: a reserve that cannot cover the whole tier credits zero, and if the reward call reverts the work still happened and the keeper is paid nothing.

So the honest summary of this section is: if nobody runs a keeper, nothing happens. No launch, no fee collection, no buyback, no burn, no artwork, no price warming and no automatic token delivery. Those are not background processes; they are transactions someone chose to send.

> 09 / Guards

Prices the protocol will refuse.

Whenever the protocol converts one asset into another — a deposit into a non-USDG quote, or the Pipe selling an asset for USDG — it sets its own minimum before your own is considered, and takes whichever is stricter.

That protocol minimum is the higher of two independent floors: an oracle fair-value band, and a floor at 99% of a same-block simulation of the same trade. STONKFI-quoted deposits are the exception — only the route floor and a live USDG peg check apply, with no fair-value band at all. The oracle side reads Chainlink first with strict round-shape and staleness checks, falls back to a cached answer, and only then to a median of route probes that must sit within 5% of a cached anchor. STONKFI has no feed at all and is priced from nine interval-TWAP buckets read off the Damper hook, with a five-bucket quorum — buckets that only exist because keepers warmed them.

Notice what the band does and does not promise. A 110% buy ceiling means a conversion can still fill meaningfully worse than fair value before the protocol refuses it, which is why your own minimum output matters: it can only tighten the floor, never loosen it.

Routes are not registered, whitelisted or governed. They are deterministic Uniswap v4 pool keys over a fixed set of fee and tick-spacing templates, probed in a fixed order, and the first that completes within its tick-read budget is used. Alternates are availability fallbacks, not price competitors.

> 10 / Damper

Three hours of sell-side friction.

For three hours after a launch, a Uniswap v4 hook takes a surcharge out of sells and burns it. Buys are never surcharged. The ceiling starts at 31% and falls in a straight line to zero, after which the hook stops charging and cannot be re-armed.

Thirty-one percent is a ceiling, not an opening rate. Both of the counters the surcharge is computed from start at zero, so the first sells into a fresh pool are surcharged little or nothing, and the ceiling is only approached under sustained heavy selling early in the window.

The surcharge has two parts, and both scale by the same decay factor. Up to 7% comes from recent sell flow over a rolling 30-minute window, saturating at ten million coins — one percent of supply. Up to 24% comes from price impact, but the impact measured is the cumulative net sell flow since launch against the launch position, not the impact of your own trade in isolation. It contributes nothing below 2% and is maximal at 8%.

None of it is a fee. The hook does not override the pool's fee at all; it settles the surcharge separately, taking it in the coin itself and sending it to 0x…dEaD — no liquidity provider, creator or treasury receives it. The pool's ordinary 1% fee is separate, does not decay, and is not part of the 31%.

The Damper is a price, not a gate. It inspects no addresses, keeps no allowlist and imposes no cooldown; anyone willing to pay the surcharge can sell as much as the pool will fill. It shapes the cost of exiting early. It does not prevent loss.

> 11 / Trading

One pool, one position, forever.

Each launch creates one canonical pool: the coin against its quote, a static 1% fee, tick spacing 60, Damper hook attached. Its parameters are fixed at creation and nothing can change them afterwards.

Canonical is not exclusive. Once transfers unlock, the coin is an ordinary ERC-20 and nothing in the protocol prevents anyone from opening a second market for it — with no hook, no surcharge and none of the liquidity described below. Everything in this section is a property of the pool the protocol seeded, not of the token.

The launch liquidity is a single position seeded once, and it is permanent in the strong sense: the adapter has no code path that reduces it, and the hook rejects add-liquidity and remove-liquidity from every address except the adapter itself. Nobody can withdraw the protocol's liquidity — and nobody else can provide any, so holders cannot earn a share of the pool's 1% fee.

The position is one-sided.It is seeded with coin only, spanning from the launch tick outward, so there is no liquidity on the far side of the launch price. The quote a seller receives is quote that earlier buyers put in. Price can be walked back toward the launch tick but not through it, and once that range's quote is exhausted, a sell cannot fill against it at all.

Anyone can sell through the adapter, which previews the Damper charge, enforces the fee ceiling you supply, requires a full fill and pays the quote straight to a recipient address you name. During the Damper window sells must be exact-input and must fill completely; after it expires the hook stops constraining swap shape and stops reading your fee ceiling at all — a silent mode change worth handling explicitly if you are integrating.

> 12 / Token

Fixed supply, lazy delivery.

Every launch mints its own coin with a fixed supply of 1,000,000,000 at 18 decimals. The number is a compile-time constant and there is no mint function, so supply cannot change under any code path.

Transfers are frozen for everyone but the controller until the launch unlocks them, once, permanently. For the inaugural raise, 910,000,000 tokens go to the launch — seeded as liquidity and bought in the opening swap — and three tranches of 30,000,000 go to founder destinations fixed at deployment: one unlocked, one locked for 730 days, one vesting linearly over 365 days. Founder allocation exists on that raise only; every later raise puts its whole supply into its launch.

Allocation is delivered lazily.After launch the coin contract holds the backers' tokens and hands them over when materialize is called — by anyone, for any account. Until then balanceOf already adds the unclaimed entitlement, so the number reads correctly while the tokens themselves have not moved, and visibleBalanceOf returns the same figure. The keeper pushes allocations in batches, but only up to a bounded number of attempts per launch; past that it is pull-only, and an indexer rebuilding balances from transfer logs alone will show nothing until someone makes the call.

Burns throughout the protocol are transfers to 0x…dEaD rather than supply reductions. Circulating supply falls; the number totalSupply reports never moves.

> 13 / Fees

Collected by whoever shows up.

The pool charges a static 1%, and because the protocol's position is the only liquidity in it, all of that fee accrues to the protocol. None of it streams anywhere on its own: it sits uncollected inside the pool manager until a keeper collects it.

When collection runs, the coin side goes to the Stonk Pipe. Every launch coin is burned in full there; when the coin is STONKFIitself the Pipe keeps 20% as the keeper reward reserve and burns the other 80%. The quote side is halved between the raise's fee recipient and the Stonk Pipe, with the odd unit going to the Pipe. Anyone modelling fee revenue as half of one percent of volume is wrong on the coin leg: none of it reaches the fee recipient.

The fee recipient is credited rather than paid. Each collection appends a dated accrual lot, and the recipient claims a window of lots at a time to an address of their choosing. Lots never compact, so a long history of dust collections stays paginated forever — and any lot left unclaimed for 365 days can be swept to the Pipe by any passing address, with no notice and nothing in it for the caller.

Accruals do not follow the office. When creator rights or the fee seat change hands, outstanding fees settle to the outgoing address first and stay claimable by it. A successor — including a community that has just completed a takeover — inherits the future, not the balance.

> 14 / Stonk Pipe

Fees in, STONKFI out.

The Pipe is where the protocol's share of value goes. It takes one 6.67% lane from every launch, half of every quote-side pool fee collected, the whole coin side of those fees, escheated accruals and marketplace royalties. It converts what it receives into STONKFI and burns it.

Apart from the coin side of pool fees, which is burned on arrival, nothing is spent when it lands. Every other balance decays out of a locked bucket on a one-day half-life — continuous exponential decay, not a delay and not a release schedule — and only the matured part can be processed, at most 100 USDG of swap budget per block across all assets.

All of the USDG realised buys STONKFI through the same guarded routes as everything else. Purchased STONKFI then matures on the same half-life and is burned in full at settlement, as is STONKFI that reached the Pipe without being purchased. Keeper rewards are funded separately, from a 20% share of the coin-side pool fees that arrive denominated in STONKFI— the only value that leaves the burn path.

The Pipe has no owner. Nobody can redirect it, pause it or withdraw from it; the burn address is a constant, and the crank is the only caller that can move value through it — the one exception being a keeper withdrawing STONKFI already credited to it.

> 15 / Mementos

A receipt, and a lever.

Every launch mints an ERC-1155 collection with one token id for that launch. A wallet earns one unit for every whole 5 USDG of its total backing, floor rounded, claimable only once the raise has launched.

A memento is a record of having backed a launch. It is not a fee share, an ownership interest, a redemption right or a promise of value — the token's own onchain description says so. Units are ordinary transferable ERC-1155 balances delivered lazily, and unlike the coin an unmaterialized entitlement shows as a zero balanceOf — only visibleBalanceOf adds it — and produces no transfer log.

Each launch also mints one permanent anchor unit that can never be transferred or burned, plus up to two bonus units for the addresses that spent the most gas building the artwork. Marketplace royalties are set at 5% and always name the Stonk Pipe, but ERC-2981 is a signal, not an enforcement: an ordinary transfer can omit it entirely.

The takeover is narrower than it sounds. At least 14 days after a launch, a single address holding a ceiling-75% supermajority of the community supply can burn it in one call and take over — the buy-side quote-fee recipient, and nothing else. Creator control stays with the rights holder. NFT royalties stay with the Pipe. Outstanding accruals stay with the outgoing recipient. It can happen once per launch and cannot be undone.

> 16 / Artwork

Drawn by contracts, paid for in gas.

A memento's image has no server, no IPFS and no URL behind it. The token returns a data URI whose JSON and 1000 × 1000 SVG are assembled by contracts at read time, from path data held in storage contracts and a palette recomputed from the launch id.

The picture is not drawn in one transaction. It is built in batches of ten paths — six for the Perfect Vortex archetype — by anyone willing to send them, and only for the launch that has not happened yet — seven to forty-five calls, depending on how dense the composition turns out. The keeper will take a turn at it, but the artwork job is best-effort and is preempted by the launch job whenever a launch is due.

The launch is the deadline.Once a launch succeeds, its artwork can never be finished, and that token permanently shows a substitute: either a deterministic geometric placeholder derived from the launch id, or an earlier launch's finished artwork rotated by a multiple of 90 degrees and hue-shifted. Both substitutes label themselves in the traits, so a holder can always tell which of the three they are looking at.

The two addresses that burned the most gas building a launch's artwork are recorded when it completes and later receive two memento units between them. The metric is gas spent rather than work completed, the leaderboard holds exactly two places, and nothing is paid at all if the artwork never finishes, if the launch was too small, or if a community takeover closed the reward before it was reserved.

> 17 / Architecture

Deployed once, then fixed.

The protocol is a controller plus a set of components — launch adapter, canonical routes, price guard, Damper hook, Stonk Pipe, crank, memento collection and the onchain artwork stack — most of them created by their own factory during construction and bound to the controller as immutable addresses. The artwork renderer is the exception: it is deployed beforehand and passed in, bound once at construction, and thereafter read by the memento collection for metadata and driven directly by the crank.

Nothing is upgradeable. There is no proxy in front of the controller, no admin able to swap a component, and no migration path. The correctness of every component is fixed at deployment; the controller validates their results and reverts, but cannot replace them.

The release itself is a deterministic seventeen-transaction stream from one address: six Laminar libraries, the renderer, seven factories, two preparation calls and then the controller. That ordering is described by a comment on the controller's constructor rather than enforced onchain. What the constructor does enforce is narrower than it sounds: the Damper, adapter, routes and price guard must each report the expected pool manager, controller and token bindings or construction reverts, while the Pipe, crank and renderer are checked only for their controller binding and the inaugural coin, lock and vesting are trusted from the asset factory. The fork rehearsal, the recorded runtime hashes and the broadcast checksum are release-driver output recorded alongside the release; nothing on this page recomputes them.

> 18 / Reading state

What the chain will and will not tell you.

Every raise emits a small, stable set of events — creation, each deposit and the quote purchase it triggered, withdrawal, cancellation, refund, launch, launch failure, referral claim, fee collection and the two handover events — with raise id, coin, backer, referrer and asset as indexed topics.

Positions and entitlements are read through struct-returning views, but two of the ones users care about most return nothing meaningful until the raise has launched. Any pre-launch “you will receive N” figure is an off-chain estimate that depends on the final totals and the rate resolved at launch — not a quote from the chain.

The subtlety that catches integrators is lazy delivery. Coins and mementos sit with the token contract or a custodian until someone materializes them, so an indexer that reconstructs balances from transfer logs will honestly report zero for a backer who is genuinely owed tokens. Read balanceOfor the entitlement views rather than replaying logs — the coin's balanceOf already adds the unclaimed allocation, and visibleBalanceOf returns the same number. The memento is the one that still reads zero until it is materialized.

Some things simply are not readable. Queue position is private with no getter, so any displayed position is a reconstruction. Launch failure reasons are hashes, not messages. And several views revert rather than returning a default, so read them defensively.

> 19 / Status

What is and is not settled.

The contracts described here are deployed on Robinhood Chain, chain 4663. The controller is 0x5DB57a2e6DAD60E9964531bC7244Ff9E712c6999, and the code at that address — not this page — is the protocol.

Everything above is still a reading of source code, not of a chain. A deployed contract is only the code that was actually broadcast, so treat this page as a claim about that deployment to be checked, not as evidence of it. This docs page does not sign. The raise, creation and claims interfaces can build transactions, and each signing surface states what it will ask the connected wallet to do.

The address graph

Every address below was read back off chain 4663 rather than copied from a deployment log: the controller's own views name its components, and the three it does not expose were confirmed to carry runtime code. The controller was created in block 28,629,638.

One package, both pages

The raise page and this one are read from the same contract package, so their numbers agree. If they ever diverge again — a new revision landing on one page before the other — the disagreement belongs on this page, named, rather than quietly reconciled.

Before anything is signed

Verify the chain and chain id, the controller and USDG addresses against the official announcement, then the deployment timestamp, contract-read backing, and the amount, deadline, slippage and referrer on the transaction itself — before signing. An address that is not published here and by @stonkdotfi is not this protocol, whatever it says it is.

Backing is speculative and may result in total loss. STONKFI is not equity, debt, a deposit account or a promise of profit. Contract-derived target valuations are launch inputs, not predicted prices or returns. This page is informational, not financial advice.