GetxRouter

{{
  "language": "Solidity",
  "sources": {
    "contracts/router.sol": {
      "content": "// SPDX-License-Identifier: MIT


pragma solidity ^0.8.0;

library SafeMath {
    function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
        require((z = x + y) >= x, "ds-math-add-overflow");
    }

    function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
        require((z = x - y) <= x, "ds-math-sub-underflow");
    }

    function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
        require(y == 0 || (z = x * y) / y == x, "ds-math-mul-overflow");
    }
}

interface IERC20 {
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
    event Transfer(address indexed from, address indexed to, uint256 value);

    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);

    function totalSupply() external view returns (uint256);

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

    function allowance(address owner, address spender)
        external
        view
        returns (uint256);

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

    function transfer(address to, uint256 value) external returns (bool);

    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool);
}

library TransferHelper {
    function safeApprove(
        address token,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('approve(address,uint256)')));
        (bool success, bytes memory data) = token.call(
            abi.encodeWithSelector(0x095ea7b3, to, value)
        );
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            "TransferHelper: APPROVE_FAILED"
        );
    }

    function safeTransfer(
        address token,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('transfer(address,uint256)')));
        (bool success, bytes memory data) = token.call(
            abi.encodeWithSelector(0xa9059cbb, to, value)
        );
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            "TransferHelper: TRANSFER_FAILED"
        );
    }

    function safeTransferFrom(
        address token,
        address from,
        address to,
        uint256 value
    ) internal {
        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
        (bool success, bytes memory data) = token.call(
            abi.encodeWithSelector(0x23b872dd, from, to, value)
        );
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            "TransferHelper: TRANSFER_FROM_FAILED"
        );
    }

    function safeTransferETH(address to, uint256 value) internal {
        (bool success, ) = to.call{value: value}(new bytes(0));
        require(success, "TransferHelper: ETH_TRANSFER_FAILED");
    }
}
 
