THE MECHANISM,
IN ELEVEN LINKS.

GASLINE ($GSLN) is an ERC-20 token traded through a single Uniswap v4 pool against ETH. A v4 hook sits in front of that pool and decides what every swap costs.

The buy side is fixed at 1%. The sell side is dynamic between 1% and 4%, and it is not derived from the token's own market. It is derived from the state of Ethereum blockspace in the previous block.

Everything the hook collects is allocated to holders and paid out in native ETH. There is no treasury cut, no team fee, no marketing fee and no buyback.

A Uniswap v4 hook is a contract the pool calls at defined points in a swap. GASLINE uses the swap callbacks to read chain state and set the fee that applies to that swap.

Sequence

• A swap enters the pool and the pool calls the hook.
• The hook reads the header state of the previous block.
• Blockspace conditions are reduced to a single load score, 0 — 100.
• The score is mapped into the fee band. Buys skip the mapping and pay the fixed rate.
• The fee is taken inside the swap and accrued to the reward pool as ETH.

Nothing about this loop consults the GSLN chart. The only external input is the chain itself.

Blockspace is the scarce resource every Ethereum transaction competes for. Its price and saturation are visible directly in the block header, with no oracle in between.

Inputs read by the hook

• BASEFEE — the protocol-level price of gas, adjusted by EIP-1559 each block.
• GASUSED — how much of the block was actually consumed.
• GASLIMIT — the ceiling that block could have used.
• BLOBBASEFEE and excess blob gas — pressure from the EIP-4844 data market.

These four values describe how contested the chain was during the block that just closed. Congested chain, expensive exit. Quiet chain, cheap exit.

The raw header values live on very different scales, so the hook normalises each one and combines them into a single bounded score.

utilisation = gasUsed / gasLimit          → 0 … 1
feePressure = log(baseFee + 1) / log(43)  → 0 … 1
blobPressure = blobs / 9                  → 0 … 1

load = round(
    utilisation  * 50 +
    feePressure  * 34 +
    blobPressure * 16
)                                         → 0 … 100

Utilisation dominates because it is the hardest signal to fake: filling a block costs real gas. The logarithm on the base fee keeps a single spike from saturating the score.

The live value is on the network terminal.

The load score maps linearly into the fee band. The band is hard-bounded in the contract — the fee can never leave it.

sellFee = 1.00% + (load / 100) * 3.00%

load   0  →  1.00%
load  25  →  1.75%
load  50  →  2.50%
load  75  →  3.25%
load 100  →  4.00%

What the fee is not derived from

• GSLN price action.
• Holder activity or wallet age.
• Buy / sell ratio.
• Token volatility.
• Trade direction history.
• Trade size or the identity of the sender.

Buys are always 1%. There is no whitelist and no per-address exception.

The reference is always block N−1. A swap executing in block N is priced from a block that was sealed before the transaction existed.

This closes the obvious loop. If the fee were read from the current block, a seller could pad the block with their own gas to move their own price, or a searcher could bundle around it. Using the previous header makes the input immutable at execution time.

Consequences

• The exit cost is known before the transaction is sent.
• The current transaction cannot influence the data used to price itself.
• Two swaps in the same block pay the same fee, regardless of order.

100% of hook fees are allocated to holders. Fees are settled into native ETH and accrue pro-rata to GSLN balance.

• Rewards are paid in native ETH, never in GSLN, and never in a wrapper.
• Accrual is continuous — every swap that pays a fee adds to the pool.
• There is no staking step, no lock and no vesting. Holding is the position.

Because rewards arrive as ETH, a holder is never forced to sell the token to realise them.

Claims are pull-based: a holder withdraws their own ETH when they choose to, so nobody's transaction pays gas to push rewards to anyone else.

• Open /rewards and link a wallet.
• Pending, earned and claimed totals load for that address.
• CLAIM ETH withdraws the full pending balance in one transaction.
• Claiming does not change the GSLN balance or reset the position.

Supply is fixed at 100,000 GSLN. There is no mint function and no rebasing.

Components

• GSLN token — a plain ERC-20. No transfer tax, no blacklist, no pause switch.
• GASLINE hook — a Uniswap v4 hook bound to the GSLN / ETH pool. Reads block state, resolves the fee, routes the fee to the distributor.
• Reward distributor — holds pooled ETH, tracks pro-rata accrual, serves pull-based claims.

Fee path

swap → pool → hook.beforeSwap()
     → read header of block N-1
     → load score → fee
     → fee taken in-swap
     → settled as ETH
     → distributor accrual
     → holder claim

The fee band, the reference offset of one block and the 100% reward allocation are constants of the hook, not owner-adjustable parameters.

• Variable exit cost. Selling during congested blocks costs up to 4%. The fee is knowable in advance, but it is not constant.
• Correlated timing. Market-wide panic and network congestion often coincide, so exits tend to be more expensive exactly when volume spikes.
• Reward rate is not yield. Rewards depend entirely on trading volume. No volume, no ETH.
• Chain assumptions. The model reads EIP-1559 and EIP-4844 header fields. A future protocol change to those fields would require a redeploy of the hook.
• Smart contract risk. Hooks are new surface area. Audits reduce risk; they do not remove it.
• Pre-launch state. Contract figures are read from mainnet and render as a dash until the contracts exist. The blockspace panels model the mechanism so it can be inspected before launch; the fee and load they show switch to the hook's own values the moment it is deployed.