Forkchoice Ethereum Mainnet

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.15;

/*

 /$$   /$$ /$$$$$$$$       /$$$$$$$$ /$$
| $$  / $$|_____ $$/      | $$_____/|__/
|  $$/ $$/     /$$/       | $$       /$$ /$$$$$$$   /$$$$$$  /$$$$$$$   /$$$$$$$  /$$$$$$
 \  $$$$/     /$$/        | $$$$$   | $$| $$__  $$ |____  $$| $$__  $$ /$$_____/ /$$__  $$
  >$$  $$    /$$/         | $$__/   | $$| $$  \ $$  /$$$$$$$| $$  \ $$| $$      | $$$$$$$$
 /$$/\  $$  /$$/          | $$      | $$| $$  | $$ /$$__  $$| $$  | $$| $$      | $$_____/
| $$  \ $$ /$$/           | $$      | $$| $$  | $$|  $$$$$$$| $$  | $$|  $$$$$$$|  $$$$$$$
|__/  |__/|__/            |__/      |__/|__/  |__/ \_______/|__/  |__/ \_______/ \_______/

Contract: Smart Contract for managing X7R fee tokens V2

Fixes:

    1. Ability to manage the release of tokens built up by the contract to not affect user trading with large slippage

This contract will NOT be renounced.

The following are the only functions that can be called on the contract that affect the contract:

    function setShares(uint256 distributeShare_, uint256 liquidityShare_, uint256 treasuryShare_) external onlyOwner {
        require(distributeShare + liquidityShare + treasuryShare == 1000);

        require(distributeShare_ >= minShare && distributeShare_ <= maxShare);
        require(liquidityShare_ >= minShare && liquidityShare_ <= maxShare);
        require(treasuryShare_ >= minShare && treasuryShare_ <= maxShare);

        distributeShare = distributeShare_;
        liquidityShare = liquidityShare_;
        treasuryShare = treasuryShare_;

        emit SharesSet(distributeShare_, liquidityShare_, treasuryShare_);
    }

    function setRouter(address router_) external onlyOwner {
        require(router_ != address(router));
        router = IUniswapV2Router(router_);
        emit RouterSet(router_);
    }

    function setOffRampPair(address offRampPairAddress) external onlyOwner {
        require(offRampPair != offRampPairAddress);
        offRampPair = offRampPairAddress;
        emit OffRampPairSet(offRampPairAddress);
    }

    function setBalanceThreshold(uint256 threshold) external onlyOwner {
        require(!balanceThresholdFrozen);
        balanceThreshold = threshold;
        emit BalanceThresholdSet(threshold);
    }

    function setMaxSlippage(uint256 newMaxSlippageBips) external onlyOwner {
        require(newMaxSlippageBips > 0 && newMaxSlippageBips <= 1000, "Invalid slippage value"); // Max 10% slippage
        uint256 oldSlippage = maxSlippageBips;
        maxSlippageBips = newMaxSlippageBips;
        emit MaxSlippageUpdated(oldSlippage, newMaxSlippageBips);
    }

    function setLiquidityRatioTarget(uint256 liquidityRatioTarget_) external onlyOwner {
        require(liquidityRatioTarget_ != liquidityRatioTarget);
        require(liquidityRatioTarget_ >= minLiquidityRatioTarget && liquidityRatioTarget <= maxLiquidityRatioTarget);
        liquidityRatioTarget = liquidityRatioTarget_;
        emit LiquidityRatioTargetSet(liquidityRatioTarget_);
    }

    function setLiquidityTokenReceiver(address liquidityTokenReceiver_) external onlyOwner {
        require(
            liquidityTokenReceiver_ != address(0)
            && liquidityTokenReceiver_ != address(0x000000000000000000000000000000000000dEaD)
            && liquidityTokenReceiver != liquidityTokenReceiver_
        );

        address oldLiquidityTokenReceiver = liquidityTokenReceiver;
        liquidityTokenReceiver = liquidityTokenReceiver_;
        emit LiquidityTokenReceiverSet(oldLiquidityTokenReceiver, liquidityTokenReceiver_);
    }

    function setDistributionTarget(address target) external onlyOwner {
        require(
            target != address(0)
            && target != address(0x000000000000000000000000000000000000dEaD)
            && distributeTarget != payable(target)
        );
        require(!distributeTargetFrozen);
        address oldTarget = address(distributeTarget);
        distributeTarget = payable(target);
        emit DistributeTargetSet(oldTarget, distributeTarget);
    }

    function setTreasuryTarget(address target) external onlyOwner {
        require(
            target != address(0)
            && target != address(0x000000000000000000000000000000000000dEaD)
            && treasuryTarget != payable(target)
        );
        require(!treasuryTargetFrozen);
        address oldTarget = address(treasuryTarget);
        treasuryTarget = payable(target);
        emit TreasuryTargetSet(oldTarget, target);
    }

    function freezeTreasuryTarget() external onlyOwner {
        require(!treasuryTargetFrozen);
        treasuryTargetFrozen = true;
        emit TreasuryTargetFrozen();
    }

    function freezeDistributeTarget() external onlyOwner {
        require(!distributeTargetFrozen);
        distributeTargetFrozen = true;
        emit DistributeTargetFrozen();
    }

    function freezeBalanceThreshold() external onlyOwner {
        require(!balanceThresholdFrozen);
        balanceThresholdFrozen = true;
        emit BalanceThresholdFrozen();
    }

These functions will be passed to DAO governance once the ecosystem stabilizes.

*/

