1SAT the asymptote is one
An inverse bonding curve where total ever-mintable supply approaches one token. The last fraction of supply is exponentially expensive to reach. A fork inspired by sato on Ethereum mainnet, with a few game-theory adjustments around the deadline, the deployer payout, and the first-flipper incentive.
your position
connected as —
how it works, in plain words
buy = mint
You send ETH to the V4 pool. The hook intercepts the swap, prices it on its own bonding curve, and mints fresh SAT to you. There is no LP. The hook is the AMM.
sell = burn
You send SAT back through the same pool. The hook prices the trade on the inverse curve, burns your tokens, and pays you ETH from the reserves the curve has built up. Every wei ever paid in, minus what sellers have already pulled and what's earmarked for the deployer, sits in the hook.
K = 1 token, S = 100 ETH
Total supply approaches the asymptote K_SUPPLY = 1e18 wei = 1 whole token. Marginal price at curve start is S/K = 100 ETH/SAT. The 99% self-deprecation threshold sits at around 460 ETH cumulative inflow, which is reachable in real flow.
almost no admin
The token contract self-attests with a public RESTRICTIONS_FORBIDDEN = true flag. No owner, no pause, no blacklist, no upgrade path. The deployer's only privilege is the streaming fee described below; the deployer cannot freeze trading, change parameters, or block any address.
deployer streaming fee
Each time totalMintedFair crosses a new 10% bracket of K_SUPPLY (10%, 20%, 30%, ..., 90%), 1% of curve reserves at that moment is locked to the deployer. Nine brackets total. The 90 to 100% segment pays nothing here; the first-flipper bonus covers it. Deployer can withdraw any time, any number of times.
7 days to flip
Buys are allowed for BUY_PERIOD = 7 days from launch. If the curve hits 99% supply during that window, the flip happens naturally. If not, anyone can call forceFlipAfterDeadline() after day 7 and the curve locks at whatever level it's at. No more buys, ever.
anti-sniper window
For the first LAUNCH_BLOCKS = 150 blocks (about 30 minutes on mainnet), each wallet can spend at most 1 ETH cumulatively across all buys. After the window, only the standard 5 ETH per-tx cap applies. Combined with the inherited ±10% entropy multiplier on the first 100 blocks, the early curve is hostile to single-wallet snipes. Doesn't stop sybil; raises the cost of one.
first-flipper bonus
Whichever wallet's call triggers selfDeprecated earns a 1% bounty from curve reserves at the flip moment. Past the 7-day deadline the bounty grows by +1% per day, capped at 6%. Two side-games: race to be the buyer that pushes past 99% pre-deadline, or race to be the caller of forceFlipAfterDeadline() post-deadline (longer wait, bigger bounty, but someone else can take it first).
the curve, rendered
Forward: totalMinted(eth) = K · (1 − e−eth/S).
Inverse: eth(total) = −S · ln(1 − total/K).
K = 1 token, S = 100 ETH. The 99% line is where new mints lock forever.
Drag the slider to move along the curve.
scenarios: what's a $X stake worth?
Marginal price climbs 99× from curve start to the
99% flip. Smaller, earlier entries get the steepest multipliers
because they're minted on the cheap end of the curve and extract
on the expensive end of the inverse curve, if they're
first out at the flip. Every seller ahead of you takes a slice
of the reserves; late sellers eventually hit
InsufficientEthReserves.
your entry
Flip is at ~460 ETH cumulative. Anything past that
is impossible by construction (no more buys). At $3,500/ETH,
roughly $1.61M of inflow takes us to flip.
outcome
"Exit value" assumes you sell your full stake on the inverse curve once the curve has reached your target inflow. In practice you have to be ahead of every other seller, and reserves are bounded by cumulative curve ETH minus the deployer's accrued streaming fee and the first-flipper bonus.
five reference scenarios at $3,500/ETH
| entry | ETH in | SAT held | price after buy | exit @ flip* | multiple |
|---|---|---|---|---|---|
| $1,000 | 0.286 | 0.00286 SAT | $351k/SAT | $88,000 | 88× |
| $5,000 | 1.43 | 0.01419 SAT | $355k/SAT | $309,000 | 62× |
| $10,000 | 2.86 | 0.02817 SAT | $360k/SAT | $469,000 | 47× |
| $50,000 | 14.3 | 0.1331 SAT | $400k/SAT | $931,000 | 18.6× |
| $100,000 | 28.6 | 0.2484 SAT | $450k/SAT | $1.14M | 11.4× |
*Exit value assumes you're first out at the flip and the inverse
curve still has reserves. Reserves at flip are roughly
415 ETH after the streaming deployer fee and the 1%
first-flipper bonus. The whole table sums to far more than that.
That's the mathematical impossibility behind the bank run. Not
everyone can win.
trade
The trade interface goes live as soon as the contracts are deployed. Until then, the buy/sell panel below works as a simulator that quotes what the curve would do given the current state.
buy
ETH → SATmax 5 ETH per swap. cooldown 1 block before sell.
sell
SAT → ETHpost-99% the curve still buys back. reserves drain with every sell.
what happens at 99%
Once totalMintedFair ≥ 0.99 · K, the contract sets a
one-way selfDeprecated flag. From that block on, no
buy is ever allowed again. The bonding curve still buys back
from sellers. This is when the experiment shows what it actually is.
- phase 1 issuance. Buys mint, sells burn and refund. Price is a deterministic function of cumulative ETH. Anyone can quote the curve from outside. This is the state we're in.
- flip self-deprecation. At 99% of K, the gate slams. No new SAT will ever exist again. Supply can only shrink from this block forward.
- phase 2 race to exit. The curve still buys back from sellers, but reserves drain with every sell. Earlier exits get more ETH back. A bank run by design.
- phase 3 market. When curve reserves are gone, price discovery moves to secondary pools and OTC. The bonding-curve floor is gone. Whatever the experiment showed, it's now public history.
1SAT vs $sato
| $sato (upstream) | 1SAT (this fork) | |
|---|---|---|
| asymptote (K) | 21_000_000e18 (21M tokens) | 1e18 (1 whole token) |
| curve scale (S) | 500 ETH | 100 ETH |
| marginal price at eth = 0 | ~2.4 × 10⁻⁵ ETH/SAT | 100 ETH / SAT |
| ETH to reach 99% of supply | ~2,300 ETH | ~460 ETH |
| self-deprecation threshold | 99/100 · K | 99/100 · K (unchanged) |
| per-swap buy cap | 5 ETH | 5 ETH (unchanged) |
| launch-window per-wallet cap | none | 1 ETH per wallet for the first 150 blocks (~30 min) |
| deployer fee | none | streaming 1% per 10% bracket of K crossed (9 brackets, claimable any time) |
| buy deadline | none (buys forever, until 99%) | 7 days from deploy. After that, forceFlipAfterDeadline() |
| first-flipper bonus | none | 1% of reserves to whoever flips (+1%/day past deadline, cap 6%) |
| license | MIT | MIT, attribution preserved |
Compiler version, optimizer settings, EVM target, and the underlying curve math match upstream so the diff is auditable. The behaviour deltas are listed explicitly above; nothing else is changed. source on GitHub →
contracts
not yet deployed
not yet deployed
0x2888