The Sprivio Paper

1 · The idea

A launchpad whose income has exactly one exit.

Every launchpad says it will support its token. Almost none can show you the three transactions that would prove it — the fee arriving, the buy on the open market, the burn. We went through a list of 113 launchpads while designing this; seventeen could show a real market buyback. The rest said it and could not demonstrate it.

So we did not write a promise. We removed the ability to break one. The contract that receives the platform's share of every fee on Robinhood Chain has no owner, no withdraw function, no setter and no upgrade path. The only way value leaves it is buying $SPRIVIO on the market and sending it to the burn address. Anyone can trigger that and keep 0.5% for the gas. We do not have to be involved, and we cannot take the money out — not because we promise not to, but because the function does not exist.

Everything below is checkable. Contract addresses are in section 4; the live numbers are on the Proof page, which your own browser reads straight from the chain.

2 · The flywheel

1. Someone launches a tokenOne transaction, on any of four chains.
2. People trade itEvery trade on the curve pays a 1% fee.
3. The platform's share goes to the treasury30% of that fee — 10% during the founding period.
4. The treasury can only buy and burn$SPRIVIO bought on the market, sent to the burn address, same transaction.
5. Supply falls, and the ledger is publicEvery burn is one row with its transaction.
6. Someone noticesand we are back at step 1.

🔴 We are stuck at step 1, and we will say so until it changes. Steps 2 through 5 are built and have run end to end — but the money that ran through them was ours. The flywheel does not begin when the treasury ships. It begins the first time somebody who is not us launches a token. That is the single number we are watching.

3 · The economics

The trading fee

Founding rate, for the first … launches per chain. After that it becomes … to the creator. Both numbers are constant in the factory with no setter, so they cannot change for a token after it launches. For comparison: on pump.fun the creator receives none of the trading fee; Ethics Launch publishes 70/30, which is the same as our standard rate.

The launch window

A tax on buys in the opening seconds, halving fast. A bot that buys in the first second pays almost all of it away. Half of that penalty is paid to the creator — it is not our fee. The creator is exempt from it on their own opening buy. These figures are computed from the contract's own SNIPE_TAX_START_BPS and SNIPE_TAX_SECONDS, not written by hand. We think three seconds is too short and intend to lengthen it; see the roadmap.

What it costs

Bridging between any of the four is free — we take nothing on it; you pay the underlying network and routing provider only. A creator may also set their own trade tax of up to 10%; that one is paid to them in full and we take none of it.

4 · The architecture

Four pieces. Each is a plain contract you can read on a block explorer.

The factory

Creates the token and its bonding curve in a single transaction, mints the creator's share to them, and opens the rest as a public curve that anyone can buy from immediately. The fee recipient is immutable — there is deliberately no setter, because being able to change where the money goes is the same as being able to take it.

🔴 Addresses change when we redeploy — and the roadmap below says we intend to. That is why this table is read from our deployment config and verified against the chain as you load it, rather than typed into a document that cannot be edited.

The same address on two chains is not a mistake — with the same deployer and nonce, CREATE produces the same address everywhere. It is also how a token launched through "all four chains" ends up at one address on all of them.

The bonding curve

A constant-product curve with a virtual reserve that sets the opening price and can never be withdrawn by anyone, including us. Selling is always open, including after graduation is reached — an earlier design closed both sides at graduation, which would have buried every holder's money in a contract with no way out. Fees accrue inside the curve and are pulled on demand; claimPlatformFees() is callable by anyone and always pays the treasury.

The treasury

… — … on Robinhood Chain.

This is the piece the whole design rests on. It has no owner, no withdraw, no setter, no upgrade path, and its bytecode contains neither SELFDESTRUCT nor DELEGATECALL. Two paths out, both written in the contract: buy $SPRIVIO and send it to the burn address, and pay the caller 0.5% for triggering it. There is no third.

A limitation we are not hiding: the buying venue is fixed at construction. When $SPRIVIO graduates to a DEX, the current venue's buy() stops working and whatever balance is left in this contract becomes unreachable. We chose that over adding an emergency-withdraw, because an emergency-withdraw is an owner by another name. The exposure is small and bounded on purpose: the keeper fee means the balance is drained continuously, so at any moment it holds only what has arrived since the last burn.

