The runner.exchange
protocol

runner.exchange is a token launchpad. It removes the two hardest parts of launching a token — bootstrapping a market and earning trust — by making both mechanical and enforced in code.

Every launch follows the same path. A creator mints a fixed-supply ERC-20 for a small fee. The token immediately trades against a bonding curve: a deterministic pricing function where the price depends only on how many tokens have been bought, with no order book and no counterparty. As buyers arrive, the curve collects ETH. When it reaches the graduation threshold, the collected ETH and the reserve tokens are deposited into a Uniswap V3 pool in the same transaction, as a liquidity position that is then locked forever. From that point the token trades on the open market with liquidity that can never be withdrawn.

There are no team allocations, no presale, no mint function after launch, and no ability for anyone — including the protocol owner — to pause a live curve, seize its ETH, or pull graduated liquidity. These are properties of the contracts, not promises.

A token moves through three phases:

  launch ──▶ curve (trading) ──▶ graduation ──▶ open market
   mint         buy / sell on          deposit to        Uniswap V3,
  fixed         a bonding curve        a locked V3      position locked,
  supply        priced by demand       position         earns fees

The curve phase and the open-market phase are both fully tradable. The only discontinuity is graduation itself, which happens atomically inside the buy that crosses the threshold — there is no window where the token cannot be traded.

Each launch deploys a standard ERC-20 with a fixed supply of 1,000,000,000 tokens (18 decimals), minted in full to the launchpad at construction. The contract has:

• no mint function — supply can never grow;
• no owner and no admin — nothing to pause or reconfigure;
• no transfer hooks or fees on the token itself.

Before graduation the unsold supply simply sits in the launchpad as curve inventory. At graduation part of it is paired into the Uniswap V3 position (see §6), so total supply is fixed and circulating supply is fully accounted for at every step.

Pricing uses a constant-product curve over virtual reserves — the same invariant as a Uniswap pool, but seeded with virtual liquidity so trading can begin with zero real deposits. Each token snapshots its curve parameters at creation; they never change afterwards.

Define, for a live curve:

  ethReserve   = virtualEth   + realEth        (ETH collected so far)
  tokenReserve = virtualToken − tokensSold     (tokens still on the curve)
  k            = virtualEth × virtualToken     (constant, fixed per token)

A buy takes a fee off the ETH sent, then moves along the curve. Let dx be the net ETH after fees:

  fee       = ethIn × tradeFee
  dx        = ethIn − fee
  tokensOut = tokenReserve − ⌈ k / (ethReserve + dx) ⌉

The division rounds up (against the trader), which guarantees the product of the effective reserves never falls below k. A sell is the mirror image, with the fee taken off the ETH returned:

  grossOut = (tokenIn × ethReserve) / (tokenReserve + tokenIn)
  ethOut   = grossOut − grossOut × tradeFee

Because both directions round in the curve's favour, the contract always holds at least as much ETH as it would owe if every token sold so far were sold back. This solvency property is the core invariant of the system (see §9).

Only a fixed slice of the supply — the curve supply, 80% by default — is sold on the curve. When cumulative sales reach it, the collected ETH has, by construction, reached the graduation threshold at the same instant.

The spot price is the ratio of the effective reserves:

  price = ethReserve / tokenReserve      (ETH per token)

Price rises monotonically as tokens are bought and falls as they are sold — it is a pure function of tokensSold, identical for every trader at a given point on the curve. Market cap is the spot price times total supply. Both are emitted with every trade event, so a client can reconstruct the full price history from logs alone, with no indexer required.

When a buy pushes collected ETH to the graduation threshold, that same transaction:

1. closes the curve — no further curve trades are possible;
2. seeds a Uniswap V3 pool at the curve's final price, forcing any pre-created pool back to that price first;
3. deposits the collected ETH and a matched amount of tokens as a full-range Uniswap V3 liquidity position; and
4. locks that position permanently — the contract holds it with no function to withdraw the liquidity.

The amount of tokens paired with the ETH is chosen so the Uniswap pool opens at exactly the curve's final price:

  ethToPool    = graduationEth − graduationFee
  tokensToPool = ethToPool × tokenReserve / ethReserve
  opening price = ethToPool / tokensToPool  ≡  final curve price

Because the opening price matches the last curve price, there is no gap for arbitrage bots to exploit on the first block. And because the position is locked rather than owned, no party — creator, protocol, or third party — can ever remove the liquidity. Unlike a burned position, though, the locked V3 position keeps earning swap fees (see §7). The token now trades on Uniswap like any other asset, routable and composable.

A buy that would overshoot the threshold is clamped to land exactly on it; the unused ETH is refunded in the same transaction. Graduation therefore always lands on the exact target with no dust and no failed migrations.

The protocol charges three fees, all bounded in the contract:

• Creation fee — a small flat fee to launch a token, paid once. Deters spam.
• Trade fee— a small percentage on each curve buy and sell, split between the protocol and the token's creator. Creators earn from their token's activity without holding any of the supply.
• Graduation fee — a flat fee taken from the collected ETH at graduation, before liquidity is deposited.

After graduation, the token trades on its Uniswap V3 pool. The locked position keeps earning the pool's swap fee, which is collected and split between the creator and the treasury — permanent income rather than a one-time listing. All fees accrue in the contract and are pulled to their recipients, so a recipient that cannot receive ETH can never block trading for anyone else.

The affiliate program is invite-only, limited to approved affiliates and brand ambassadors. It is first-touch and permanent, in the style of trading terminals like fomo, bullx, and Padre:

1. Approved affiliates and brand ambassadors receive a personal referral link carrying a vanity code. Links are created by the team, not self-service.
2. When a new visitor arrives through an affiliate's link, their browser records that affiliate as their referrer for 30 days.
3. The first time they connect a wallet, that wallet is bound to the affiliate — permanently. The binding cannot be overwritten by a later link, and self-referral is ignored.
4. The affiliate earns a share of the trading fees that wallet pays, across every token, for as long as they trade.

Rewards are attributed from on-chain trade data — referred volume, fees, and the affiliate's share are all derived from real trades, not estimates. Approved affiliates and brand ambassadors see their live totals and per-wallet breakdown on the affiliate dashboard. Rewards accrue continuously and are paid out to your wallet from protocol revenue on a regular schedule.

The protocol owner exists only to tune parameters for future launches. Concretely, the owner can change the treasury address, the creation fee, and the default curve parameters new tokens inherit, and can pause the creation of new tokens.

The owner cannot:

• pause, edit, or halt trading on any live curve;
• withdraw or touch the ETH held for any curve;
• change the parameters of a token that already exists;
• mint tokens or alter any deployed token;
• withdraw graduated liquidity — the locked position has no withdrawal path.

These limits are structural: the contract simply has no function that would allow them. The one property everything rests on is solvency — at all times the contract holds enough ETH to buy back every token sold on every live curve, which the curve's rounding guarantees by construction.

Default values a new token inherits at launch. Curve parameters are snapshotted per token and immutable thereafter; protocol parameters affect future launches only.

Bonding curve

A pricing function where a token's price depends only on how much has been bought. No order book, no counterparty.

Virtual reserves

Notional liquidity used to seed the curve so trading can start with no real deposits.

Graduation

The moment a curve's collected ETH reaches its threshold and its liquidity migrates to Uniswap.

Locked position

The full-range Uniswap V3 liquidity position created at graduation. The contract holds it with no function to withdraw the liquidity — it can never be pulled — but it still collects swap fees.

First-touch

Attribution model where a referred wallet is credited to the first affiliate whose link it arrived through.