Our Approach

In DeFi, liquidity is everything—but most platforms waste it by burning it too soon. At Flaunt, we do it differently. Our liquidity management system keeps liquidity productive, recycles it from inactive tokens, and turns it into rewards for the community.

Our Smarter Approach to Liquidity Management

1. Burning Liquidity Only for Successful Tokens

We only burn liquidity for tokens that reach a $1 million market cap. Why? Because those tokens have proven their value in the market. Until they hit that milestone, their liquidity tokens remain locked in our Liquidity Manager for security and transparency.

This ensures we’re not wasting valuable liquidity on projects that don’t take off.

function sendTokenToDead

function sendTokenToDead(address poolToken) internal {
        uint256 tokenId = poolTokenToTokenId[poolToken];

        require(tokenId != 0, "No LP found");
        require(!isLiquidityRemoved[tokenId], "Already removed");

        // Step 1: Collect fees and route to protocol & creator
        collectAllFees(tokenId);

        // Step 2: Burn the NFT by sending to dead address
        nonfungiblePositionManager.safeTransferFrom(
            address(this),
            0x000000000000000000000000000000000000dEaD,
            tokenId
        );

        // Step 3: Mark as removed and clean up state
        isLiquidityRemoved[tokenId] = true;
        delete poolTokenToTokenId[poolToken];
        delete deposits[tokenId];
    }

2. Reclaiming Liquidity from Dead Tokens

If a token shows no trading activity for 7 consecutive days and its Uniswap liquidity pool holds less than 3.26 ETH, we consider it a dead token. Instead of letting that idle liquidity sit there doing nothing, we remove it and put it to better use:

• 100% of reclaimed liquidity is used to buy $Flaunt tokens from the market.

• These $Flaunt tokens are then distributed to the community:

1

35% to Creators Rewarded weekly based on their token’s dex trading volume.

2

35% to Traders Shared with users based on platform trading activity.

3

25% to Stakers Boosts the APR in the staking pool.

4

5% to Dead Token Holders Gives holders a chance to recover some value.

This creates a win-win across the board—creators earn for launching, traders get rewarded for activity, stakers enjoy higher APR, and holders of dead tokens recover some value.

function decreaseLiquidityByToken

function decreaseLiquidityByToken(
        address poolToken
    ) internal returns (uint256 amount0, uint256 amount1) {
        uint256 tokenId = poolTokenToTokenId[poolToken];

        require(tokenId != 0, "No LP found");
        require(!isLiquidityRemoved[tokenId], "Already removed");

        // Collect fees and map creator shares
        collectAllFees(tokenId);

        // Remove liquidity and handle WETH unwrap + FLAUNT buy
        (amount0, amount1) = decreaseLiquidityCurrentRange(tokenId, poolToken);
    }

    function decreaseLiquidityCurrentRange(
        uint256 tokenId,
        address poolToken
    ) internal returns (uint256 amount0, uint256 amount1) {
        require(!isLiquidityRemoved[tokenId], "Already removed");

        Deposit memory userDeposit = deposits[tokenId];
        uint128 liquidity = userDeposit.liquidity;
        require(liquidity > 0, "No liquidity");

        INonfungiblePositionManager.DecreaseLiquidityParams
            memory params = INonfungiblePositionManager
                .DecreaseLiquidityParams({
                    tokenId: tokenId,
                    liquidity: liquidity,
                    amount0Min: 0,
                    amount1Min: 0,
                    deadline: block.timestamp
                });

        (amount0, amount1) = nonfungiblePositionManager.decreaseLiquidity(
            params
        );

        deposits[tokenId].liquidity = 0;
        isLiquidityRemoved[tokenId] = true;

        // Identify WETH token from position
        (
            ,
            ,
            address token0,
            address token1,
            ,
            ,
            ,
            ,
            ,
            ,
            ,

        ) = nonfungiblePositionManager.positions(tokenId);

        emit Debug_PostBalance(
            IERC20(token0).balanceOf(address(this)),
            IERC20(token1).balanceOf(address(this))
        );

        address tokenWeth = token0 == address(weth)
            ? token0
            : (token1 == address(weth) ? token1 : address(0));
        require(tokenWeth != address(0), "No WETH in pool");

        // Collect any final fees
        nonfungiblePositionManager.collect(
            INonfungiblePositionManager.CollectParams({
                tokenId: tokenId,
                recipient: address(this),
                amount0Max: type(uint128).max,
                amount1Max: type(uint128).max
            })
        );

        // Get full WETH balance held by contract
        uint256 wethBalance = IERC20(tokenWeth).balanceOf(address(this));

        require(wethBalance > 0, "No WETH received");

        // Subtract WETH owed to creators
        uint256 wethToUse = wethBalance > totalWethForCreators
            ? wethBalance - totalWethForCreators
            : 0;

        if (wethToUse > 0) {
            // 1. Unwrap to ETH
            weth.withdraw(wethToUse);

            // 2. Buy FLAUNT with ETH
            swapRouter.buyERC20WithETHV2{value: wethToUse}(FLAUNT_TOKEN, 0);

            // 3. Get FLAUNT token balance
            uint256 flauntBalance = IERC20(FLAUNT_TOKEN).balanceOf(
                address(this)
            );

            // 4. Split and distribute
            uint256 stakingAmount = (flauntBalance * 65) / 100;
            uint256 rewardsAmount = flauntBalance - stakingAmount;

            IERC20(FLAUNT_TOKEN).transfer(STAKING, stakingAmount);
            IERC20(FLAUNT_TOKEN).transfer(USER_REWARDS, rewardsAmount);

            emit LiquidityRemovedDeadHolders(
                poolToken,
                (rewardsAmount * 5) / 100
            );

            emit LiquidityRemovedPlatformTraders(
                poolToken,
                (rewardsAmount * 30) / 100
            );
        }
    }

Both functions are triggered securely using Chainlink Automation, which listens for on-chain events like market cap milestones, trading inactivity, and ETH balance in the token’s Uniswap pool.

Only Chainlink’s Upkeep Forwarder is allowed to call these functions, ensuring the entire process is fully automated, on-chain, and completely shielded from manual interference. It's a safety-first system designed to protect the platform—and the community.