The bridge

One page, two routes. Base → Arc USDC goes through Circle CCTP. Everything else between the four chains is routed through Relay — measured today at three seconds from Robinhood Chain to Arc. Before sending, we check that the transaction targets the chain you picked, carries the exact amount, and has your address encoded in its data; if any of those is off we refuse to send. Sprivio's fee on bridging is zero.

5 · How to use it

Launch a token

1. Go to the launch page and connect a wallet. We never hold your keys and cannot move your tokens.
2. Fill in name, symbol, supply and artwork. The identity is written into the token contract and cannot be edited afterwards by anyone, us included.
3. Choose your share of supply. Capped at 20% — a launch keeping more than that is indistinguishable from a rug, so the contract rejects it.
4. Set an opening buy. A token that opens with zero trades is one nobody buys: of five we launched without one, four ended with an empty curve and not a single holder. You are exempt from the launch-window tax on it.
5. Optionally tick launch on all four chains. You sign once per chain; each chain uses its own currency and its own curve settings, shown to you before you sign. You get four real independent contracts — not a bridge, not a wrapper.

Trade

Buy and sell on the curve from the token's page. Selling is always available. When a curve reaches its graduation target it migrates into a real DEX pool and the liquidity position is burned, so nobody — including us — can pull it.

Bridge

Pick a route on the bridge, get a live quote, sign once. We add no fee.

Trigger a buyback

Anyone can. Call buybackAndBurn(minTokensOut) on the treasury when it holds a balance; you keep 0.5% of it. You do not need our permission and we cannot stop you. Current balance and every past burn are on the Proof page.

6 · Roadmap

Two different kinds of thing get called a roadmap. This chapter is the first kind: work that depends only on us, with a condition that has to be true on-chain before we announce it. The second kind — things gated on how far this actually gets — is the next chapter. We publish the day a condition becomes true, not the day we decide to do it.

What B4 changes, and why it is one deployment and not three

• A longer, gentler launch window. Three seconds is too short to stop a bot — the tax has already fallen to 6.18% after one second, which punishes a slow human more than a fast script.
• No launch fee. It is small — a couple of dollars — but while nobody is here, any barrier is the wrong barrier. The fee is set at construction and cannot be changed afterwards, by design, so removing it means a new factory.
• Creator-selectable fee tiers, so the person launching decides what their traders pay instead of inheriting our number.

All three need a redeploy, so they ship together rather than spending a deployment on each. When they do, the numbers on this page, in the API, in the docs and in the contract all change in the same commit — there is a test that fails if they drift apart. Nothing on this page is a hand-typed number; every figure you see was read from the chain by your own browser when you opened it, which is why this document can promise never to be edited and still never go stale.

7 · Milestones

This chapter is the part of the roadmap that does not depend only on us. Each rung has a condition anyone can check from a public source, and a thing we have committed to do when it is met. A roadmap without a trigger is a mood; a trigger you cannot verify is a press release.

🔴 These are conditions, not predictions. Nothing here says any of these numbers will be reached, and none of it is a forecast of price. If a rung is never reached, the thing attached to it simply never happens. Do not treat any of it as a reason to buy anything.

Where it stands right now

These numbers come from the bonding curve itself, read by your browser. That matters: $SPRIVIO has not graduated, so every trade happens on the curve — and the charting sites index the empty Uniswap v4 pool instead, which makes them report a market cap and a liquidity figure that are wrong by several orders of magnitude. We would rather show you the contract than a number that flatters or insults us. The ETH price used for the dollar conversion comes from CoinGecko's public API; everything else is quoteReserve() and tokenReserve() on the curve, which you can call yourself.

Why a market cap alone is not a condition, it is a bounty

🔴 Correction, 2026-09-20. This paragraph originally said our pool was thin enough that "a few dollars moves the quoted price a long way", and quoted a market cap of $2,559 and liquidity of $0.78. Those figures were wrong, and they were wrong against us. They came from a charting site that indexes an empty Uniswap v4 pool; $SPRIVIO has not graduated, so every trade actually happens on the bonding curve, which that site does not index. Read from the curve itself, the depth is three to four orders of magnitude larger. We are correcting it in place rather than quietly editing it, because a paper that promises not to change has to show its corrections.

