PAMP TOKEN$PAMP

How the auction works

The entry price is fixed and the token rate is not. Each day is a fixed 86,400-second window in which anyone may buy 1 to 1,000 entries per transaction. An entry is worth 0.0001 ETH, paid as 0.00006 ETH with the transaction plus 0.00004 ETH worth of $FUEL taken from the buyer's wallet. There is no limit on how many transactions one address sends.

When the day closes, that day's emission is split across every entry sold that day:

Everyone who enters on a given day receives the same rate, so there is nothing to gain by timing a purchase within the day. The rate falls as the day sells more: a day that sells 10 entries pays ten times per entry what the same day would pay at 100. A day that sells nothing mints nothing, which is why final supply can end below the cap but never above it.

Entering and claiming are separate steps. Entering records your share; after the day closes you call claim(day), or claimMany for several days at once, and the contract mints your PAMP then. Unclaimed days do not expire.

The contract takes exactly the $FUEL an entry costs at the moment the transaction lands. The caller passes maxFuel, a cap on what may be taken, so a price move between quoting and landing cannot take more than the caller agreed to; the transaction reverts instead and nothing is spent.

Emission schedule

Daily emission decays geometrically at a factor of 0.997698, so day 1,000 emits exactly a tenth of day 1. The 1,000 daily amounts sum to exactly 100,000,000 PAMP and are stored on chain as a fixed table that v2 reuses unchanged.

Where each entry goes

Every entry splits its value in the same transaction, in fixed proportions the contract stores as constants:

Pricing the $FUEL share

Each entry takes 0.00004 ETH worth of $FUEL. Converting that value into a $FUEL amount needs a price, and the price has to survive two things: a genuine fast move on the 1-minute chart, and someone pushing the pool for a few blocks to make entries cheaper.

The price comes from the FUEL/WETH pool's own oracle, which records a data point every block the pool trades. The contract reads it two ways — the 10-second average and the 15-minute average — and charges whichever gives more $FUEL per entry:

• A fast drop is charged at once. If $FUEL falls 28% in one block, ten seconds later an entry takes about 35% more $FUEL. Measured on a fork of the live pool: 20 $FUEL per entry before, 27 after.
• A pump buys no discount. If $FUEL is pushed up 4x for a few blocks, the 10-second average says entries should be cheap, but the 15-minute average still applies. Measured: 20 $FUEL per entry before a 1 ETH pump, 19 after — the long average absorbs ten of its 900 seconds.
• Entries never pause for a price move. The only thing that stops pricing is a pool oracle with less than 15 minutes of history, which was filled before launch. A collapse to a tenth of today's price simply means ten times the $FUEL per entry.

The contract also keeps its own price log. Every entry, and anyone who calls poke(), stores a sample of the two averages and the $FUEL per entry being charged — at most one sample every 10 seconds. The log is readable on chain (samples, latestSample, samplesRange) and each sample emits an event, so the price the auction charged at any moment is a matter of record rather than a screenshot.

A manipulation that did work would have to hold the pool's price for a full 15 minutes against anyone who trades it back, paying the pool's 1% fee and impact both ways, for a discount capped at the size of the move on 40% of the entries bought inside that window. At the entry sizes involved that is a losing trade.

The buy and burn

$MORE exposes neither burn nor burnFrom — it is a minimal proxy — so burning means buying it and transferring it to 0x…dEaD. The $MORE pools on this chain are thin, so each burn is split across five routes rather than pushed through one:

First hops run on Uniswap V3 because those pools are far deeper than their v4 equivalents on this chain, and because V3 carries an observation buffer the contract can read a real TWAP from. All five second hops are v4 pools behind a single hook.

Splitting is worth its complexity. Measured against live chain state:

A bad pool must never cost someone their entry

The burner runs inline inside every entry, so a failing route has to degrade rather than revert. Each leg executes behind a self-call wrapped in try/catch; a leg that reverts parks its ETH instead of taking the entry down with it. Three rules keep legs from failing in the first place:

• Self-throttling. Rather than reverting when a swap would move the price too far, each hop computes the largest input that stays within maxImpactBps (150) at current liquidity and swaps only that.
• Price sanity. V3 hops check spot against the pool's own TWAP. v4 pools have no oracle, so those hops compare spot against a reference tick the contract maintains, which may only drift at a bounded rate between burns.
• minLegAmount is zero. Every entry burns immediately and nothing accumulates. A 1,000-entry transaction burned 1.45M $MORE and 20,035 $FUEL in one go on a fork of the live chain.

flush() is permissionless and retries every parked leg, paying its caller 1.5% of what it burns. That is the mechanism by which parked dust and temporarily broken routes drain without anyone privileged having to act.

Staking

Claimed PAMP can be locked in a staking contract that is a fork of the $MORE staking contract on this chain, whose verified source was taken from Sourcify. The mechanics are the original's; the token is $PAMP and the lock range is narrower.

• Lock 7 to 1,000 days. Any amount; several stakes per address.
• Leaving early forfeits the unserved share. A stake at 25% of its term keeps 25% of principal plus rewards; the other 75% is the penalty.
• 14 days of grace after unlock, then a late penalty grows linearly and reaches 100% a further 700 days on. A stake left for years is eventually worth nothing to its owner and everything to the others.
• Every penalty is recycled to the stakes still open, pro rata by amount, through a cumulative reward-per-token index. If nobody is staked when a penalty is paid, it waits for the next stake to open.
• That is the only source of rewards. There is no emission, no fixed rate and no reward budget. A staking pool where nobody ever leaves early pays nothing.

There is no owner. The original's one owner power — sweeping tokens sent to the contract by mistake — is permissionless here and pays the PAMP fund, and can never touch $PAMP. Because $PAMP supports EIP-2612, stakeWithPermit opens a stake in one transaction.

Parameters

Three new contracts, deployed on Robinhood Chain (chain 4663) on 20 September 2026, plus two reused from v1. Every parameter below is a constant or immutable. None can be changed after deployment, by anyone. Contract addresses are published on the dashboard, which reads each one back from the chain and flags any mismatch.

There is no owner, no admin role, no pause and no upgrade path in any of the three v2 contracts. The token's configure function, which names the auction as the only minter, is callable by anyone exactly once and has already been called. The test suite is 104 tests: 98 unit and invariant tests, plus fork tests that run real swaps and real $FUEL burns against live chain state, including a 1,000-entry transaction, a 28% one-block dump and a 1 ETH pump. A read-only verification script audits the live deployment and reverts on the first mismatch.