Fee Structure

// User sends 100 ETH to buy tokens
const userSends = 100;

// Calculate 1% protocol fee
const totalFee = userSends * 0.01; // 1 ETH

// Split fee
const creatorFee = totalFee * 0.3; // 0.3 ETH (30%)
const platformFee = totalFee * 0.7; // 0.7 ETH (70%)

// Net to curve for trading
const netAmount = userSends - totalFee; // 99 ETH

// Calculate tokens from curve
const tokensOut = calculateBuyReturn(99);

// Update state
accumulatedCreatorFees += creatorFee; // 0.3 ETH saved for creator
transferToPlatform(platformFee); // 0.7 ETH sent immediately
transferToUser(tokensOut); // Tokens to buyer

function buy(address buyer, uint256 minTokensOut)
    external payable returns (TradeResult memory) {

    // 1. Calculate fees
    uint256 totalFee = msg.value * PROTOCOL_FEE_BPS / BASIS_POINTS;
    uint256 creatorFee = totalFee * CREATOR_SHARE_BPS / BASIS_POINTS;
    uint256 platformFee = totalFee - creatorFee;
    uint256 netAmount = msg.value - totalFee;

    // 2. Calculate tokens
    uint256 tokensOut = calculateBuyReturn(netAmount);
    require(tokensOut >= minTokensOut, "Slippage");

    // 3. Update state
    s_accumulatedCreatorFees += creatorFee;
    updateReserves(netAmount, tokensOut);

    // 4. Execute transfers
    IERC20(s_token).safeTransfer(buyer, tokensOut);
    s_factory.call{value: platformFee}("");

    return TradeResult(tokensOut, totalFee, creatorFee, platformFee);

	// NOTE: this is a pseudo representation, see real implementation at each chain's respective contracts
}

// User sells 10,000,000 tokens
const tokensSold = 10_000_000;

// Calculate gross native out (before fees)
const grossNative = calculateSellReturn(tokensSold); // 5 ETH

// Calculate 1% fee on gross
const totalFee = grossNative * 0.01; // 0.05 ETH

// Split fee
const creatorFee = totalFee * 0.3; // 0.015 ETH (30%)
const platformFee = totalFee * 0.7; // 0.035 ETH (70%)

// Net to user
const userReceives = grossNative - totalFee; // 4.95 ETH

// Update state
accumulatedCreatorFees += creatorFee; // 0.015 ETH saved
transferToPlatform(platformFee); // 0.035 ETH sent
transferToUser(userReceives); // 4.95 ETH to seller

function sell(address seller, uint256 tokenAmount, uint256 minNativeOut)
    external returns (TradeResult memory) {

    // 1. Calculate gross native (before fees)
    uint256 grossNative = calculateSellReturn(tokenAmount);

    // 2. Calculate fees
    uint256 totalFee = grossNative * PROTOCOL_FEE_BPS / BASIS_POINTS;
    uint256 creatorFee = totalFee * CREATOR_SHARE_BPS / BASIS_POINTS;
    uint256 platformFee = totalFee - creatorFee;
    uint256 nativeOut = grossNative - totalFee;

    require(nativeOut >= minNativeOut, "Slippage");

    // 3. Update state (use GROSS for reserves)
    s_accumulatedCreatorFees += creatorFee;
    updateReserves(grossNative, tokenAmount);

    // 4. Execute transfers
    IERC20(s_token).safeTransferFrom(seller, address(this), tokenAmount);
    seller.call{value: nativeOut}("");
    s_factory.call{value: platformFee}("");

    return TradeResult(nativeOut, totalFee, creatorFee, platformFee);

	// NOTE: this is a pseudo representation, see real implementation at each chain's respective contracts
}

// Token bonded with 114.35 ETH liquidity (determined by k)
const bondingLiquidity = 114.35;
const reservedTokens = 150_000_000;

// Calculate 12% migration fee
const migrationFee = bondingLiquidity * 0.12; // 13.72 ETH

// Split fee
const creatorFee = migrationFee * 0.6; // 8.23 ETH (60%)
const platformFee = migrationFee * 0.4; // 5.49 ETH (40%)

// Net liquidity to DEX
const liquidityToDEX = bondingLiquidity - migrationFee; // 100.63 ETH

// Execute migration
accumulatedCreatorFees += creatorFee; // 8.23 ETH saved for creator
transferToPlatform(platformFee); // 5.49 ETH sent
migrateToDEX(liquidityToDEX, reservedTokens); // Create LP

function migrate(address migrator) external returns (address pool, string memory dex) {
    require(s_bonded, "Not bonded");
    require(!s_graduated, "Already graduated");

    uint256 nativeLiquidity = s_realNativeReserves;
    uint256 tokenLiquidity = 150_000_000 * 10**18;

    // Calculate migration fee (12%)
    uint256 migrationFee = nativeLiquidity * MIGRATION_FEE_BPS / BASIS_POINTS;
    uint256 creatorFee = migrationFee * CREATOR_SHARE_MIGRATION_BPS / BASIS_POINTS;
    uint256 platformFee = migrationFee - creatorFee;
    uint256 netLiquidity = nativeLiquidity - migrationFee;

    // Update state
    s_graduated = true;
    s_accumulatedCreatorFees += creatorFee;
	// Clear reserves states here
	// ......

    // Execute migration
    s_factory.call{value: platformFee}("");
    IERC20(s_token).safeTransfer(migrator, tokenLiquidity);
    (pool, dex) = IDEXMigrator(migrator).migrate{value: netLiquidity}(
        s_token, netLiquidity, tokenLiquidity
    );

    emit TokenMigrated(s_token, pool, dex, netLiquidity, tokenLiquidity, migrationFee, creatorFee, platformFee);

	// NOTE: this is a pseudo representation, see real implementation at each chain's respective contracts
}