a pool that repairs itself
every time it trades.
BaseLine is a Uniswap v4 hook ERC-20 with band-based self-defending liquidity. Every buy and sell fee recycles into 100 sequential liquidity bands, building a whale-resistant floor that strengthens with every swap.
The Problem
Most tokens are weak on the downside. They can move up fast, but the liquidity below price is usually thin. Once sellers show up, price falls through weak support because the pool is not actively repairing itself.
BaseLine solves this through three problems.
Flippers extract from thin pools
Most launches reward early flippers. They buy, sell into later buyers, and leave the pool weaker.
BaseLine routes every buy and sell fee back into liquidity bands. Fast buy-sell behavior is also hit with a Skim Fee, which makes early flipping less attractive and sends that value into plunge protection.
So flippers do not just drain the pool. They help fund the downside structure.
Large exits break weak markets
Normal pools often look liquid until a whale exits. A few large sells can cause heavy price impact because there is not enough liquidity below price.
BaseLine builds thicker downside bands over time. As transactions increase, more value is routed into lower bands, making large exits less destructive.
The goal is a whale-resistant floor, not by blocking sells, but by making the pool deeper.
Most tokens have no real floor
Most tokens can fall as far as liquidity allows. There is no built-in mechanism accumulating support below price.
BaseLine continuously sends fees into the bands below the current price. Over time, this creates a stronger floor where pushing price lower becomes harder.
The more the token trades, the stronger the downside liquidity gets.
Pool Architecture
BaseLine does not use one passive liquidity pool. It splits the price curve into 100 sequential liquidity bands, where each band represents a fixed range of cumulative pool ETH.
The system is based on a constant-product style curve:
realTokens(eth) = K / (V + eth) Where: V = virtual ETH eth = cumulative ETH inside the pool curve K = curve constant realTokens(eth) = tokens remaining at that ETH level
In this model, price is not treated as one flat pool. Price is mapped across a curve, and that curve is sliced into bands.
Band 0 = 0 → 4.304 ETH Band 1 = 4.304 → 8.608 ETH Band 2 = 8.608 → 12.912 ETH ... Band 99 = 426.096 → 430.4 ETH
The band index can be calculated as:
currentBand = floor(cumulativeETH / 4.304)
So if the pool has 150 ETH of cumulative depth:
currentBand = floor(150 / 4.304) currentBand ≈ 34
That means price is trading around Band 34, and all bands below it form the downside liquidity structure.
Price Curve
The price curve starts at a low launch price and rises as cumulative ETH increases.
Launch price = $0.01
The curve is designed so that as more ETH enters the system, the price moves into higher bands. The green curve represents price increasing against cumulative pool ETH.
In simplified form:
price(eth) = dETH / dTokens
Since token supply remaining decreases as ETH increases, price rises along the curve.
The important part:
price moves upward through bands, but every transaction can also strengthen the liquidity below the current band.
This is what makes BaseLine different from a normal pool. The pool is not just where trades happen. It is also the structure that stores downside protection.
Token Allocation Per Band
Tokens are not distributed equally across all bands.
The first band receives the largest token allocation, and each later band receives less. The allocation decreases geometrically across the 100 bands.
From the model:
Band 0 = 600,000 BaseLine Band 1 = 150,000 BaseLine Remaining bands = geometrically decreasing allocation
This means early bands are deeper in token supply, while higher price bands become progressively thinner in token allocation.
A simplified allocation model looks like:
tokensInBand[n] = tokensInBand[n - 1] × decayRate
Or:
B_n = B_0 × r^n Where: B_n = token allocation in band n B_0 = token allocation in band 0 r = geometric decay rate n = band number
This creates a curve where lower bands hold more tokens and higher bands hold less tokens.
Liquidity Bands
Each band is its own Uniswap v4 LP position.
At deployment, these bands are seeded as single-sided BaseLine liquidity. As price moves upward, the active band changes.
Active band = band where current price is trading Bands below active band = downside support Bands above active band = future upside liquidity
Example:
Current band = 34 Bands 0–33 = downside liquidity Band 34 = active trading zone Bands 35–99 = future upside ranges
This matters because BaseLine routes liquidity based on where price currently is.
Band Targets & Band Health
Band Targets And Band Debt
Each band has a target ETH amount.
targetETH[n] = desired ETH for band n currentETH[n] = actual ETH inside band n
If a band has less ETH than its target, the missing amount is Band Debt.
BandDebt[n] = max(0, targetETH[n] - currentETH[n])
Example:
Band 10 target = 10 ETH Band 10 current = 7 ETH BandDebt[10] = 10 - 7 BandDebt[10] = 3 ETH
The system uses Band Debt to decide where fees should go.
Higher debt means the band needs more liquidity.
routingWeight[n] = BandDebt[n] / totalDebt
So if one band has 60% of all missing ETH, it receives more of the next fee flow.
Band Health Score
Band Health Score measures how healthy the current liquidity zone is.
The score compares actual ETH against desired ETH in the current band and the band below it.
currentHealth = currentETH[currentBand] / targetETH[currentBand] lowerHealth = currentETH[currentBand - 1] / targetETH[currentBand - 1]
Then the system combines both into one score.
Example structure:
BandHealthScore = (0.40 × currentHealth) + (0.60 × lowerHealth)
The lower band can be weighted more heavily because it acts as the first downside support zone.
If the score is high, the sell fee stays low.
If the score is low, the sell fee rises.
sellFee = clamp(0%, 5%, f(1 - BandHealthScore))
TLDR:
Buy Fees
BaseLine applies a constant 1.25% buy-side fee on every buy.
This fee is not sent to a team wallet, marketing wallet, or external treasury. It is routed back into the liquidity structure and used to strengthen the bands below the current price.
buyFee = buyAmount × 0.0125
Example:
buyAmount = 10 ETH buyFee = 10 × 0.0125 buyFee = 0.125 ETH
That 0.125 ETH is captured by the hook and recycled into the band system.
Directional Liquidity Routing
Buy fees are routed into the liquidity bands below the current active band.
eligibleBands = bands[0 → currentBand - 1]
If the current active band is Band 34:
eligibleBands = bands[0 → 33]
This means buy pressure does two things at once:
So price can move up, but the structure underneath it also gets stronger.
Buy Fee Weighting
Buy fees do not need to be split equally across every lower band.
The system prioritizes the bands that matter most:
A simple routing model:
nearestBandShare = buyFee × 60% debtWeightedShare = buyFee × 40%
The debt-weighted share is distributed based on missing ETH inside eligible bands.
BandDebt[n] = max(0, targetETH[n] - currentETH[n]) routingWeight[n] = BandDebt[n] / totalDebtAcrossEligibleBands amountToBand[n] = debtWeightedShare × routingWeight[n]
So if a lower band is more underfunded, it receives more of the next buy fee.
Example Buy Flow
Assume:
buyAmount = 10 ETH buyFee = 1.25% currentBand = 34 capturedFee = 0.125 ETH
The system identifies the eligible downside bands:
eligibleBands = bands[0 → 33]
Then routes the fee:
60% → Band 33 40% → weakest lower bands by Band Debt
In numbers:
Band 33 receives = 0.125 × 60% Band 33 receives = 0.075 ETH Debt-weighted bands receive = 0.125 × 40% Debt-weighted bands receive = 0.050 ETH
That 0.050 ETH is split across the weakest lower bands based on their Band Debt.
Launch Phase Edge Case
During the earliest phase of the pool, price is still inside Band 0.
Since Band 0 is the first band, there is no lower band to route buy fees into yet.
currentBand = 0 eligibleBands = none
Instead of wasting the buy fee or sending it somewhere else, the hook temporarily parks it.
pendingTaxETH += buyFee
Once price crosses out of Band 0 into Band 1, the parked ETH is flushed into the normal routing system.
if currentBand > 0:
flush pendingTaxETH into liquidity bandsThis means no buy-side fee is wasted during launch.
Parking + Flush Example
Assume the pool is newly deployed and still inside Band 0.
currentBand = 0 pendingTaxETH = 0 hookETH = 0
buyAmount = 1 ETH buyFee = 1 × 0.0125 buyFee = 0.0125 ETH currentBand = 0 pendingTaxETH = 0.0125 ETH hookETH = 0.0125 ETH
buyAmount = 2 ETH buyFee = 2 × 0.0125 buyFee = 0.025 ETH currentBand = 0 pendingTaxETH = 0.0375 ETH hookETH = 0.0375 ETH
buyAmount = 5 ETH buyFee = 5 × 0.0125 buyFee = 0.0625 ETH currentBand = 1 pendingTaxETH + buyFee = 0.1000 ETH
The hook now flushes the parked balance:
0.1000 ETH → Band 0 LP pendingTaxETH = 0
Net effect:
zero buy fee wasted during the launch phase
Sell Fees
BaseLine uses a dynamic sell-side fee that moves between 0% and 5%.
The fee is calculated every swap from the health of the liquidity band directly below the current price. If that downside band is strong, selling is cheap. If that downside band is weak, selling becomes more expensive.
sellFee = 0% → 5%
The logic is simple:
The sell fee is not random. It is a direct response to the strength of the band that price would fall into next.
Band Health Score
The sell fee is based on the Band Health Score of the band directly below current price.
For each band, the system checks how reinforced that band is compared to its initial seeded liquidity.
reinforcementBps[i] =
((L_total[i] - L_seed[i]) / L_seed[i]) × 10,000
Where:
L_seed[i] = initial liquidity seeded into band i
L_total[i] = current liquidity inside band i
reinforcementBps[i] = extra liquidity gained by the bandIf a band is exactly at its starting liquidity:
L_total[i] = L_seed[i] reinforcementBps[i] = 0
If a band has grown 20% above its starting liquidity:
L_total[i] = 1.20 × L_seed[i] reinforcementBps[i] = 2,000 bps
That means the band has reached the reinforcement target.
The health score is capped between 0 and 10,000 bps:
healthBps[i] =
clamp(reinforcementBps[i] / threshold, 0, 10,000)With a 1.2x reinforcement target:
threshold = 2,000 bps
So:
Health = 0 bps → band is only at seed liquidity Health = 10,000 bps → band is reinforced to target or higher
In plain terms:
0% health = no reinforcement 50% health = halfway to target reinforcement 100% health = fully reinforced band
Target Sell Fee Formula
Once the system knows the health of the band below current price, it calculates the target sell fee.
targetSellFeeBps =
MAX_SELL_FEE_BPS × (10,000 - healthBps) / 10,000
Where:
MAX_SELL_FEE_BPS = 500 bps
500 bps = 5%So the weaker the band below price, the closer the sell fee moves toward 5%.
The healthier the band below price, the closer the sell fee moves toward 0%.
Core logic:
sell fee = inverse function of band-below health
Weak support means higher fee. Strong support means lower fee.
Why The Band Below Matters
The band directly below current price is the first downside support zone.
If price starts moving down, that is the band sellers hit first. So BaseLine prices sell pressure based on the health of that specific band.
activeBand = current trading range supportBand = activeBand - 1
If the support band is weak, the sell fee increases.
If the support band is reinforced, the sell fee decreases.
This makes the sell fee directly tied to the area being stressed.
Sell Fee Routing
100% of the sell fee is routed into the band directly below the current active band.
supportBand = currentBand - 1 amountToSupportBand = totalSellFee
There is no split across multiple bands.
There is no treasury routing.
There is no team wallet routing.
The sell fee reinforces the exact band that protects the next move down.
This is the cleanest version of the design:
sell pressure → fee collected → band below current price gets stronger
So every sell funds the same plunge-protection layer that sellers are pushing against.
Tax Smoothing
The sell fee does not jump instantly from low to high.
Even if the target sell fee moves from 1% to 5%, the applied fee moves gradually. This prevents sudden one-swap fee spikes and makes the system harder to manipulate.
appliedFee(t+1) =
appliedFee(t) + min(targetFee - appliedFee(t), MAX_FEE_DELTA_BPS)With the current model:
MAX_FEE_DELTA_BPS = 50 bps 50 bps = 0.50%
So the sell fee can only move by 0.50% per swap.
Example:
Current applied fee = 1.00% Target fee = 5.00% Max movement = 0.50% Next applied fee = 1.50%
Then:
Swap 1: 1.00% Swap 2: 1.50% Swap 3: 2.00% Swap 4: 2.50% ...
This prevents bots from manufacturing a one-swap sell-fee spike.
Example Sell Flow
Assume:
currentBand = 34 supportBand = 33 MAX_SELL_FEE_BPS = 500 supportBandHealth = 50%
The target fee is:
targetSellFeeBps =
500 × (10,000 - 5,000) / 10,000
targetSellFeeBps = 250 bps
targetSellFee = 2.50%If the sell-side fee collected is 1 ETH:
totalSellFee = 1 ETH
Then the full amount routes to the band below:
1 ETH → Band 33
So the sell directly strengthens the next downside support band.
Net Effect
The sell fee is a defensive routing mechanism.
It does three things:
When the band below price is healthy, sellers pay less.
When the band below price is weak, sellers pay more, and that extra value repairs the exact band under stress.
Skim Fee
BaseLine adds a Skim Fee on top of the normal dynamic sell fee.
This fee applies when the same wallet buys and then sells too quickly. It is designed to make fast roundtrip trading expensive, especially for short-term flippers and bots trying to extract from thin liquidity.
The Skim Fee is not a separate treasury charge. It routes back into the same plunge-protection system and strengthens the liquidity band below current price.
How It Works
When a wallet buys, the system records the time of that buy.
lastBuyTime[tx.origin] = block.timestamp
If the same wallet sells shortly after buying, an extra sell-side fee is added.
timeSinceBuy = block.timestamp - lastBuyTime[tx.origin]
The shorter the time since the last buy, the higher the Skim Fee.
In basis points:
< 5 minutes = +200 bps < 1 hour = +100 bps < 6 hours = +50 bps ≥ 6 hours = +0 bps
Total Sell Fee Cap
The Skim Fee is added on top of the dynamic sell fee, but total sell-side fees are capped.
totalSellFee = bandHealthFee + skimFee totalSellFee = min(totalSellFee, 7.00%)
So even if the band-health fee is at the max 5% and the Skim Fee adds another 2%, the user cannot be charged more than 7% total on the sell.
maxBandHealthFee = 5.00% maxSkimFee = 2.00% maxTotalSellFee = 7.00%
Example
Assume a wallet buys and then sells within 5 minutes.
bandHealthFee = 5.00% skimFee = 2.00%
The total sell-side fee becomes:
totalSellFee = 5.00% + 2.00% totalSellFee = 7.00%
The wallet also paid the buy-side fee when entering:
buyFee = 1.25%
So the total roundtrip cost is at least:
roundtripCost = buyFee + totalSellFee roundtripCost = 1.25% + 7.00% roundtripCost = 8.25%
This is before slippage.
So a bot or flipper needs more than 8.25% upside just to break even on a fast roundtrip.
Why It Matters
Without a Skim Fee, fast traders can repeatedly buy, sell, and abuse short-term band movement.
BaseLine makes that behavior expensive.
The goal is not to block selling. The goal is to stop short-term extraction from being cheap.
That extra fee is routed back into plunge protection, meaning short-term flippers help reinforce the floor they are trying to exit through.