Market cap is still only the last price multiplied by supply, and a rung written on market cap alone would still not be a condition — it would be a public bounty: whoever pushes the price through it forces us to act, then sells into us acting. That is a documented attack, not a hypothetical. A 2026 study of 34,988 tokens found that 82.8% of those that rose more than 100% showed signs of manipulation, and the most common method was small, targeted buys against a shallow pool. The ladder keeps all three conditions for that reason, and we are not loosening them now that the real number is better than we thought.

So every rung needs three things at once, and the third is the one that matters:

1. The market cap, as a 14-day average — not a spike, not a peak, not the best reading of the week.
2. A floor under the pool's liquidity, because a market cap standing on a shallow pool is not a measurement of anything.
3. A number of launches by people who are not us. This is the one that cannot be bought. Anyone can move a price; nobody can fake other people deciding to use the thing. It is read from launchCount() on each chain, minus our own launches, and it is the number we actually care about.

The first two are read from the same public page as the market cap itself. The third is read straight from the chain by your own browser. We would rather publish a ladder that is hard to trigger than one that can be triggered with fifty dollars — a promise anyone can force is not a promise, it is an exploit.

The ladder

The contract behind M1

It is deployed and funded. This is not a description of something we intend to build — you can open it right now and read what is in it. One third of everything the team held went in on the day this paper was published.

The honest limit of what the code guarantees. There is no withdraw function, so we cannot move those tokens to ourselves directly. But the contract does let whoever holds the publisher key set any list — which means code alone does not stop us from publishing a list with our own addresses on it. We are saying so rather than letting someone find it. Here is what we did about it instead: the eligibility rule — who counts, how much each address gets, which addresses are excluded — was written and sealed today, before we know who will be on that list, and its fingerprint is published here:

The deadline is one year. That number is not arbitrary: the most expensive broken promise in this industry recently was an airdrop that was announced and then postponed for 365 days, with the price falling every time the delay was confirmed. The difference here is that after 365 days we do not get to postpone — anyone can call burnUnclaimed() and the tokens stop existing. Delay costs us the same as refusal, which is why neither is worth anything to us.

The sealed envelope

There is one thing at M2 we are not describing yet. Writing "there will be a surprise" would be worth nothing — anyone can invent one afterwards, or quietly shrink it. So we did the honest version instead: the text is written, and its fingerprint is published here, today.

Milestones that depend on people, not on price

The ladder above is the one everyone asks about. These matter more, and they are the ones we actually control least:

P1 is the one that has not happened yet, and everything else on this page is downstream of it. The honest summary of where we are: the machine is built, tested and readable, and nobody outside our own wallets has used it yet. That is stated again, with the live number, in chapter 10.

Why we can make the M4 promise

M4 is the one we expect people to disbelieve. Here is why it is within our power: our holding is roughly — of supply, in wallets that are already listed on the Proof page. Giving it away is entirely our own decision, and because those wallets are public, the promise fails visibly if we break it. We would rather be held to that than hold a bag.

8 · Adding chains

Four is where we are, not where we are going. The design does not care how many chains there are — the factory is one contract deployed per chain with the same constants everywhere. Adding one is a deployment, not a rewrite.

What a chain has to have

1. An EVM the factory compiles for, or a port we can verify line by line. Solana is that port, which is why it sits on the roadmap rather than in this list.
2. A DEX we can graduate into — verified by function selector, not by "there is a contract at that address". We have already been caught out by an address that looked like a well-known router and was not one.
3. A public node that will serve event logs. This is the condition that actually blocks chains. Several have nodes that refuse historical logs without a paid key, and a launchpad whose listings cannot be read is not a launchpad.
4. A free route in and out. If value cannot reach the chain without a toll, a creator there cannot really use us.

How chains get chosen

Until M4 we choose, and we say why. From M4 onward we publish a shortlist of chains meeting the four conditions above and holders pick the order. A chain that fails condition 3 does not reach the shortlist however popular it is — we would rather say no than ship a chain whose token list is blank half the time.

What "omnichain" will mean here

Two different things, usually sold as one:

• Moving value between chains. Works today, on all four, free.
• One supply of $SPRIVIO across all of them — burning anywhere reducing the global number. That is the hard one, it is M5, and it is not live. We will not describe it as working until a burn on a secondary chain provably reduces total supply.

