Fair Launch Platform Development

Fair Launch Platform Development

"Fair launch" means token launch without pre-sale, without team allocation, without VC investors with discounted tokens—all participants get tokens on equal terms from start. YFI (Yearn Finance) in 2020 was canonical: 30,000 tokens distributed purely through yield farming, André Cronje kept none for himself.

In practice, "fair" is spectrum. Completely fair launch is rare. More common: minimal team allocation (3-5%) + fair distribution mechanism for rest. Platform's task—implement distribution mechanism truly minimizing early insider advantage.

Liquidity Bootstrapping Pool (LBP): Core Mechanism

LBP (popularized by Balancer)—dynamic AMM pool where token weights change over time. Starting with high token weight (e.g., 96% TOKEN / 4% USDC), pool creates high initial price that organically decreases as weights change to final value (50/50).

LBP mechanics:
t=0:   weight [TOKEN: 96%, USDC: 4%] → high price
t=T/2: weight [TOKEN: 72%, USDC: 28%] → price decreases  
t=T:   weight [TOKEN: 50%, USDC: 50%] → final weight

Math: price = (reserve_USDC / weight_USDC) / (reserve_TOKEN / weight_TOKEN)

Solves bot/sniper problem: no fixed low price at launch that's immediately arb'd. Bots gain nothing buying early—price will be lower later. Creates natural price discovery.

Custom LBP Contract

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;
        
        return (collateralReserve * wToken * PRECISION) / (tokenReserve * wCollateral);
    }
    
    // Token purchase
    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 weighted AMM formula
        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());
    }
}

Using Balancer V2

Instead of custom LBP—use audited Balancer V2 LBP:

import { BalancerSDK } from "@balancer-labs/sdk"

const balancer = new BalancerSDK({
  network: Network.MAINNET,
  rpcUrl: "https://mainnet.infura.io/v3/...",
})

// LBP creation via Balancer V2
const lbpParams = {
  name: "My Token LBP",
  symbol: "MTK-LBP",
  tokens: [collateralAddress, tokenAddress].sort(),
  weights: ["0.04", "0.96"],        // initial: 4% USDC, 96% TOKEN
  endWeights: ["0.50", "0.50"],     // final: 50/50
  swapFeePercentage: "0.01",        // 1% swap fee
  startTime: Math.floor(Date.now() / 1000) + 3600, // 1 hour from now
  endTime:   Math.floor(Date.now() / 1000) + 3600 + 3 * 86400, // 3 days
}

Fair Launch Mechanisms

Batch Auction (Gnosis Auction / Fjord Foundry)

All participants submit bids during auction window. After closing—clearing price determined: single price at which demand equals supply. All buyers pay same price regardless of submission time.

Flow:
1. Window: 24-72 hours
2. Participants submit bid (amount USDC, min acceptable price)
3. After window: sort bids by price descending
4. Clearing price: minimum price where full allocation sells
5. Bids >= clearing price: execute at clearing price
6. Bids < clearing price: refunded

Advantage over LBP: no time pressure—no sense waiting for "right moment," everyone pays same price.

Vesting for Purchased Tokens

Fair launch doesn't mean immediate availability—else early buyers immediately dump. Standard: purchased tokens vest linearly 6-12 months.

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

Some platforms add whitelist for compliance. Merkle tree approach: off-chain list of approved addresses → on-chain Merkle root → user proves inclusion at participation.

Anti-Bot Mechanisms

Commit-reveal. Participants first commit hash of their bid, then reveal. Bots don't know other bids—can't optimize front-run.

Max contribution cap per address. Limits whale domination, but easily bypassed with multiple wallets.

Proof-of-Humanity or Gitcoin Passport. Requires on-chain identity verification. Costlier for users, but fairer.

Technical Stack

Contracts: Foundry + OpenZeppelin. LBP: Balancer V2 or custom. Frontend: wagmi + viem + React. Auction: Gnosis Auction (existing audited contract). Analytics: Dune Analytics for distribution tracking.

Development Process

Economic design (1 week). Choose mechanism (LBP vs batch vs hybrid), parameters (duration, weights, max cap), vesting schedule.

Development (3-5 weeks). Auction/LBP contract → vesting contract → admin controls (emergency pause) → 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 simple mechanics—minimal external audit.

Full platform (LBP + vesting + UI): 6-10 weeks.