gomp

gomp is a token on ethereum. when you want some, you send ethereum to a contract address, and the contract sends gomp tokens back to your wallet. when you want to cash out, you send the gomp back to the same contract and it sends ethereum to you.

that's the whole product. no order book. no market makers. no website that has to be up. just a contract that buys and sells gomp from you, at prices that follow a fixed mathematical formula.

most crypto tokens have a team behind them. that team decides when to mint new tokens, who gets them, what the price is, when to dump on holders, whether to pause the contract. holding the token means trusting those people not to rug you.

gomp doesn't have a team in that sense. we deployed the contract and walked away. we didn't keep any tokens for ourselves. we can't mint more. we can't pause anything. we can't withdraw the ethereum sitting in the contract. if we deleted the website tonight, the contract would keep working tomorrow.

every token issued on gomp is priced by a single math formula called the gompertz curve. it was invented in 1825 by an english actuary named benjamin gompertz to model how human populations age and die. it's the kind of S-shaped curve you see when something starts slowly, then grows fast in the middle, then plateaus near the top.

for gomp, the curve says: if X ethereum has been sent into the contract so far, then exactly Y gomp tokens exist. the more X grows, the more Y grows, but not at a constant rate.

q(e) = A · exp(-B · exp(-C · e)) - Q0

  e  = total ethereum sent so far (the reserve)
  q  = total gomp that exists at that reserve
  A, B, C, Q0 = curve parameters (fixed forever)
  K  = A - Q0 = 21,000,000 (the asymptote: supply can
                            approach but never reach it)

you don't need to understand the formula to use it. the contract uses it for you. but here's what matters: this is a different shape from how most token curves work. it has phases.

most bonding curves get monotonically more expensive the more you mint. gomp's curve is shaped like an asymmetric S, which gives it a lifecycle with four stages, like an organism:

the buy flow has five steps:

1. you click "mint" and type how much ethereum you want to spend (max 5 per transaction).
2. your wallet sends that ethereum to the contract.
3. the contract uses the gompertz formula to figure out exactly how many gomp tokens that ethereum buys at this moment.
4. the contract creates those tokens out of thin air and sends them to your wallet.
5. the ethereum stays in the contract forever (well, until someone else burns gomp to redeem it).

a 0.3% fee is taken out of every mint. the fee stays inside the contract. nobody, not even us, can ever pull it out.

same thing as a mint, in reverse. you send gomp back to the contract, the contract burns it (destroys it forever), and ethereum from the reserve flows back to your wallet.

the amount of ethereum you get is decided by an "inverse" of the curve. burning tokens when supply is high gives you more ethereum than burning tokens when supply is low.

burns have a special fee unlike any other curve-based token:

this isn't a punishment. it's friction. flash-trading the curve to extract a few dollars becomes structurally unprofitable. the people who hold are the people who built the reserve. they shouldn't be paying the same exit toll as bots.

if you mint 1 eth of gomp and immediately burn it, you lose about 0.6% (the mint fee plus the burn fee). you do not make money by instantly round-tripping. the design intentionally guarantees you lose money on that.

the way you make money is the same way miners made money on bitcoin: by entering before more people enter. the curve's burn price is not based on what you paid. it's based on how much ether is in the reserve right now. when more people mint after you, the reserve grows, and your gomp becomes redeemable for more ether than you paid.

example (numbers rounded for clarity):

  step 1: you mint when total reserve is 100 eth.
          you pay 1 eth, receive ~9,000 gomp.

  step 2: over the next month, 400 more eth flows in
          from other people minting. total reserve is
          now 500 eth.

  step 3: you burn your 9,000 gomp. the contract
          looks at the current curve position (500 eth)
          and pays you the inverse-curve eth at that
          level, less the 0.3% burn fee.

  step 4: you receive ~3.6 eth back. you paid 1 eth.
          you profited ~2.6 eth on demand growth.

if instead, total reserve is still 100 eth when you
burn (nobody else minted after you), you get back
about 0.994 eth. you lose ~0.6% to fees and call it
a day.

the upside is paid by people who entered after you. the downside is paid by you if nobody enters after you. this is not a passive yield product. it is speculation on curve growth, dressed up in a curve that's mathematically transparent.

