Our Approach

A Smarter Way to Build Value

In decentralized finance (DeFi), liquidity is the lifeblood of any project. But many platforms waste this precious resource by burning liquidity tokens as soon as a project lists on Uniswap or similar exchanges. At Flaunt, we believe there’s a better way—a smarter way that benefits the entire community.

We’ve introduced a game-changing liquidity management system that ensures liquidity stays productive, supporting the community while reducing waste from inactive tokens.

What’s Wrong with Burning Liquidity?

Most platforms burn liquidity tokens once a project fills the bonding curve and lists on a dex. It sounds good on paper, but here’s the issue:

• Burned liquidity is gone forever. Even if the project fails or becomes inactive, that liquidity can never be recovered.

• Wasted resources. Valuable ETH is permanently locked away, never to be used again, even for tokens that don’t gain any traction.

Instead of following this outdated approach, Flaunt has a dynamic model that maximizes liquidity for active projects and reclaims liquidity from dead tokens to fuel our ecosystem.

Aspect	Traditional Liquidity Burning	Flaunt.meme’s Approach
What Happens to Liquidity?	Burned and gone forever—never to be used again	Kept safe and only burned when a token proves its worth
When is Liquidity Burned?	Right after a token hits the market, whether it succeeds or not	Only for tokens that reach a $1M market cap—after they’ve shown real value
Dead Token Liquidity	Lost forever. If a token dies, its liquidity is gone too	Reclaimed and used to buy $Flaunt tokens from the market, boosting community rewards
Who Benefits?	No one. Burned liquidity helps no one after it’s gone	Stakers, users, and holders—because we turn reclaimed liquidity into rewards
Resource Usage	Wasted. Once burned, that liquidity is locked away forever	Maximized. We turn idle liquidity into buybacks and community rewards
Community Impact	Minimal. There are no ongoing rewards after burning	Continuous. Reclaimed liquidity boosts community rewards and helps holders recover value

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:

  • 65% to stakers

  • 30% to the platform users

  • 5% to holders of the dead token

This creates a win-win situation. Stakers benefit from continuous rewards, and holders of inactive tokens get a second chance to 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.