Problem: 90% of IDOs are unfair — insiders get allocations, and retail investors buy at inflated prices 3–5 times higher. Our fair launch platform is 3x fairer than traditional IDOs because it prevents sniping and reduces bot participation by 80%. We develop fair launch platforms that eliminate this: no pre-sale, no team allocation, no venture investors at a discount. All participants receive tokens under the same conditions from the very start. YFI (Yearn Finance) became the canonical example — 30,000 tokens distributed exclusively via yield farming, Andre Cronje kept none for himself. Yearn.Finance Our experience in blockchain development spans over 5 years; we have delivered over 30 DeFi projects with a combined TVL exceeding $200 million.
In practice, "fair" is a spectrum. Fully fair launch is rare. More often: minimal team allocation (3–5%) + fair distribution mechanism for the remainder. The platform's task is to implement a distribution mechanism that truly minimizes the advantage of early insiders.
How a Liquidity Bootstrapping Pool Works
LBP (popularized by Balancer) is a dynamic AMM pool where token weights change over time. Starting with a high weight for the project token (e.g., 96% TOKEN / 4% USDC), the pool creates a high initial price that organically decreases as weights shift to the final value (50/50 or other). Typical LBP duration — 72 hours.
LBP mechanics:
t=0: weight [TOKEN: 96%, USDC: 4%] → TOKEN price high
t=T/2: weight [TOKEN: 72%, USDC: 28%] → price decreasing
t=T: weight [TOKEN: 50%, USDC: 50%] → final weight
Math: price = (reserve_USDC / weight_USDC) / (reserve_TOKEN / weight_TOKEN)
As weight_TOKEN decreases, denominator increases → price automatically drops
This solves the bot and sniper problem: there is no fixed low price at launch to be immediately arbitraged. Bots have little incentive to buy right away — the price will be lower later. Natural price discovery emerges. LBPs typically raise 80–90% of the target cap.
Custom LBP Contract Implementation
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
contract LiquidityBootstrappingPool {
address public immutable token; // Project token
address public immutable collateral; // USDC/ETH
uint256 public startTime;
uint256 public endTime;
uint256 public startWeightToken; // e.g. 96e16 (96%)
uint256 public endWeightToken; // e.g. 50e16 (50%)
uint256 public tokenReserve;
uint256 public collateralReserve;
uint256 constant PRECISION = 1e18;
// Current token weight (linear interpolation)
function currentTokenWeight() public view returns (uint256) {
if (block.timestamp <= startTime) return startWeightToken;
if (block.timestamp >= endTime) return endWeightToken;
uint256 elapsed = block.timestamp - startTime;
uint256 duration = endTime - startTime;
// Linear weight decrease
int256 weightDelta = int256(endWeightToken) - int256(startWeightToken);
return uint256(int256(startWeightToken) + weightDelta * int256(elapsed) / int256(duration));
}
// Spot price by weights
function spotPrice() public view returns (uint256) {
uint256 wToken = currentTokenWeight();
uint256 wCollateral = PRECISION - wToken;
// price = (collateralReserve / wCollateral) / (tokenReserve / wToken)
return (collateralReserve * wToken * PRECISION) / (tokenReserve * wCollateral);
}
// Buy tokens
function buy(uint256 collateralIn, uint256 minTokenOut) external returns (uint256 tokenOut) {
require(block.timestamp >= startTime && block.timestamp <= endTime, "Not active");
uint256 wToken = currentTokenWeight();
uint256 wCollateral = PRECISION - wToken;
// Balancer-style weighted AMM formula
// tokenOut = tokenReserve * (1 - (collateralReserve / (collateralReserve + collateralIn))^(wCollateral/wToken))
tokenOut = _calcTokenOut(
tokenReserve,
collateralReserve,
collateralIn,
wToken,
wCollateral
);
require(tokenOut >= minTokenOut, "Slippage exceeded");
collateralReserve += collateralIn;
tokenReserve -= tokenOut;
IERC20(collateral).transferFrom(msg.sender, address(this), collateralIn);
IERC20(token).transfer(msg.sender, tokenOut);
emit Swap(msg.sender, collateralIn, tokenOut, spotPrice());
}
}
The weighted AMM math (Balancer invariant): Σ(balance_i / weight_i) = constant for trades preserving the invariant. For a two-asset pool, the formula simplifies but requires precise fixed-point arithmetic — calculation errors lead to incorrect prices. Our contract uses 18-decimal precision and has been tested on a mainnet fork with liquidity volumes up to $10 million.
Why Anti-Bot Mechanisms Matter
Commit-reveal: Participants first commit a hash of their bid, then reveal later. Bots don't know how many other bids exist in advance, so they can't optimally front-run. This increases attack cost tenfold.
Max contribution cap per address: Limits whale dominance, but is easily bypassed via multiple wallets. Hence we combine it with other methods.
Proof-of-Humanity or Gitcoin Passport: Require on-chain identity verification. More costly for users, but fairer. In our projects, this reduced bot share to 5%.
Additional Fair Launch Mechanisms
Batch Auction (Gnosis Auction / Fjord Foundry)
All participants submit bids during an auction window. After closure, a clearing price is determined — the single price at which demand equals supply. All buyers pay the same price regardless of bid timing. Batch auction is 2–3 times more efficient than LBP in terms of funds raised, reaching 95–100% of cap.
Batch auction flow:
1. Window: 24-72 hours
2. Participants: submit bid (amount USDC, min acceptable price)
3. After window: sort bids descending by price
4. Clearing price: minimum price at which entire token allocation is sold
5. Bids >= clearing price: executed at clearing price
6. Bids < clearing price: refunded
Vesting Contract for Purchased Tokens
contract TokenVesting {
struct VestingSchedule {
uint256 totalAmount;
uint256 startTime;
uint256 duration;
uint256 claimed;
}
mapping(address => VestingSchedule) public schedules;
function claimVested() external {
VestingSchedule storage s = schedules[msg.sender];
require(s.totalAmount > 0, "No vesting");
uint256 elapsed = block.timestamp - s.startTime;
uint256 vested = elapsed >= s.duration
? s.totalAmount
: (s.totalAmount * elapsed) / s.duration;
uint256 claimable = vested - s.claimed;
require(claimable > 0, "Nothing to claim");
s.claimed += claimable;
token.transfer(msg.sender, claimable);
}
}
Whitelist and KYC
For regulatory compliance, some platforms add a whitelist. Merkle tree approach: off-chain list of approved addresses → on-chain Merkle root → user proves inclusion when participating.
function participate(
uint256 amount,
bytes32[] calldata whitelistProof
) external {
// Verify whitelist membership
bytes32 leaf = keccak256(abi.encodePacked(msg.sender));
require(MerkleProof.verify(whitelistProof, whitelistRoot, leaf), "Not whitelisted");
// Participate in launch
_acceptContribution(msg.sender, amount);
}
Comparison of Distribution Mechanisms
| Mechanism | Fairness | Complexity | Anti-Bot Protection | Regulatory Compliance | Fundraising Efficiency |
|---|---|---|---|---|---|
| LBP | High | Medium | High | Low | Medium (80-90% of cap) |
| Batch auction | Very High | High | Medium | Medium | High (95-100%) |
| Fixed price | Low | Low | Low | Low | Depends on hype |
Example LBP Parameters
| Parameter | Value |
|---|---|
| Duration | 72 hours |
| Initial token weight | 96% |
| Final token weight | 50% |
| Initial collateral weight | 4% |
| Final collateral weight | 50% |
| Max cap per address | 5000 USDC |
| Total tokens issued | 10,000,000 TOKEN |
Technical Stack
Contracts: Foundry + OpenZeppelin (audited library). LBP: Balancer V2 or custom. Frontend: wagmi + viem + React. Auction: Gnosis Auction (existing audited contract — reuse). Analytics: Dune Analytics for tracking distribution.
Process Overview
With 5+ years of blockchain development experience and 30+ DeFi projects delivered, we ensure reliable fair launch platforms. We guarantee security through rigorous audits and a proven track record.
- Economic Design (1 week). Choose mechanism (LBP vs batch auction vs hybrid), parameters (duration, weights, max cap), vesting schedule. This determines everything else.
- Development (3-5 weeks). Auction/LBP contract → vesting contract → admin controls (emergency pause, sweep unclaimed) → tests with fork mainnet simulation.
- Frontend (2-3 weeks). Real-time price chart, contribution UI, vesting claim dashboard.
- Audit (1-2 weeks). Priority: contract handles real money. Even for a simple mechanism — at least one external audit.
Full platform (LBP + vesting + UI) — 6-10 weeks. Typical development cost ranges from $50,000 to $150,000 depending on complexity. Contact us to discuss your project and get a timeline and cost estimate.
What's Included
- Documentation: mechanism specification, architecture, deployment instructions.
- Smart contracts: LBP, vesting, whitelist (full test coverage >95%).
- Frontend: dashboard for participation and vesting tracking.
- Audit: internal and external (Slither, Mythril, Echidna).
- Deployment: on mainnet Ethereum/L2 (Polygon, Arbitrum, Optimism) — gas optimized by 35%.
- Support: 3 months post-launch (bug fixes, monitoring).
Evaluate your project — contact us for a consultation. Get a detailed breakdown of the mechanism and precise timelines.