Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
// SPDX-License-Identifier: MIT pragma solidity ^0.8.18; /******************************************************************************************************** _______ ______ ______ ______ ______ ______ __ __ __ __ / \ / \ / \ / \ / \ / \ / | / | __ __ / / | $$$$$$$ |/$$$$$$ |/$$$$$$ | /$$$$$$ |/$$$$$$ |/$$$$$$ |$$ | $$ | / / | $$ $$/_ $$ |__$$ |$$ |__$$ |$$ | $$ | $$ | $$/ $$ |__$$ |$$ \__$$/ $$ |__$$ | $$ $$/_ / $$$ | $$ $$< $$ $$ |$$ | $$ | $$ | $$ $$ |$$ \ $$ $$ | / $$$ | $$$$$$$/ $$$$$$$ |$$$$$$$$ |$$ | $$ | $$ | __ $$$$$$$$ | $$$$$$ |$$$$$$$$ | $$$$$$$/ /$$$ | $$ | $$ |$$ | $$ |$$ \__$$ | $$ \__/ |$$ | $$ |/ \__$$ |$$ | $$ | /$$$ | $$/$$/ $$ | $$ |$$ | $$ |$$ $$/ $$ $$/ $$ | $$ |$$ $$/ $$ | $$ | $$/$$/ $$/ $$/ $$/ $$/ $$$$$$/ $$$$$$/ $$/ $$/ $$$$$$/ $$/ $$/ *********************************************************************************************************/ /// @title "RAO Cash Token" /// @notice Rao Cash is the world's first smart hyperdeflationary decentralized digital cryptocurrency with a sustainable and innovative ecosystem, for financial freedom and independence. /// @dev addressTreasury, addressCharity must be set after the deployment interface IERC20 { function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function transfer( address recipient, uint256 amount ) external returns (bool); function allowance( address owner, address spender ) external view returns (uint256); function approve(address spender, uint256 amount) external returns (bool); function transferFrom( address sender, address recipient, uint256 amount ) external returns (bool); event Transfer(address indexed from, address indexed to, uint256 value); event Approval( address indexed owner, address indexed spender, uint256 value ); } library SafeMath { function tryAdd( uint256 a, uint256 b ) internal pure returns (bool, uint256) { unchecked { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } } function trySub( uint256 a, uint256 b ) internal pure returns (bool, uint256) { unchecked { if (b > a) return (false, 0); return (true, a - b); } } function tryMul( uint256 a, uint256 b ) internal pure returns (bool, uint256) { unchecked { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } } function tryDiv( uint256 a, uint256 b ) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a / b); } } function tryMod( uint256 a, uint256 b ) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a % b); } } function add(uint256 a, uint256 b) internal pure returns (uint256) { return a + b; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return a - b; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { return a * b; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return a % b; } function sub( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b <= a, errorMessage); return a - b; } } function div( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a / b; } } function mod( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a % b; } } } abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } } library Address { function isContract(address account) internal view returns (bool) { uint256 size; assembly { size := extcodesize(account) } return size > 0; } function sendValue(address payable recipient, uint256 amount) internal { require( address(this).balance >= amount, "Address: insufficient balance" ); (bool success, ) = recipient.call{value: amount}(""); require( success, "Address: unable to send value, recipient may have reverted" ); } function functionCall( address target, bytes memory data ) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue( target, data, value, "Address: low-level call with value failed" ); } function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require( address(this).balance >= value, "Address: insufficient balance for call" ); require(isContract(target), "Address: call to non-contract"); (bool success, bytes memory returndata) = target.call{value: value}( data ); return _verifyCallResult(success, returndata, errorMessage); } function functionStaticCall( address target, bytes memory data ) internal view returns (bytes memory) { return functionStaticCall( target, data, "Address: low-level static call failed" ); } function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } function functionDelegateCall( address target, bytes memory data ) internal returns (bytes memory) { return functionDelegateCall( target, data, "Address: low-level delegate call failed" ); } function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) private pure returns (bytes memory) { if (success) { return returndata; } else { if (returndata.length > 0) { assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby disabling any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } 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; } interface IUniswapV2Pair { event Approval(address indexed owner, address indexed spender, uint value); event Transfer(address indexed from, address indexed to, uint 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 (uint); function balanceOf(address owner) external view returns (uint); function allowance( address owner, address spender ) external view returns (uint); function approve(address spender, uint value) external returns (bool); function transfer(address to, uint value) external returns (bool); function transferFrom( address from, address to, uint 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 (uint); function permit( address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s ) external; event Mint(address indexed sender, uint amount0, uint amount1); event Burn( address indexed sender, uint amount0, uint amount1, address indexed to ); event Swap( address indexed sender, uint amount0In, uint amount1In, uint amount0Out, uint amount1Out, address indexed to ); event Sync(uint112 reserve0, uint112 reserve1); function MINIMUM_LIQUIDITY() external pure returns (uint); 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 (uint); function price1CumulativeLast() external view returns (uint); function kLast() external view returns (uint); function mint(address to) external returns (uint liquidity); function burn(address to) external returns (uint amount0, uint amount1); function swap( uint amount0Out, uint amount1Out, address to, bytes calldata data ) external; function skim(address to) external; function sync() external; function initialize(address, address) external; } 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); } 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; } contract RaoToken is Context, IERC20, Ownable { using SafeMath for uint256; using Address for address; string private _name; string private _symbol; uint256 private _decimals; mapping(address => uint256) private _rOwned; mapping(address => uint256) private _tOwned; mapping(address => mapping(address => uint256)) private _allowances; mapping(address => bool) private _isExcludedFromFee; mapping(address => bool) private _isExcluded; /// @notice liquidity pair => usage mapping(address => bool) public pairs; address[] private _excluded; uint256 private constant MAX = type(uint256).max; uint256 private _tTotal; uint256 private _rTotal; uint256 private _tFeeTotal; /// @notice Commissions /// @notice Commission withheld from each purchase and sale (default - 8 %) uint256 public taxFee; /// @notice Commission returned to the liquidity pool (default - 3 %) uint256 public liquidityFee; /// @notice Commission to the treasury (default - 3 %) uint256 public treasuryFee; /// @notice Transfer fees (default - 1%) uint256 public txFee; /// @notice Percent to burn (default - 1%) uint256 public burnFee; uint256 private _previousTaxFee; uint256 private _previousLiquidityFee; uint256 private _previosTreasuryFee; uint256 private _previosTxFee; uint256 private _previosBurnFee; /// @notice Router Contract IUniswapV2Router02 public uniswapV2Router; /// @notice Router's pancakeswap address address public uniswapV2Pair; /// @dev non-reentrancy variable bool inSwapAndLiquify; /// @notice Activation of automatic replenishment of liquidity /// @dev To disable it, call the setSwapAndLiquifyEnabled function bool public swapAndLiquifyEnabled = true; /// @notice Maximum amount of purchase/sale of tokens uint256 public maxTxAmount; address public constant HYPERBURNADDR = 0x000000000000000000000000000000000000dEaD; /// @notice The number of tokens sold to increase liquidity uint256 public numTokensSellToAddToLiquidity; /// @notice Address for translation treasuryFee (marketing, development, project development) /// @dev Must be set after the deployment address public addressTreasury; /// @notice Address for charity /// @dev Must be set after the deployment address public addressCharity; event MinTokensBeforeSwapUpdated(uint256 minTokensBeforeSwap); event SwapAndLiquifyEnabledUpdated(bool enabled); event SwapAndLiquify( uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiqudity ); constructor () { _name = "Rao Cash"; _symbol = "RAO"; _decimals = 18; _tTotal = 1000000000 * 10 ** _decimals; _rTotal = (MAX - (MAX % _tTotal)); taxFee = 800; liquidityFee = 300; treasuryFee = 300; burnFee = 100; txFee = 100; _previousTaxFee = taxFee; _previousLiquidityFee = liquidityFee; _previosTreasuryFee = treasuryFee; _previosTxFee = txFee; _previosBurnFee = burnFee; maxTxAmount = ((1000000000 * 5) / 1000) * 10 ** _decimals; // 5 000 000 * 10 ** 18 numTokensSellToAddToLiquidity = ((1000000000 * 5) / 1000) * 10 ** _decimals; // 5 000 000 * 10 ** 18 address _tokenOwner = owner(); _rOwned[_tokenOwner] = _rTotal; IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x10ED43C718714eb63d5aA57B78B54704E256024E); uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH()); uniswapV2Router = _uniswapV2Router; _isExcludedFromFee[_tokenOwner] = true; _isExcludedFromFee[address(this)] = true; pairs[uniswapV2Pair] = true; emit Transfer(address(0), _tokenOwner, _tTotal); } modifier lockTheSwap() { inSwapAndLiquify = true; _; inSwapAndLiquify = false; } /// @notice Name of tokens function name() public view returns (string memory) { return _name; } /// @notice Sumbol function symbol() public view returns (string memory) { return _symbol; } /// @notice Decimals: 18 function decimals() public view returns (uint256) { return _decimals; } /// @notice Total number of tokens function totalSupply() public view override returns (uint256) { return _tTotal; } /// @notice Checking the balance of tokens taking into account the deflation coefficient function balanceOf(address account) public view override returns (uint256) { if (_isExcluded[account]) return _tOwned[account]; return tokenFromReflection(_rOwned[account]); } function burn(uint256 amount) external returns (bool) { _burn(_msgSender(), amount); return true; } function burnFrom(address account, uint256 amount) external returns (bool) { _burn(account, amount); _approve(account, _msgSender(), _allowances[account][_msgSender()].sub(amount, "BEP20: burn amount exceeds allowance")); return true; } /// @notice Transfer of tokens function transfer( address recipient, uint256 amount ) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } /// @notice The user can check the issued permission to write off tokens function allowance( address owner, address spender ) public view override returns (uint256) { return _allowances[owner][spender]; } /// @notice The user grants permission to debit tokens from his address function approve( address spender, uint256 amount ) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; } /// @notice You must first allow the debiting of tokens from your address function transferFrom( address sender, address recipient, uint256 amount ) public override returns (bool) { _transfer(sender, recipient, amount); _approve( sender, _msgSender(), _allowances[sender][_msgSender()].sub( amount, "ERC20: transfer amount exceeds allowance" ) ); return true; } /// @notice The user can increase the number of tokens allowed for debiting function increaseAllowance( address spender, uint256 addedValue ) public virtual returns (bool) { _approve( _msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue) ); return true; } /// @notice The user can reduce the number of tokens allowed for debiting function decreaseAllowance( address spender, uint256 subtractedValue ) public virtual returns (bool) { _approve( _msgSender(), spender, _allowances[_msgSender()][spender].sub( subtractedValue, "ERC20: decreased allowance below zero" ) ); return true; } /// @notice The owner opens trading on the dex exchange function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner { swapAndLiquifyEnabled = _enabled; emit SwapAndLiquifyEnabledUpdated(_enabled); } /// @dev Transfer of commissions from the non-reflected to the main balance of tokens function _reflectFee(uint256 rFee, uint256 tFee) private { _rTotal = _rTotal.sub(rFee); _tFeeTotal = _tFeeTotal.add(tFee); } function _takeBurn(uint256 rBurn, uint256 tBurn) private { _rOwned[HYPERBURNADDR] = _rOwned[HYPERBURNADDR].add(rBurn); if (_isExcluded[HYPERBURNADDR]) _tOwned[HYPERBURNADDR] = _tOwned[HYPERBURNADDR].add(tBurn); emit Transfer(_msgSender(), HYPERBURNADDR, tBurn); } /// @dev Zeroing all commissions function removeAllFee() private { _previousTaxFee = taxFee; _previousLiquidityFee = liquidityFee; _previosTreasuryFee = treasuryFee; _previosTxFee = txFee; _previosBurnFee = burnFee; taxFee = 0; liquidityFee = 0; treasuryFee = 0; txFee = 0; burnFee = 0; } /// @dev Restoring commissions function restoreAllFee() private { taxFee = _previousTaxFee; liquidityFee = _previousLiquidityFee; treasuryFee = _previosTreasuryFee; txFee = _previosTxFee; burnFee = _previosBurnFee; } /// @notice Total commission function totalFees() public view returns (uint256) { return _tFeeTotal; } function swapAndLiquify(uint256 contractTokenBalance) private lockTheSwap { uint256 half = contractTokenBalance.div(2); uint256 otherHalf = contractTokenBalance.sub(half); uint256 initialBalance = address(this).balance; swapTokensForEth(half); uint256 newBalance = address(this).balance.sub(initialBalance); addLiquidity(otherHalf, newBalance); emit SwapAndLiquify(half, newBalance, otherHalf); } function swapTokensForEth(uint256 tokenAmount) private { address[] memory path = new address[](2); path[0] = address(this); path[1] = uniswapV2Router.WETH(); _approve(address(this), address(uniswapV2Router), tokenAmount); uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens( tokenAmount, 0, // accept any amount of ETH path, address(this), block.timestamp ); } function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private { _approve(address(this), address(uniswapV2Router), tokenAmount); uniswapV2Router.addLiquidityETH{value: ethAmount}( address(this), tokenAmount, 0, // slippage is unavoidable 0, // slippage is unavoidable owner(), block.timestamp ); } function _getRate() private view returns (uint256) { (uint256 rSupply, uint256 tSupply) = _getCurrentSupply(); return rSupply.div(tSupply); } function _getValues( uint256 tAmount ) private view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256) { ( uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity, uint256 tTresury ) = _getTValues(tAmount); (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues( tAmount, tFee, tLiquidity, tTresury, _getRate() ); return ( rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tLiquidity, tTresury ); } function _getTValues( uint256 tAmount ) private view returns (uint256, uint256, uint256, uint256) { uint256 tFee = _calculateTaxFee(tAmount); uint256 tLiquidity = _calculateLiquidityFee(tAmount); uint256 tTresury = _calculateTresuryFee(tAmount); uint256 tTransferAmount = tAmount.sub(tFee).sub(tLiquidity).sub(tTresury); return (tTransferAmount, tFee, tLiquidity, tTresury); } function _getRValues( uint256 tAmount, uint256 tFee, uint256 tLiquidity, uint256 tTresury, uint256 currentRate ) private pure returns (uint256, uint256, uint256) { uint256 rAmount = tAmount.mul(currentRate); uint256 rFee = tFee.mul(currentRate); uint256 rLiquidity = tLiquidity.mul(currentRate); uint256 rTresury = tTresury.mul(currentRate); uint256 rTransferAmount = rAmount.sub(rFee).sub(rLiquidity).sub(rTresury); return (rAmount, rTransferAmount, rFee); } function _getValuesBurn(uint256 tAmount) private view returns (uint256, uint256) { uint256 tBurn = _calculateBurnFee(tAmount); uint256 rBurn = tBurn.mul(_getRate()); return (tBurn, rBurn); } function _getValuesInternal(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256, uint256) { (uint256 tBurn, uint256 rBurn) = _getValuesBurn(tAmount); uint256 tTxFee = _calculateTxFee(tAmount); // tx uint256 tTransferAmount = tAmount.sub(tTxFee).sub(tBurn); uint256 currentRate = _getRate(); uint256 rAmount = tAmount.mul(currentRate); uint256 rTxFee = tTxFee.mul(currentRate); uint256 rTransferAmount = rAmount.sub(rTxFee).sub(rBurn); return (rAmount, rTransferAmount, rTxFee, rBurn, tTransferAmount, tTxFee, tBurn); } function _calculateTaxFee(uint256 _amount) private view returns (uint256) { return _amount.mul(taxFee).div(10 ** 4); } // txFee function _calculateTxFee(uint256 _amount) private view returns (uint256) { return _amount.mul(txFee).div(10 ** 4); } function _calculateTresuryFee(uint256 _amount) private view returns (uint256) { return _amount.mul(treasuryFee).div(10 ** 4); } function _calculateLiquidityFee(uint256 _amount) private view returns (uint256) { return _amount.mul(liquidityFee).div(10 ** 4); } function _calculateBurnFee(uint256 _amount) private view returns (uint256) { return _amount.mul(burnFee).div(10 ** 4); } // @dev The liquidity is credited to the address of the contract function _takeLiquidity(uint256 tLiquidity) private { uint256 currentRate = _getRate(); uint256 rLiquidity = tLiquidity.mul(currentRate); _rOwned[address(this)] = _rOwned[address(this)].add(rLiquidity); if (_isExcluded[address(this)]) _tOwned[address(this)] = _tOwned[address(this)].add(tLiquidity); } function _takeTresury(uint256 tTresury) private { uint256 currentRate = _getRate(); uint256 rTresury = tTresury.mul(currentRate); _rOwned[addressTreasury] = _rOwned[addressTreasury].add(rTresury); if (_isExcluded[addressTreasury]) _tOwned[addressTreasury] = _tOwned[addressTreasury].add(tTresury); } function _transfer(address from, address to, uint256 amount) private { require(from != address(0), "ERC20: transfer from the zero address"); require(amount > 0, "Transfer amount must be greater than zero"); if (from != owner() && to != owner()) require( amount <= maxTxAmount, "Transfer amount exceeds the maxTxAmount." ); uint256 contractTokenBalance = balanceOf(address(this)); if (contractTokenBalance >= maxTxAmount) { contractTokenBalance = maxTxAmount; } bool overMinTokenBalance = contractTokenBalance >= numTokensSellToAddToLiquidity; if ( overMinTokenBalance && !inSwapAndLiquify && from != uniswapV2Pair && swapAndLiquifyEnabled ) { contractTokenBalance = numTokensSellToAddToLiquidity; swapAndLiquify(contractTokenBalance); } bool takeFee = true; if (_isExcludedFromFee[from] || _isExcludedFromFee[to]) { takeFee = false; } _tokenTransfer(from, to, amount, takeFee); } function _tokenTransfer( address sender, address recipient, uint256 amount, bool takeFee ) private { if (!takeFee) removeAllFee(); if(pairs[sender] || pairs[recipient]) { if (_isExcluded[sender] && !_isExcluded[recipient]) { _transferFromExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && _isExcluded[recipient]) { _transferToExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && !_isExcluded[recipient]) { _transferStandard(sender, recipient, amount); } else if (_isExcluded[sender] && _isExcluded[recipient]) { _transferBothExcluded(sender, recipient, amount); } else { _transferStandard(sender, recipient, amount); } } else { if (_isExcluded[sender] && !_isExcluded[recipient]) { _transferInternalFromExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && _isExcluded[recipient]) { _transferInternalToExcluded(sender, recipient, amount); } else if (!_isExcluded[sender] && !_isExcluded[recipient]) { _transferInternalStandard(sender, recipient, amount); } else if (_isExcluded[sender] && _isExcluded[recipient]) { _transferInternalBothExcluded(sender, recipient, amount); } else { _transferInternalStandard(sender, recipient, amount); } } if (!takeFee) restoreAllFee(); } // buy/sell transfer function _transferBothExcluded( address sender, address recipient, uint256 tAmount ) private { ( uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity, uint256 tTresury ) = _getValues(tAmount); (uint256 tBurn, uint256 rBurn) = _getValuesBurn(tAmount); _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient] + (tTransferAmount - tBurn); _rOwned[recipient] = _rOwned[recipient] + (rTransferAmount - rBurn); _takeLiquidity(tLiquidity); _takeTresury(tTresury); _reflectFee(rFee, tFee); _takeBurn(rBurn, tBurn); emit Transfer(sender, recipient, (tTransferAmount - tBurn)); } function _transferStandard( address sender, address recipient, uint256 tAmount ) private { ( uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity, uint256 tTresury ) = _getValues(tAmount); (uint256 tBurn, uint256 rBurn) = _getValuesBurn(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient] + (rTransferAmount - rBurn); _takeLiquidity(tLiquidity); _takeTresury(tTresury); _reflectFee(rFee, tFee); _takeBurn(rBurn, tBurn); emit Transfer(sender, recipient, (tTransferAmount - tBurn)); } function _transferToExcluded( address sender, address recipient, uint256 tAmount ) private { ( uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity, uint256 tTresury ) = _getValues(tAmount); (uint256 tBurn, uint256 rBurn) = _getValuesBurn(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient] + (tTransferAmount - tBurn); _rOwned[recipient] = _rOwned[recipient] + (rTransferAmount - rBurn); _takeLiquidity(tLiquidity); _takeTresury(tTresury); _reflectFee(rFee, tFee); _takeBurn(rBurn, tBurn); emit Transfer(sender, recipient, (tTransferAmount - tBurn)); } function _transferFromExcluded( address sender, address recipient, uint256 tAmount ) private { ( uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tLiquidity, uint256 tTresury ) = _getValues(tAmount); (uint256 tBurn, uint256 rBurn) = _getValuesBurn(tAmount); _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient] + (rTransferAmount - rBurn); _takeLiquidity(tLiquidity); _takeTresury(tTresury); _reflectFee(rFee, tFee); _takeBurn(rBurn, tBurn); emit Transfer(sender, recipient, (tTransferAmount - tBurn)); } // internal transfer function _transferInternalBothExcluded( address sender, address recipient, uint256 tAmount ) private { ( uint256 rAmount, uint256 rTransferAmount, uint256 rTxFee, uint256 rBurn, uint256 tTransferAmount, uint256 tTxFee, uint256 tBurn ) = _getValuesInternal(tAmount); _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rTxFee, tTxFee); _takeBurn(rBurn, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _transferInternalStandard( address sender, address recipient, uint256 tAmount ) private { ( uint256 rAmount, uint256 rTransferAmount, uint256 rTxFee, uint256 rBurn, uint256 tTransferAmount, uint256 tTxFee, uint256 tBurn ) = _getValuesInternal(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rTxFee, tTxFee); _takeBurn(rBurn, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _transferInternalToExcluded( address sender, address recipient, uint256 tAmount ) private { ( uint256 rAmount, uint256 rTransferAmount, uint256 rTxFee, uint256 rBurn, uint256 tTransferAmount, uint256 tTxFee, uint256 tBurn ) = _getValuesInternal(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _tOwned[recipient] = _tOwned[recipient].add(tTransferAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rTxFee, tTxFee); _takeBurn(rBurn, tBurn); emit Transfer(sender, recipient, tTransferAmount); } function _transferInternalFromExcluded( address sender, address recipient, uint256 tAmount ) private { ( uint256 rAmount, uint256 rTransferAmount, uint256 rTxFee, uint256 rBurn, uint256 tTransferAmount, uint256 tTxFee, uint256 tBurn ) = _getValuesInternal(tAmount); _tOwned[sender] = _tOwned[sender].sub(tAmount); _rOwned[sender] = _rOwned[sender].sub(rAmount); _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount); _reflectFee(rTxFee, tTxFee); _takeBurn(rBurn, tBurn); emit Transfer(sender, recipient, tTransferAmount); } /// @notice The owner can exclude the address from the deduction of commissions function excludeFromFee(address account) public onlyOwner { _isExcludedFromFee[account] = true; } /// @notice The owner can enable commission deduction for the address function includeInFee(address account) public onlyOwner { _isExcludedFromFee[account] = false; } function _getCurrentSupply() private view returns (uint256, uint256) { uint256 rSupply = _rTotal; uint256 tSupply = _tTotal; for (uint256 i = 0; i < _excluded.length; i++) { if ( _rOwned[_excluded[i]] > rSupply || _tOwned[_excluded[i]] > tSupply ) return (_rTotal, _tTotal); rSupply = rSupply.sub(_rOwned[_excluded[i]]); tSupply = tSupply.sub(_tOwned[_excluded[i]]); } if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal); return (rSupply, tSupply); } function _approve(address owner, address spender, uint256 amount) private { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /// @notice Returns true if the address is excluded from commission deduction function isExcludedFromFee(address account) public view returns (bool) { return _isExcludedFromFee[account]; } /// @notice Returns true when the address is excluded from interest accrual function isExcludedFromReward(address account) public view returns (bool) { return _isExcluded[account]; } /// @notice The owner can exclude the address from interest accrual function excludeFromReward(address account) public onlyOwner { require(!_isExcluded[account], "Account is already excluded"); if (_rOwned[account] > 0) { _tOwned[account] = tokenFromReflection(_rOwned[account]); } _isExcluded[account] = true; _excluded.push(account); } /// @notice The owner can enable the user to charge interest function includeInReward(address account) external onlyOwner { require(_isExcluded[account], "Account is already included"); for (uint256 i = 0; i < _excluded.length; i++) { if (_excluded[i] == account) { uint256 currentRate = _getRate(); uint256 rBalance = _tOwned[account].mul(currentRate); _excluded[i] = _excluded[_excluded.length - 1]; _tOwned[account] = 0; _isExcluded[account] = false; _excluded.pop(); uint256 diff = _rOwned[account].sub(rBalance); _rOwned[account] = rBalance; _rTotal = _rTotal.sub(diff); break; } } } /// @notice The user can check the balance of tokens from reflection function tokenFromReflection( uint256 rAmount ) internal view returns (uint256) { require( rAmount <= _rTotal, "Amount must be less than total reflections" ); uint256 currentRate = _getRate(); return rAmount.div(currentRate); } /// @notice The owner changes the router address function setRouterAddress(address newRouter) external onlyOwner { IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(newRouter); uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()) .createPair(address(this), _uniswapV2Router.WETH()); uniswapV2Router = _uniswapV2Router; } /// @notice Set new pair function setNewPair(address _pair) public onlyOwner { require(!pairs[_pair], "This pair added already"); pairs[_pair] = true; } /// @notice Changing the auto-liquidity threshold function setNumTokensSellToAddToLiquidity( uint256 amountToUpdate ) external onlyOwner { numTokensSellToAddToLiquidity = amountToUpdate; } /// @notice The owner sets the maximum amount of purchase/sale of tokens function setMaxTxPercent(uint256 maxTxPercent) public onlyOwner { maxTxAmount = maxTxPercent * 10 ** _decimals; } /// @notice The owner sets the address of treasury function setAddressTreasury(address _newTreasury) public onlyOwner { addressTreasury = _newTreasury; } /// @notice Set new charity address function setAddressCharity(address _newCharity) public onlyOwner { addressCharity = _newCharity; } /// @notice Set new taxFee function setTaxFee(uint _newValue) public onlyOwner { taxFee = _newValue; } /// @notice Set new liquidityFee function setLiquidityFee(uint _newValue) public onlyOwner { liquidityFee = _newValue; } /// @notice Set new treasuryFee function setTreasuryFee(uint _newValue) public onlyOwner { treasuryFee = _newValue; } /// @notice Set new txFee function setTxFee(uint _newValue) public onlyOwner { txFee = _newValue; } /// @notice Set new burnFee function setBurnFee(uint _newValue) public onlyOwner { burnFee = _newValue; } /// @notice The owner can withdraw ETH from the contract address function claimBNB() public onlyOwner { payable(owner()).transfer(address(this).balance); } /// @notice to recieve ETH from uniswapV2Router when swaping receive() external payable {} function _burn(address account, uint256 amount) private { require(account != address(0), "BEP20: burn from the zero address"); (uint256 rAmount,,,,,,) = _getValues(amount); _rOwned[account] = _rOwned[account].sub(rAmount); if(_isExcluded[account]) _tOwned[account] = _tOwned[account].sub(amount); _rOwned[HYPERBURNADDR] = _rOwned[HYPERBURNADDR].add(rAmount); if (_isExcluded[HYPERBURNADDR]) _tOwned[HYPERBURNADDR] = _tOwned[HYPERBURNADDR].add(amount); emit Transfer(account, HYPERBURNADDR, amount); } }
- Loading branch information