FeeSwapper

{{
  "language": "Solidity",
  "sources": {
    "YGMI/FeeSwapper.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/* -------------------------------------------------------------------------- */
/*                                  INTERFACES                                */
/* -------------------------------------------------------------------------- */

interface ISwapRouter {
    struct ExactInputSingleParams {
        address tokenIn;
        address tokenOut;
        uint24 fee;
        address recipient;
        uint256 deadline;
        uint256 amountIn;
        uint256 amountOutMinimum;
        uint160 sqrtPriceLimitX96;
    }

    function exactInputSingle(
        ExactInputSingleParams calldata params
    ) external payable returns (uint256 amountOut);
}

interface IWETH {
    function withdraw(uint256) external;
}

interface IERC20 {
    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool);

    function approve(address spender, uint256 value) external returns (bool);

    function balanceOf(address account) external view returns (uint256);

    function addFees() external payable;
}

/* --------------------------- YGMI Router Interface --------------------------- */
interface IYgmiRouter {
    function isTokenTradable(address token) external view returns (bool);
}

/* -------------------------------------------------------------------------- */
/*                               FEE SWAPPER LOGIC                            */
/* -------------------------------------------------------------------------- */

contract FeeSwapper {
    address public immutable v3Router;
    address public ygmiRouter;
    address public owner;

    constructor(address _v3Router) {
        require(_v3Router != address(0), "Invalid v3Router");
        v3Router = _v3Router;
        owner = msg.sender;
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "Not authorized");
        _;
    }

    function setYgmiRouter(address _ygmiRouter) external onlyOwner {
        require(_ygmiRouter != address(0), "Invalid address");
        ygmiRouter = _ygmiRouter;
    }

    function swapTokenToETH(
        address ygmi,
        address weth,
        uint256 amountIn,
        address recipient
    ) external {
        require(amountIn > 0, "Invalid amount");
        require(
            IYgmiRouter(ygmiRouter).isTokenTradable(recipient),
            "Recipient token not allowed"
        );

        IERC20(ygmi).approve(v3Router, type(uint256).max);

        ISwapRouter.ExactInputSingleParams memory params = ISwapRouter
            .ExactInputSingleParams({
                tokenIn: ygmi,
                tokenOut: weth,
                fee: 10000, // 1% fee tier
                recipient: address(this),
                deadline: block.timestamp,
                amountIn: amountIn,
                amountOutMinimum: 0,
                sqrtPriceLimitX96: 0
            });

        ISwapRouter(v3Router).exactInputSingle(params);

        uint256 wethBalance = IERC20(weth).balanceOf(address(this));
        require(wethBalance > 0, "No WETH output");

        IWETH(weth).withdraw(wethBalance);
        IERC20(recipient).addFees{value: wethBalance}();

        //(bool success, ) = payable(recipient).call{value: wethBalance}("");
        //require(success, "ETH transfer failed");
    }

    function takeLostEthBack() external onlyOwner {
        uint256 bal = address(this).balance;
        require(bal > 0, "No ETH to withdraw");

        (bool success, ) = payable(owner).call{value: bal}("");
        require(success, "ETH transfer failed");
    }

    receive() external payable {}
}
"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": true,
      "runs": 200
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    },
    "remappings": []
  }
}}