there is also a separate secondary market. once enough gomp has been minted, normal automated-market-maker pools (like gomp/usdc on uniswap) tend to spring up around the curve. you can sell into those pools instead of burning. the price there is whatever the market says, which can be higher or lower than the curve's burn price at any given moment. the trade page shows you both quotes so you can pick.

every gomp token that exists corresponds to ethereum that someone, somewhere, paid to mint it. that ethereum is sitting in the contract right now. if everyone burned their gomp at once, the contract would drain back to zero and everyone would have their ethereum back (minus the locked-in fees, which stay in the contract for the mathematical equivalent of forever).

this is the strong claim of the design. supply is backed by deposits, not by faith. if you want to audit how much ethereum is backing the supply right now, you don't ask us. you read the contract's balance on etherscan.

here are things we cannot do, ever:

• mint gomp without paying ethereum for it
• pause the contract
• upgrade the contract
• withdraw any ethereum from the reserve except by burning gomp like anyone else
• withdraw any of the accumulated fees
• blacklist addresses
• change the fee
• change the curve formula
• change the maximum supply

there are no functions in the contract code that do any of these things. it's not a promise we're making. it's a mathematical fact about the bytecode that's deployed.

the contract does not ask bots to behave. it just makes botting a bad trade. three mechanisms are enforced at the bytecode level, not by a terms-of-service.

entropy    = keccak256(prevBlockHash, swapper, ethIn)
multiplier = 0.9 + (entropy % 0.2)   // uniform ±10%

prevBlockHash is unknown until the block is mined.
a bot cannot simulate its exact output before submitting —
it might receive 10% fewer tokens than its model predicts.

if a bot decides to buy in those first 100 blocks anyway, it is paying the most expensive tokens in the protocol's lifetime — the lag-phase premium — with a random penalty on the output. the contract does not prevent it. it just makes it a structurally bad trade.

you do not need to read this section. the contract does the math for you. it's here for people who want to verify the formulas line up with the on-chain code.

forward: how much gomp exists at eth reserve e:

  q(e) = A · exp(-B · exp(-C · e)) - Q0

inverse: how much eth was needed to reach supply q:

  e(q) = (1/C) · ln( B / ln(A / (q + Q0)) )

marginal price (eth per token) at reserve e:

  dq/de = A · B · C · exp(-Ce) · exp(-B · exp(-Ce))

constants (locked at deployment):

  A  = 22,153,834.18
  B  = 2.9557
  C  = 0.0021674   per ether
  Q0 = 1,153,834.18   = A · exp(-B)
  K  = A - Q0       = 21,000,000   (asymptote)

the inverse formula has two nested logarithms, what mathematicians call a double log. it's the unusual feature that makes this curve the gompertz and not just a regular exponential.

mint fee:  flat 0.3% of every mint, forever.

burn fee:  decays linearly with how long you've held.

  fee(blocks_held) = max( 0.3%, 1.0% - 0.7% · (held / 10000) )

  held = 1 block      → reverts (no flash-sell allowed)
  held = 100 blocks   → ~0.993% fee  (~20 minutes)
  held = 5,000 blocks → ~0.65%  fee  (~16 hours)
  held ≥ 10,000 blocks → 0.3%   fee  (baseline, ~1.4 days on mainnet)

all fee revenue stays inside the contract forever.
it isn't a treasury. nobody collects it. it accumulates
and sits there, making the reserve marginally bigger
over time, but otherwise being mathematically inert.

1. open the trade page
2. connect your wallet (we read your eth balance, that's all)
3. type how much eth you want to spend (or drag the slider; it shows you a live preview)
4. click mint gomp and approve the transaction
5. you now have gomp. to cash out, switch the tab to burn, type how many gomp to sell, and approve.

• the curve might never get to the inflection. if nobody mints enough ether into the contract, the curve stays in the lag phase forever and your tokens stay expensive relative to the inverse-curve value.
• there is no recovery if you send eth to the wrong place. the contract has no admin. nobody can refund you. measure twice, mint once.
• the secondary market price can diverge from the curve price. the curve will always quote you something. so will any AMM pool that ends up existing. they aren't required to agree, and arbitrage doesn't always close the gap instantly.
• profit depends on demand growth. the curve only pays out more than you put in if more ether enters the reserve after your mint. if nobody else mints, you can only round-trip back what you paid, minus fees.