library DcxLibrary {
    using SafeMath for uint256;

    // returns sorted token addresses, used to handle return values from pairs sorted in this order
    function sortTokens(address tokenA, address tokenB)
        internal
        pure
        returns (address token0, address token1)
    {
        require(tokenA != tokenB, "DcxLibrary: IDENTICAL_ADDRESSES");
        (token0, token1) = tokenA < tokenB
            ? (tokenA, tokenB)
            : (tokenB, tokenA);
        require(token0 != address(0), "DcxLibrary: ZERO_ADDRESS");
    }

    function pairFor(
        address factory,
        address tokenA,
        address tokenB
    ) internal pure returns (address pair) {
        (address token0, address token1) = sortTokens(tokenA, tokenB);
        bytes32 hash = keccak256(
            abi.encodePacked(
                hex"ff",
                factory,
                keccak256(abi.encodePacked(token0, token1)),
                hex"50fc0809a6a95d6fc85f253c88b1f1b988e4a4fada0e826bae1f0ac6109a4e2c" // init code hash
            )
        );
        pair = address(uint160(uint256(hash)));
    }

    // fetches and sorts the reserves for a pair
    function getReserves(
        address factory,
        address tokenA,
        address tokenB
    ) internal view returns (uint256 reserveA, uint256 reserveB) {
        (address token0, ) = sortTokens(tokenA, tokenB);
        pairFor(factory, tokenA, tokenB);
        (uint256 reserve0, uint256 reserve1, ) = IGetxPair(
            pairFor(factory, tokenA, tokenB)
        ).getReserves();
        (reserveA, reserveB) = tokenA == token0
            ? (reserve0, reserve1)
            : (reserve1, reserve0);
    }

    // given some amount of an asset and pair reserves, returns an equivalent amount of the other asset
    function quote(
        uint256 amountA,
        uint256 reserveA,
        uint256 reserveB
    ) internal pure returns (uint256 amountB) {
        require(amountA > 0, "DcxLibrary: INSUFFICIENT_AMOUNT");
        require(
            reserveA > 0 && reserveB > 0,
            "DcxLibrary: INSUFFICIENT_LIQUIDITY"
        );
        amountB = amountA.mul(reserveB) / reserveA;
    }

    // given an input amount of an asset and pair reserves, returns the maximum output amount of the other asset
    function getAmountOut(
        uint256 amountIn,
        uint256 reserveIn,
        uint256 reserveOut
    ) internal pure returns (uint256 amountOut) {
        require(amountIn > 0, "DcxLibrary: INSUFFICIENT_INPUT_AMOUNT");
        require(
            reserveIn > 0 && reserveOut > 0,
            "DcxLibrary: INSUFFICIENT_LIQUIDITY"
        );
        uint256 amountInWithFee = amountIn.mul(9975);
        uint256 numerator = amountInWithFee.mul(reserveOut);
        uint256 denominator = reserveIn.mul(10000).add(amountInWithFee);
        amountOut = numerator / denominator;
    }

    // given an output amount of an asset and pair reserves, returns a required input amount of the other asset
    function getAmountIn(
        uint256 amountOut,
        uint256 reserveIn,
        uint256 reserveOut
    ) internal pure returns (uint256 amountIn) {
        require(amountOut > 0, "DcxLibrary: INSUFFICIENT_OUTPUT_AMOUNT");
        require(
            reserveIn > 0 && reserveOut > 0,
            "DcxLibrary: INSUFFICIENT_LIQUIDITY"
        );
        uint256 numerator = reserveIn.mul(amountOut).mul(10000);
        uint256 denominator = reserveOut.sub(amountOut).mul(9975);
        amountIn = (numerator / denominator).add(1);
    }

    // performs chained getAmountOut calculations on any number of pairs
    function getAmountsOut(
        address factory,
        uint256 amountIn,
        address[] memory path
    ) internal view returns (uint256[] memory amounts) {
        require(path.length >= 2, "DcxLibrary: INVALID_PATH");
        amounts = new uint256[](path.length);
        amounts[0] = amountIn;
        for (uint256 i; i < path.length - 1; i++) {
            (uint256 reserveIn, uint256 reserveOut) = getReserves(
                factory,
                path[i],
                path[i + 1]
            );
            amounts[i + 1] = getAmountOut(amounts[i], reserveIn, reserveOut);
        }
    }

    // performs chained getAmountIn calculations on any number of pairs
    function getAmountsIn(
        address factory,
        uint256 amountOut,
        address[] memory path
    ) internal view returns (uint256[] memory amounts) {
        require(path.length >= 2, "DcxLibrary: INVALID_PATH");
        amounts = new uint256[](path.length);
        amounts[amounts.length - 1] = amountOut;
        for (uint256 i = path.length - 1; i > 0; i--) {
            (uint256 reserveIn, uint256 reserveOut) = getReserves(
                factory,
                path[i - 1],
                path[i]
            );
            amounts[i - 1] = getAmountIn(amounts[i], reserveIn, reserveOut);
        }
    }
}


interface IGetxFactory {
    event PairCreated(
        address indexed token0,
        address indexed token1,
        address pair,
        uint256
    );

    function feeTo() external view returns (address);

    function feeToSetter() external view returns (address);

    function getPair(address tokenA, address tokenB)
        external
        view
        returns (address pair);

    function allPairs(uint256) external view returns (address pair);

    function allPairsLength() external view returns (uint256);

    function createPair(address tokenA, address tokenB)
        external
        returns (address pair);

    function setFeeTo(address) external;

    function setFeeToSetter(address) external;

    function INIT_CODE_PAIR_HASH() external view returns (bytes32);
}

interface IGetxPair {
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
    event Transfer(address indexed from, address indexed to, uint256 value);

    function name() external pure returns (string memory);

    function symbol() external pure returns (string memory);

    function decimals() external pure returns (uint8);

    function totalSupply() external view returns (uint256);

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

    function allowance(address owner, address spender)
        external
        view
        returns (uint256);

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

    function transfer(address to, uint256 value) external returns (bool);

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

    function DOMAIN_SEPARATOR() external view returns (bytes32);

    function PERMIT_TYPEHASH() external pure returns (bytes32);