abstract contract Ownable {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor(address owner_) {
        _transferOwnership(owner_);
    }

    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    function owner() public view virtual returns (address) {
        return _owner;
    }

    function _checkOwner() internal view virtual {
        require(owner() == msg.sender, "Ownable: caller is not the owner");
    }

    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

interface IERC20 {
    function circulatingSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address to, uint256 amount) external returns (bool);
    function approve(address spender, uint256 amount) external returns (bool);
}

interface IUniswapV2Router {
    function WETH() external returns (address);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
}

interface IUniswapV2Pair {
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
}

interface ILiquidityHub {
    function processFees(address) external;
}

interface IX7EcosystemSplitter {
    function takeBalance() external;
}

interface IWETH {
    function withdraw(uint) external;
}

contract X7RLiquidityHub is Ownable, ILiquidityHub {
    IUniswapV2Router public router;
    address public offRampPair;

    IERC20 public x7r;
    address public liquidityTokenReceiver;
    uint256 public minLiquidityRatioTarget = 5;
    uint256 public maxLiquidityRatioTarget = 99;
    uint256 public maxSlippageBips = 200; // 2% default slippage

    uint256 public liquidityRatioTarget = 15;

    uint256 public minShare = 200;
    uint256 public maxShare = 500;

    uint256 public distributeShare = 300;
    uint256 public liquidityShare = 400;
    uint256 public treasuryShare = 300;

    uint256 public balanceThreshold = 1 ether;

    uint256 public distributeBalance;
    uint256 public treasuryBalance;
    uint256 public liquidityBalance;
    uint256 public x7rLiquidityBalance;

    address payable public distributeTarget;
    address payable public treasuryTarget;

    bool public distributeTargetFrozen;
    bool public treasuryTargetFrozen;
    bool public balanceThresholdFrozen;
    bool public slippageManagementEnabled = true;

    event SharesSet(uint256 distributeShare, uint256 liquidityShare, uint256 treasuryShare);
    event OffRampPairSet(address indexed offRampPair);
    event DistributeTargetSet(address indexed oldTarget, address indexed newTarget);
    event TreasuryTargetSet(address indexed oldTarget, address indexed newTarget);
    event MaxSlippageSet(uint256 oldSlippage, uint256 newSlippage);
    event SlippageManagementEnabledSet(bool enabled);
    event LiquidityRatioTargetSet(uint256 liquidityRatioTarget);
    event LiquidityTokenReceiverSet(address indexed oldReciever, address indexed newReceiver);
    event BalanceThresholdSet(uint256 threshold);
    event RouterSet(address router);
    event TreasuryTargetFrozen();
    event DistributeTargetFrozen();
    event BalanceThresholdFrozen();

    constructor(address x7r_, address router_, address _owner) Ownable(_owner) {
        router = IUniswapV2Router(router_);
        x7r = IERC20(x7r_);

        emit RouterSet(router_);
    }

    receive() external payable {}

    function setShares(uint256 distributeShare_, uint256 liquidityShare_, uint256 treasuryShare_) external onlyOwner {
        require(distributeShare + liquidityShare + treasuryShare == 1000);

        require(distributeShare_ >= minShare && distributeShare_ <= maxShare);
        require(liquidityShare_ >= minShare && liquidityShare_ <= maxShare);
        require(treasuryShare_ >= minShare && treasuryShare_ <= maxShare);

        distributeShare = distributeShare_;
        liquidityShare = liquidityShare_;
        treasuryShare = treasuryShare_;

        emit SharesSet(distributeShare_, liquidityShare_, treasuryShare_);
    }

    function setRouter(address router_) external onlyOwner {
        require(router_ != address(router));
        router = IUniswapV2Router(router_);
        emit RouterSet(router_);
    }

    function setOffRampPair(address offRampPairAddress) external onlyOwner {
        require(offRampPair != offRampPairAddress);
        offRampPair = offRampPairAddress;
        emit OffRampPairSet(offRampPairAddress);
    }

    function setBalanceThreshold(uint256 threshold) external onlyOwner {
        require(!balanceThresholdFrozen);
        balanceThreshold = threshold;
        emit BalanceThresholdSet(threshold);
    }

    function setMaxSlippage(uint256 newMaxSlippageBips) external onlyOwner {
        require(newMaxSlippageBips > 0 && newMaxSlippageBips <= 1000, "Invalid slippage value"); // Max 10% slippage
        uint256 oldSlippage = maxSlippageBips;
        maxSlippageBips = newMaxSlippageBips;
        emit MaxSlippageSet(oldSlippage, newMaxSlippageBips);
    }

    function setSlippageManagementEnabled(bool enabled) external onlyOwner {
        require(slippageManagementEnabled != enabled);
        slippageManagementEnabled = enabled;
        emit SlippageManagementEnabledSet(enabled);
    }

    function setLiquidityRatioTarget(uint256 liquidityRatioTarget_) external onlyOwner {
        require(liquidityRatioTarget_ != liquidityRatioTarget);
        require(liquidityRatioTarget_ >= minLiquidityRatioTarget && liquidityRatioTarget <= maxLiquidityRatioTarget);
        liquidityRatioTarget = liquidityRatioTarget_;
        emit LiquidityRatioTargetSet(liquidityRatioTarget_);
    }

    function setLiquidityTokenReceiver(address liquidityTokenReceiver_) external onlyOwner {
        require(
            liquidityTokenReceiver_ != address(0) &&
                liquidityTokenReceiver_ != address(0x000000000000000000000000000000000000dEaD) &&
                liquidityTokenReceiver != liquidityTokenReceiver_
        );

        address oldLiquidityTokenReceiver = liquidityTokenReceiver;
        liquidityTokenReceiver = liquidityTokenReceiver_;
        emit LiquidityTokenReceiverSet(oldLiquidityTokenReceiver, liquidityTokenReceiver_);
    }

    function setDistributionTarget(address target) external onlyOwner {
        require(
            target != address(0) &&
                target != address(0x000000000000000000000000000000000000dEaD) &&
                distributeTarget != payable(target)
        );
        require(!distributeTargetFrozen);
        address oldTarget = address(distributeTarget);
        distributeTarget = payable(target);
        emit DistributeTargetSet(oldTarget, distributeTarget);
    }

    function setTreasuryTarget(address target) external onlyOwner {
        require(
            target != address(0) &&
                target != address(0x000000000000000000000000000000000000dEaD) &&
                treasuryTarget != payable(target)
        );
        require(!treasuryTargetFrozen);
        address oldTarget = address(treasuryTarget);
        treasuryTarget = payable(target);
        emit TreasuryTargetSet(oldTarget, target);
    }

    function freezeTreasuryTarget() external onlyOwner {
        require(!treasuryTargetFrozen);
        treasuryTargetFrozen = true;
        emit TreasuryTargetFrozen();
    }

    function freezeDistributeTarget() external onlyOwner {
        require(!distributeTargetFrozen);
        distributeTargetFrozen = true;
        emit DistributeTargetFrozen();
    }

    function freezeBalanceThreshold() external onlyOwner {
        require(!balanceThresholdFrozen);
        balanceThresholdFrozen = true;
        emit BalanceThresholdFrozen();
    }

    function processFees(address tokenAddress) external {
        require(tokenAddress != address(0), "Invalid token address");
        require(IERC20(tokenAddress).balanceOf(address(this)) > 0, "No tokens to process");

        uint256 startingETHBalance = address(this).balance;
        uint256 tokensToSwap = IERC20(tokenAddress).balanceOf(address(this));

        if (tokenAddress == address(x7r)) {
            tokensToSwap -= x7rLiquidityBalance;
        }

        if (tokensToSwap > 0) {
            uint256 actualTokensToSwap = tokensToSwap;

            if (slippageManagementEnabled) {
                (uint112 reserve0, uint112 reserve1, ) = IUniswapV2Pair(offRampPair).getReserves();
                uint112 tokenReserve = address(x7r) < router.WETH() ? reserve0 : reserve1;
                uint256 maxTokensForTargetSlippage = calculateMaxTokensForSlippage(tokenReserve);
                actualTokensToSwap = tokensToSwap < maxTokensForTargetSlippage
                    ? tokensToSwap
                    : maxTokensForTargetSlippage;
            }

            swapTokensForEth(tokenAddress, actualTokensToSwap);
        }

        // Rest of the function remains the same
        uint256 ETHForDistribution = address(this).balance - startingETHBalance;

        distributeBalance += (ETHForDistribution * distributeShare) / 1000;
        treasuryBalance += (ETHForDistribution * treasuryShare) / 1000;
        liquidityBalance = address(this).balance - distributeBalance - treasuryBalance;

        if (distributeBalance >= balanceThreshold) {
            sendDistributeBalance();
        }

        if (treasuryBalance >= balanceThreshold) {
            sendTreasuryBalance();
        }

        if (liquidityBalance >= balanceThreshold) {
            buyBackAndAddLiquidity();
        }
    }

    function sendDistributeBalance() public {
        if (distributeTarget == address(0)) {
            return;
        }

        IX7EcosystemSplitter(distributeTarget).takeBalance();

        uint256 ethToSend = distributeBalance;
        distributeBalance = 0;

        (bool success, ) = distributeTarget.call{ value: ethToSend }("");

        if (!success) {
            distributeBalance = ethToSend;
        }
    }

    function sendTreasuryBalance() public {
        if (treasuryTarget == address(0)) {
            return;
        }

        uint256 ethToSend = treasuryBalance;
        treasuryBalance = 0;

        (bool success, ) = treasuryTarget.call{ value: ethToSend }("");

        if (!success) {
            treasuryBalance = ethToSend;
        }
    }

    function buyBackAndAddLiquidity() internal {
        uint256 currentX7RBalance = x7r.balanceOf(address(this));
        uint256 circulatingSupply = x7r.circulatingSupply();
        uint256 pairX7RBalance = x7r.balanceOf(offRampPair) * 1e12;
        uint256 targetX7RLiquidity = (circulatingSupply * liquidityRatioTarget) / 1000;

        if (pairX7RBalance >= targetX7RLiquidity) {
            swapEthForTokens(liquidityBalance);
        } else {
            uint256 x7rNeeded = targetX7RLiquidity - pairX7RBalance;

            if (currentX7RBalance >= x7rNeeded) {
                addLiquidityETH(x7rNeeded, liquidityBalance);
            } else {
                uint256 x7rToBuy = x7rNeeded - currentX7RBalance;
                uint256 ethForX7R = estimateETHForTokens(x7rToBuy / 1e12);

                if (ethForX7R > liquidityBalance) {
                    ethForX7R = liquidityBalance;
                }

                swapEthForTokens(ethForX7R);

                uint256 newX7RBalance = x7r.balanceOf(address(this));
                uint256 ethLeft = liquidityBalance - ethForX7R;

                addLiquidityETH(newX7RBalance, ethLeft);
            }
        }

        liquidityBalance = 0;
        x7rLiquidityBalance = x7r.balanceOf(address(this));
    }

    function addLiquidityETH(uint256 tokenAmount, uint256 ethAmount) internal {
        x7r.approve(address(router), tokenAmount);
        router.addLiquidityETH{ value: ethAmount }(
            address(x7r),
            tokenAmount,
            0,
            0,
            liquidityTokenReceiver,
            block.timestamp
        );
    }

    function estimateETHForTokens(uint256 tokenAmount) internal returns (uint256) {
        address[] memory path = new address[](2);
        path[0] = router.WETH();
        path[1] = address(x7r);
        uint256[] memory amounts = router.getAmountsIn(tokenAmount, path);
        return amounts[0];
    }

    function swapTokensForEth(address tokenAddress, uint256 tokenAmount) internal {
        address[] memory path = new address[](2);
        path[0] = tokenAddress;
        path[1] = router.WETH();

        IERC20(tokenAddress).approve(address(router), tokenAmount);
        router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount, 0, path, address(this), block.timestamp);
    }

    function swapEthForTokens(uint256 ethAmount) internal {
        address[] memory path = new address[](2);
        path[0] = router.WETH();
        path[1] = address(x7r);
        router.swapExactETHForTokensSupportingFeeOnTransferTokens{ value: ethAmount }(
            0,
            path,
            address(this),
            block.timestamp
        );
    }

    function calculateMaxTokensForSlippage(uint112 tokenReserve) internal view returns (uint256) {
        uint256 slippagePercentage = (maxSlippageBips * 1e14) / 10000;
        uint256 maxTokens = (uint256(tokenReserve) * slippagePercentage) / (1e18 + slippagePercentage);

        return maxTokens;
    }

    function rescueWETH() external {
        address wethAddress = router.WETH();
        IWETH(wethAddress).withdraw(IERC20(wethAddress).balanceOf(address(this)));
    }
}