pragma solidity >=0.5.0;

interface IUniswapV2Factory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);

    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(uint) external view returns (address pair);
    function allPairsLength() external view returns (uint);

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

    function setFeeTo(address) external;
    function setFeeToSetter(address) external;
}

pragma solidity >=0.6.2;

interface IUniswapV2Router01 {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}

pragma solidity >=0.6.2;

import './IUniswapV2Router01.sol';

interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    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;
}

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

import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.9.6/contracts/token/ERC20/ERC20.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.9.6/contracts/access/Ownable.sol";

import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";


contract WhisprToken is ERC20, Ownable {
    IUniswapV2Router02 public immutable uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
    address public uniswapV2Pair;

    uint256 public buyFeePercentage = 1;
    uint256 public sellFeePercentage = 1;

    uint256 public treasuryPercentage = 70;
    uint256 public devPercentage = 30;

    address public treasuryWallet;
    address public devWallet;

    uint256 public tokenSwapThreshold;

    bool public tradingEnabled = false;
    bool private swapping;

    mapping(address => bool) public isExcludedFromFees;
    mapping(address => bool) public isPair;

    event FeesCollectedInETH(uint256 tokenAmount, uint256 ethAmount);
    event SwapTokensForEth(uint256 tokenAmount, uint256 ethAmount);
    event FeesWithdrawn(uint256 ethAmount);
    event TradingEnabled(bool enabled);

    error InvalidFeeSplitPercentage();
    error BuyFeeTooHigh();
    error SellFeeTooHigh();
    error FailedToSendEthToTreasuryWallet();
    error FailedToSendEthToDevWallet();
    error TradingNotEnabled();
    error InvalidPairAddress();

    constructor(
        address _treasuryWallet,
        address _devWallet,
        uint256 _tokenSwapThreshold
    ) ERC20("Whispr", "WHISPR") Ownable() {
        _mint(msg.sender, 1_000_000_000 ether);

        treasuryWallet = _treasuryWallet;
        devWallet = _devWallet;
        tokenSwapThreshold = _tokenSwapThreshold;

        address WETH = uniswapV2Router.WETH();
        uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory())
            .createPair(address(this), WETH);
        isPair[uniswapV2Pair] = true;

        isExcludedFromFees[owner()] = true;
        isExcludedFromFees[address(this)] = true;

        // Approve Uniswap router to spend tokens from this contract
        _approve(address(this), address(uniswapV2Router), type(uint256).max);
    }

    function excludeFromFees(address account, bool excluded) external onlyOwner {
        isExcludedFromFees[account] = excluded;
    }

    function setTreasuryWallet(address _treasuryWallet) external onlyOwner {
        treasuryWallet = _treasuryWallet;
    }

    function setDevWallet(address _devWallet) external onlyOwner {
        devWallet = _devWallet;
    }

    function setFeeSplitPercentage(
        uint256 _treasuryPercentage,
        uint256 _devPercentage
    ) external onlyOwner {
        if (_treasuryPercentage + _devPercentage != 100) {
            revert InvalidFeeSplitPercentage();
        }
        treasuryPercentage = _treasuryPercentage;
        devPercentage = _devPercentage;
    }

    function setBuyFeePercentage(uint256 percentage) external onlyOwner {
        if (percentage > 30) {
            revert BuyFeeTooHigh();
        }
        buyFeePercentage = percentage;
    }

    function setSellFeePercentage(uint256 percentage) external onlyOwner {
        if (percentage > 30) {
            revert SellFeeTooHigh();
        }
        sellFeePercentage = percentage;
    }

    function setTokenSwapThreshold(uint256 _threshold) external onlyOwner {
        tokenSwapThreshold = _threshold;
    }

    function enableTrading() external onlyOwner {
        tradingEnabled = !tradingEnabled;
        emit TradingEnabled(true);
    }

    function addPair(address pair) external onlyOwner {
        if (pair == address(0) || pair == address(this)) {
            revert InvalidPairAddress();
        }
        isPair[pair] = true;
    }

    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal override {

        bool isBuy = isPair[sender] && recipient != address(this);
        bool isSell = isPair[recipient] && sender != address(this);

        bool skipFees = isExcludedFromFees[sender] || isExcludedFromFees[recipient];

        if (!skipFees && (isBuy || isSell)) {

            if (!tradingEnabled) {
                revert TradingNotEnabled();
            }
            
            uint256 feePercentageToApply = 0;

            if (isBuy) {
                feePercentageToApply = buyFeePercentage;
            } else if (isSell) {
                feePercentageToApply = sellFeePercentage;
            }

            uint256 fee = 0; 
            
            if (feePercentageToApply > 0) {
                fee = (amount * feePercentageToApply) / 100;
                super._transfer(sender, address(this), fee);

                // Check if contract has accumulated enough tokens to perform a swap
                uint256 contractTokenBalance = balanceOf(address(this));

                if (!swapping && isSell && contractTokenBalance >= tokenSwapThreshold) {
                    swapping = true;
                    _swapTokensForEth(contractTokenBalance);
                    swapping = false;
                }
            }

            super._transfer(sender, recipient, amount - fee);
        } else {
            super._transfer(sender, recipient, amount);
        }
    }

    function _swapTokensForEth(uint256 tokenAmount) private {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = uniswapV2Router.WETH();

        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0,
            path,
            address(this),
            block.timestamp
        );

        uint256 ethBalance = address(this).balance;

        emit SwapTokensForEth(tokenAmount, ethBalance);

        _distributeFees(ethBalance);
    }

    function _distributeFees(uint256 ethAmount) private {
        uint256 treasuryETH = (ethAmount * treasuryPercentage) / 100;
        uint256 devETH = ethAmount - treasuryETH;

        // We send via .call because we don't want to have problems sending to multisig contract wallets
        (bool successTreasury, ) = treasuryWallet.call{value: treasuryETH}("");
        if (!successTreasury) {
            revert FailedToSendEthToTreasuryWallet();
        }

        (bool successDev, ) = devWallet.call{value: devETH}("");
        if (!successDev) {
            revert FailedToSendEthToDevWallet();
        }

        emit FeesWithdrawn(ethAmount);
    }

    receive() external payable {}
}

{
  "compilationTarget": {
    "contracts/WhisprToken.sol": "WhisprToken"
  },
  "evmVersion": "shanghai",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": []
}