    function nonces(address owner) external view returns (uint256);

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    event Mint(address indexed sender, uint256 amount0, uint256 amount1);
    event Burn(
        address indexed sender,
        uint256 amount0,
        uint256 amount1,
        address indexed to
    );
    event Swap(
        address indexed sender,
        uint256 amount0In,
        uint256 amount1In,
        uint256 amount0Out,
        uint256 amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint256);

    function factory() external view returns (address);

    function token0() external view returns (address);

    function token1() external view returns (address);

    function getReserves()
        external
        view
        returns (
            uint112 reserve0,
            uint112 reserve1,
            uint32 blockTimestampLast
        );

    function price0CumulativeLast() external view returns (uint256);

    function price1CumulativeLast() external view returns (uint256);

    function kLast() external view returns (uint256);

    function mint(address to) external returns (uint256 liquidity);

    function burn(address to)
        external
        returns (uint256 amount0, uint256 amount1);

    function swap(
        uint256 amount0Out,
        uint256 amount1Out,
        address to,
        bytes calldata data
    ) external;

    function skim(address to) external;

    function sync() external;

    function initialize(address, address) external;
  }

  interface IWDCX {
    function deposit() external payable;

    function transfer(address to, uint256 value) external returns (bool);

    function withdraw(uint256) external;
  }

  interface ITradeWallet {
     struct UserDetails {
        address userAddress;
        address sellToken;
        address buyToken;
        uint256 amount;
        uint256 impact;
        uint256 timeStamp;
        uint256 index;
        bool status;
    }

    
    function executed_call(bytes calldata _encodedData) external returns (UserDetails memory);
}
contract GetxRouter {
    using SafeMath for uint256;

    address public immutable factory;
    address public immutable WDCX;
    address public owneraddress;
    address public tradeWallet;
    uint256 public Fee;
    address public operator;
    uint256 hundred = 100000000000000000000;

       struct _stableFee{
        uint256 fee;
    } 

    event _AddLiquidity(
        uint256 amountA,
        uint256 amountB,
        uint256 liquidity,
        address indexed owner
    );
    event _AddLiquidityEth(
        uint256 amountToken,
        uint256 amountETH,
        uint256 liquidity,
        address indexed owner
    );
    event _RemoveLiquidity(
        uint256 amountA,
        uint256 amountB,
        address indexed owner
    );
    event _SwaptokenTotoken(uint256[] amounts, address indexed owner);
    event _SwapExactETHForTokens(address indexed owner, uint256[] amounts);
    event _RemoveLiquidityETH(
        address indexed owner,
        uint256 amountToken,
        uint256 amountETH
    );
    event  EstRecive(uint256 estimateRecive, uint256  estimateFee);
    event _SwapExactTokensForETH(address indexed owner, uint256[] amounts);

    receive() external payable {
        assert(msg.sender == WDCX);
    }

    modifier ensure(uint256 deadline) {
        require(deadline >= block.timestamp, "GetxRouter: EXPIRED");
        _;
    }
    //
    modifier onlyContractOwner() {
        require(msg.sender == owneraddress, "onlyOwner");
        _;
    }
    modifier controllers() {
        require(
            msg.sender == owneraddress || msg.sender == operator,
            "onlyOwner or operator"
        );
        _;
    }

    constructor(
        address _factory,
        address _WDCX,
        address _owneraddress,
        address _operator,
        uint256 _fee
    ) {
        factory = _factory;
        WDCX = _WDCX;
        owneraddress = _owneraddress;
        operator = _operator;
        Fee = _fee;
    }


    mapping(address =>mapping(address =>_stableFee)) private  stableFee;
    function _addLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin
    ) internal virtual returns (uint256 amountA, uint256 amountB) {
        // create the pair if it doesn't exist yet
        if (IGetxFactory(factory).getPair(tokenA, tokenB) == address(0)) {
            IGetxFactory(factory).createPair(tokenA, tokenB);
        }
        (uint256 reserveA, uint256 reserveB) = DcxLibrary.getReserves(
            factory,
            tokenA,
            tokenB
        );
        if (reserveA == 0 && reserveB == 0) {
            (amountA, amountB) = (amountADesired, amountBDesired);
        } else {
            uint256 amountBOptimal = DcxLibrary.quote(
                amountADesired,
                reserveA,
                reserveB
            );
            if (amountBOptimal <= amountBDesired) {
                require(
                    amountBOptimal >= amountBMin,
                    "GetxRouter: INSUFFICIENT_B_AMOUNT"
                );
                (amountA, amountB) = (amountADesired, amountBOptimal);
            } else {
                uint256 amountAOptimal = DcxLibrary.quote(
                    amountBDesired,
                    reserveB,
                    reserveA
                );
                assert(amountAOptimal <= amountADesired);
                require(
                    amountAOptimal >= amountAMin,
                    "GetxRouter: INSUFFICIENT_A_AMOUNT"
                );
                (amountA, amountB) = (amountAOptimal, amountBDesired);
            }
        }
    }

    function changeFee (uint256 _fee)external controllers{
        Fee = _fee;
    } 

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        address to,
        uint256 deadline
    )
        external
        virtual
        ensure(deadline)
        returns (
            uint256 amountA,
            uint256 amountB,
            uint256 liquidity
        )
    {
        (amountA, amountB) = _addLiquidity(
            tokenA,
            tokenB,
            amountADesired,
            amountBDesired,
            0,
            0
        );
        address pair = DcxLibrary.pairFor(factory, tokenA, tokenB);
        TransferHelper.safeTransferFrom(tokenA, msg.sender, pair, amountA);
        TransferHelper.safeTransferFrom(tokenB, msg.sender, pair, amountB);
        liquidity = IGetxPair(pair).mint(to);
        emit _AddLiquidity(amountA, amountB, liquidity, msg.sender);
    }

    function addLiquidityETH(
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
        external
        payable
        virtual
        ensure(deadline)
        returns (
            uint256 amountToken,
            uint256 amountETH,
            uint256 liquidity
        )
    {
        (amountToken, amountETH) = _addLiquidity(
            token,
            WDCX,
            amountTokenDesired,
            msg.value,
            amountTokenMin,
            amountETHMin
        );
        address pair = DcxLibrary.pairFor(factory, token, WDCX);
        TransferHelper.safeTransferFrom(token, msg.sender, pair, amountToken);
        IWDCX(WDCX).deposit{value: amountETH}();
        assert(IWDCX(WDCX).transfer(pair, amountETH));
        liquidity = IGetxPair(pair).mint(to);
        // refund dust eth, if any
        if (msg.value > amountETH)
            TransferHelper.safeTransferETH(msg.sender, msg.value - amountETH);
        emit _AddLiquidityEth(amountToken, amountETH, liquidity, msg.sender);
    }

    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    )
        public
        virtual
        ensure(deadline)
        returns (uint256 amountA, uint256 amountB)
    {
        address pair = DcxLibrary.pairFor(factory, tokenA, tokenB);
        IGetxPair(pair).transferFrom(msg.sender, pair, liquidity); // send liquidity to pair
        (uint256 amount0, uint256 amount1) = IGetxPair(pair).burn(to);
        (address token0, ) = DcxLibrary.sortTokens(tokenA, tokenB);
        (amountA, amountB) = tokenA == token0
            ? (amount0, amount1)
            : (amount1, amount0);
        require(amountA >= amountAMin, "GetxRouter: INSUFFICIENT_A_AMOUNT");
        require(amountB >= amountBMin, "GetxRouter: INSUFFICIENT_B_AMOUNT");
        emit _RemoveLiquidity(amountA, amountB, msg.sender);
    }

    function  UpdateTradeWallet ( address _newTradeWallet)public controllers{
      require(_newTradeWallet != address(0),"Give vaild address");
       tradeWallet = _newTradeWallet;
    }

    function _swap(
        uint256[] memory amounts,
        address[] memory path,
        address _to
    ) internal virtual {
        for (uint256 i; i < path.length - 1; i++) {
            (address input, address output) = (path[i], path[i + 1]);
            (address token0, ) = DcxLibrary.sortTokens(input, output);
            uint256 amountOut = amounts[i + 1];
            (uint256 amount0Out, uint256 amount1Out) = input == token0
                ? (uint256(0), amountOut)
                : (amountOut, uint256(0));
            address to = i < path.length - 2
                ? DcxLibrary.pairFor(factory, output, path[i + 2])
                : _to;
            IGetxPair(DcxLibrary.pairFor(factory, input, output)).swap(
                amount0Out,
                amount1Out,
                to,
                new bytes(0)
            );
        }
    }

    function swapExactTokensForTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external virtual ensure(deadline) returns (uint256[] memory amounts) {
        amounts = DcxLibrary.getAmountsOut(factory, amountIn, path);
        require(
            amounts[amounts.length - 1] >= amountOutMin,
            "GetxRouter: INSUFFICIENT_OUTPUT_AMOUNT"
        );
        TransferHelper.safeTransferFrom(
            path[0],
            msg.sender,
            DcxLibrary.pairFor(factory, path[0], path[1]),
            amounts[0]
        );
        _swap(amounts, path, address(this));
         getFeeAndTransferUser(to,path[0],path[path.length -1], amounts[amounts.length - 1],0);
        emit _SwaptokenTotoken(amounts, to);
    }

    function swapExactETHForTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    )
        external
        payable
        virtual
        ensure(deadline)
        returns (uint256[] memory amounts)
    {
        require(path[0] == WDCX, "GetxRouter: INVALID_PATH");
        amounts = DcxLibrary.getAmountsOut(factory, msg.value, path);
        require(
            amounts[amounts.length - 1] >= amountOutMin,
            "GetxRouter: INSUFFICIENT_OUTPUT_AMOUNT"
        );
        IWDCX(WDCX).deposit{value: amounts[0]}();
        assert(
            IWDCX(WDCX).transfer(
                DcxLibrary.pairFor(factory, path[0], path[1]),
                amounts[0]
            )
        );
        _swap(amounts, path, address(this)); 
         getFeeAndTransferUser(to,path[0],path[path.length -1], amounts[amounts.length - 1],0);
        emit _SwapExactETHForTokens(to, amounts);
    }

    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        virtual
        ensure(deadline)
        returns (uint[] memory amounts)
    {
        require(path[path.length - 1] == WDCX, 'PancakeRouter: INVALID_PATH');
        amounts = DcxLibrary.getAmountsIn(factory, amountOut, path);
        require(amounts[0] <= amountInMax, 'PancakeRouter: EXCESSIVE_INPUT_AMOUNT');
        TransferHelper.safeTransferFrom(
            path[0], msg.sender, DcxLibrary.pairFor(factory, path[0], path[1]), amounts[0]
        );
        _swap(amounts, path, address(this));
        IWDCX(WDCX).withdraw(amounts[amounts.length - 1]);
        // TransferHelper.safeTransferETH(to, amounts[amounts.length - 1]);
        getFeeAndTransferUser(to,path[0],path[path.length -1], amounts[amounts.length - 1],1);
    }

     function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external virtual  ensure(deadline) returns (uint[] memory amounts) {
        amounts = DcxLibrary.getAmountsIn(factory, amountOut, path);
        require(amounts[0] <= amountInMax, 'PancakeRouter: EXCESSIVE_INPUT_AMOUNT');
        TransferHelper.safeTransferFrom(
            path[0], msg.sender, DcxLibrary.pairFor(factory, path[0], path[1]), amounts[0]
        );
        _swap(amounts, path, address(this));
         getFeeAndTransferUser(to,path[0],path[path.length -1], amounts[amounts.length - 1],0);
    }
    

       function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        virtual
        payable
        ensure(deadline)
        returns (uint[] memory amounts)
    {
        require(path[0] == WDCX, 'PancakeRouter: INVALID_PATH');
        amounts = DcxLibrary.getAmountsIn(factory, amountOut, path);
        require(amounts[0] <= msg.value, 'PancakeRouter: EXCESSIVE_INPUT_AMOUNT');
        IWDCX(WDCX).deposit{value: amounts[0]}();
        assert(IWDCX(WDCX).transfer(DcxLibrary.pairFor(factory, path[0], path[1]), amounts[0]));
        _swap(amounts, path, address(this));
        // refund dust eth, if any
        if (msg.value > amounts[0]) TransferHelper.safeTransferETH(msg.sender, msg.value - amounts[0]);
          getFeeAndTransferUser(to,path[0],path[path.length -1], amounts[amounts.length - 1],0);
    }

    function getStableFee(address[2] memory _address) public view returns (uint256){
         uint256 showFee = stableFee[_address[0]][_address[1]].fee > 0?stableFee[_address[0]][_address[1]].fee:
         stableFee[_address[1]][_address[0]].fee > 0?stableFee[_address[1]][_address[0]].fee:Fee;
         return showFee;
    }
     
    function changeStablefee(address[2] memory _address, uint256 setFee) public controllers{
        stableFee[_address[0]][_address[1]].fee = setFee;
    } 

    function quote(
        uint256 amountA,
        address tokenA,
        address tokenB
    ) public view virtual returns (uint256 amountB) {
        (uint256 reserveA, uint256 reserveB) = DcxLibrary.getReserves(
            factory,
            tokenA,
            tokenB
        );
        return DcxLibrary.quote(amountA, reserveA, reserveB);
    }

    function getAmountOut(
        uint256 amountIn,
        uint256 reserveIn,
        uint256 reserveOut
    ) public pure virtual returns (uint256 amountOut) {
        return DcxLibrary.getAmountOut(amountIn, reserveIn, reserveOut);
    }

    function getAmountIn(
        uint256 amountOut,
        uint256 reserveIn,
        uint256 reserveOut
    ) public pure virtual returns (uint256 amountIn) {
        return DcxLibrary.getAmountIn(amountOut, reserveIn, reserveOut);
    }

    function getAmountsOut(uint256 amountIn, address[] memory path)
        public
        view
        virtual
        returns (uint256[] memory amounts)
    {
        return DcxLibrary.getAmountsOut(factory, amountIn, path);
    }

    function getAmountsIn(uint256 amountOut, address[] memory path)
        public
        view
        virtual
        returns (uint256[] memory amounts)
    {
        return DcxLibrary.getAmountsIn(factory, amountOut, path);
    }

    function removeLiquidityETH(
        address token,
        uint256 liquidity,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
        public
        virtual
        ensure(deadline)
        returns (uint256 amountToken, uint256 amountETH)
    {
        (amountToken, amountETH) = removeLiquidity(
            token,
            WDCX,
            liquidity,
            amountTokenMin,
            amountETHMin,
            address(this),
            deadline
        );
        TransferHelper.safeTransfer(token, to, amountToken);
        IWDCX(WDCX).withdraw(amountETH);
        TransferHelper.safeTransferETH(to, amountETH);
        emit _RemoveLiquidityETH(to, amountToken, amountETH);
    }

    function swapExactTokensForETH(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external virtual ensure(deadline) returns (uint256[] memory amounts) {
        require(path[path.length - 1] == WDCX, "GetxRouter: INVALID_PATH");
        amounts = DcxLibrary.getAmountsOut(factory, amountIn, path);
        require(
            amounts[amounts.length - 1] >= amountOutMin,
            "GetxRouter: INSUFFICIENT_OUTPUT_AMOUNT"
        );
        TransferHelper.safeTransferFrom(
            path[0],
            msg.sender,
            DcxLibrary.pairFor(factory, path[0], path[1]),
            amounts[0]
        );
        _swap(amounts, path, address(this));
        IWDCX(WDCX).withdraw(amounts[amounts.length - 1]);
       getFeeAndTransferUser(to,path[0],path[path.length -1], amounts[amounts.length - 1],1);
    }

    function getFeeAndTransferUser(address userAddress,address tokenA,address tokenB,uint256 amountsOut , uint256 status)internal{
        uint256 exeFee = stableFee[tokenA][tokenB].fee > 0?stableFee[tokenA][tokenB].fee:

         stableFee[tokenB][tokenA].fee > 0?stableFee[tokenB][tokenA].fee:Fee;
        uint256 _fee = (exeFee * amountsOut) / hundred;
        uint256 amountToSendToUser = amountsOut > _fee? amountsOut - _fee: _fee - amountsOut;
        if(tokenB == WDCX && status == 1){
         TransferHelper.safeTransferETH(
            userAddress,
            amountToSendToUser
          );
        if(_fee > 0){
         TransferHelper.safeTransferETH(
            owneraddress,
            _fee
         );
        }
        emit EstRecive(amountToSendToUser, _fee);
        }else{
         TransferHelper.safeTransfer(
                                tokenB,
                                userAddress,
                                amountToSendToUser
                            );
         if(_fee > 0){
         TransferHelper.safeTransfer(
                                tokenB,
                                owneraddress,
                                _fee
                            );
        }
       emit EstRecive(amountToSendToUser, _fee);
        }
    }

    struct ExecuteParams {
        uint256 amountOutMin;
        bool coinStatus;
        address[] path; 
        address user;
        uint256 _timeStamp;
    }

    function executedOrder(
        ExecuteParams calldata params,
        uint256 deadline
    ) external virtual controllers ensure(deadline) {

        bytes memory executionData = abi.encode(
            params.path[params.path.length - 1], 
            params.path[0],                     
            params._timeStamp,
            params.user
        );
        ITradeWallet.UserDetails memory result = ITradeWallet(tradeWallet).executed_call(executionData);
        require(result.userAddress == params.user, "userNotFound");
        
        uint256[] memory amounts = DcxLibrary.getAmountsOut(
            factory,
            result.amount,
            params.path
        );
        require(
            amounts[amounts.length - 1] >= params.amountOutMin,
            "PancakeRouter: EXCESSIVE_INPUT_AMOUNT"
        );
        if (result.sellToken == WDCX || result.buyToken == WDCX && params.coinStatus == true) {
            if (WDCX == params.path[0]) {
                assert(
                    IWDCX(WDCX).transfer(
                    DcxLibrary.pairFor(factory, params.path[0], params.path[1]),
                    amounts[0]
                )
               );
               _swap(amounts, params.path, address(this));
                getFeeAndTransferUser(result.userAddress,params.path[0],params.path[params.path.length -1],amounts[1],0);
            } else {
                require(
                    params.path[params.path.length - 1] == WDCX,
                    "GetxRouter: INVALID_PATH"
                );
                TransferHelper.safeTransfer(
                    params.path[0],
                    DcxLibrary.pairFor(factory, params.path[0], params.path[1]),
                    amounts[0]
                );
                _swap(amounts, params.path, address(this));
                IWDCX(WDCX).withdraw(amounts[amounts.length - 1]);
               getFeeAndTransferUser(result.userAddress,params.path[0],params.path[params.path.length -1],amounts[1],1);
            }
        } else {
            TransferHelper.safeTransfer(
                params.path[0],
                DcxLibrary.pairFor(factory, params.path[0], params.path[1]),
                amounts[0]
            );
            _swap(amounts, params.path, address(this));
            getFeeAndTransferUser(result.userAddress,params.path[0],params.path[params.path.length -1],amounts[1],0);
        }
    }

    function withdrawETH(address payable _to, uint256 _amount)
        public
        onlyContractOwner
        returns (uint256)
    {
        _to.transfer(_amount);
        return _amount;
    }
 
   function withdrawTokens(address _tokenAddress, uint256 _amount)
       public
       onlyContractOwner
   {
      require(IERC20(_tokenAddress).balanceOf(address(this)) >= _amount, "Insufficient balance");
      bool success = IERC20(_tokenAddress).transfer(msg.sender, _amount);
      require(success, "Token transfer failed");
    }

    function changeOwner(address _ownerAddress)public  onlyContractOwner{
           owneraddress = _ownerAddress;
    }

    function changeOperator(address newOperator)public  controllers{
           operator = newOperator;
    }

}
"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": true,
      "runs": 200
    },
    "evmVersion": "paris",
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    }
  }
}}