9 · How we decide what to build

Before building any of this we went through the other launchpads — 113 of them on the list we worked from, and for a dozen we read the deployed bytecode rather than the marketing page. We are not going to publish our feature queue here; what is worth writing down is the rule we took away from it, because the rule is what you can hold us to.

The rule

Every claim we make has to survive someone checking it, and we build the checking first. That sounds like a slogan until you see how often it is not true elsewhere. Four patterns we found, often enough to design against each one:

1. A buyback described in detail, with nothing behind it. A burn address holding three ten-thousandths of one percent of supply. So: our buy and our burn are one transaction, and each is a row with its hash.
2. Burns that are not buybacks. Real tokens destroyed, but by users spending them, not by the platform buying on the market. Both shrink supply; only one means revenue is behind it. So: we count only what the treasury bought, and the treasury cannot obtain tokens any other way.
3. Documentation that disagrees with the contract. We found one whose docs state a 1% sell fee while the deployed constant is double that. So: our fee numbers here, in the API, in the docs and in the contract are covered by a test that fails if they drift apart.
4. "Locked forever" that is only locked today. A lock with no withdrawal function is worth exactly as much as its upgradeability. So: our treasury has no proxy, no upgrade path, and no DELEGATECALL in its bytecode.

Credit where it is earned: the clearest working buyback we found belongs to someone else, and we checked it the same way we ask you to check ours — by reading their burn address twice, an hour apart, and seeing it grow. Good work exists in this category. It is just rarer than the marketing suggests.

What we will not do

• Ship a mechanism we cannot instrument. If we cannot show you the number, we do not build the feature.
• Buy placement. No paid trending, no boosts, no purchased listings — not as a principle we are proud of, just a line we would have to disclose and would rather not cross.
• Describe something as live before it is. Sections of this page say "not live" for that reason.

One more thing worth stating plainly: of the projects we examined closely, none had a public audit, none had a public repository, and none appeared in the large protocol trackers. We are in the same position and are not pretending otherwise. What we are trying to earn is not a badge — it is that every number we publish can be recomputed by you.

What we learned about going omnichain

This settled a decision rather than inspiring a feature. We checked the relayer configuration on each of our chains directly:

• One route works for us; the one we preferred on paper does not. On Arc the only relayer type configured is the one carrying stablecoin transfers — there is nobody to relay the other kind.
• The ordinary adapter must not be used. It locks rather than burns, so a burn on a secondary chain would move tokens into a vault while global supply stayed unchanged. That would quietly turn our central claim into a lie, which is worse than not shipping.
• The default verifier setup is a single party — one signer both verifying and executing is a single point that can mint. If this ships, it ships with several independent verifiers and a timelocked multisig.

10 · Where we actually are

Everything in this section is read from the chain as you open the page. We keep the uncomfortable lines in on purpose: a status section that only lists wins gives you no way to tell this project from one that is pretending.

The full breakdown, including every wallet we control and every burn with its transaction, is on the Proof page.

11 · What we do not claim

• $SPRIVIO is not an investment product. There is no promise of price, listing, return or buyer.
• A token launched here is not listed on an exchange and has no built-in liquidity beyond its curve.
• Smart contracts can contain bugs. Ours are unaudited. Read them before you rely on them.
• We do not sell placement, trending slots or listings, and we have not bought any.
• The 1% we hold is reserved for giveaways. We do not trade it. You can watch the wallet.

Read the full risk list before you use anything here.

About everything in chapters 6 and 7

Those chapters describe conditions, not expectations. Writing "if the market cap holds $500,000 as a fourteen-day average we will do X" is not a statement that it will, that we think it will, or that anyone should act as though it might. We have no opinion to offer on the price of $SPRIVIO. Every rung on that ladder is contingent, most of them depend on behaviour by people we have never met, and the most likely outcome for a project at our stage is that none of them are ever reached.

Two things we did to stop those commitments becoming the kind of promise that gets broken. The rewards that involve our own tokens sit behind a contract that destroys them if we fail to distribute them, so failing costs us exactly as much as succeeding. And no rung depends on a third party agreeing to anything — no exchange, no venue, no partner. Where we could not remove the dependency, we removed the rung.