Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
IterableMapping
Compiler Version
v0.8.13+commit.abaa5c0e
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2022-05-20 */ // SPDX-License-Identifier: MIT pragma solidity 0.8.13; 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 ); } interface IFactory { function createPair(address tokenA, address tokenB) external returns (address pair); function getPair(address tokenA, address tokenB) external view returns (address pair); } interface IRouter { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidityETH( address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline ) external payable returns ( uint256 amountToken, uint256 amountETH, uint256 liquidity ); function swapExactETHForTokensSupportingFeeOnTransferTokens( uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens( uint256 amountIn, uint256 amountOutMin, address[] calldata path, address to, uint256 deadline ) external; } interface IERC20Metadata is IERC20 { function name() external view returns (string memory); function symbol() external view returns (string memory); function decimals() external view returns (uint8); } interface DividendPayingTokenInterface { function dividendOf(address _owner) external view returns(uint256); function withdrawDividend() external; event DividendsDistributed( address indexed from, uint256 weiAmount ); event DividendWithdrawn( address indexed to, uint256 weiAmount ); } interface DividendPayingTokenOptionalInterface { function withdrawableDividendOf(address _owner) external view returns(uint256); function withdrawnDividendOf(address _owner) external view returns(uint256); function accumulativeDividendOf(address _owner) external view returns(uint256); } library SafeMath { function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } function mul(uint256 a, uint256 b) internal pure returns (uint256) { // 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 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } library SafeMathInt { int256 private constant MIN_INT256 = int256(1) << 255; int256 private constant MAX_INT256 = ~(int256(1) << 255); function mul(int256 a, int256 b) internal pure returns (int256) { int256 c = a * b; // Detect overflow when multiplying MIN_INT256 with -1 require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256)); require((b == 0) || (c / b == a)); return c; } function div(int256 a, int256 b) internal pure returns (int256) { // Prevent overflow when dividing MIN_INT256 by -1 require(b != -1 || a != MIN_INT256); // Solidity already throws when dividing by 0. return a / b; } function sub(int256 a, int256 b) internal pure returns (int256) { int256 c = a - b; require((b >= 0 && c <= a) || (b < 0 && c > a)); return c; } function add(int256 a, int256 b) internal pure returns (int256) { int256 c = a + b; require((b >= 0 && c >= a) || (b < 0 && c < a)); return c; } function abs(int256 a) internal pure returns (int256) { require(a != MIN_INT256); return a < 0 ? -a : a; } function toUint256Safe(int256 a) internal pure returns (uint256) { require(a >= 0); return uint256(a); } } library SafeMathUint { function toInt256Safe(uint256 a) internal pure returns (int256) { int256 b = int256(a); require(b >= 0); return b; } } library IterableMapping { struct Map { address[] keys; mapping(address => uint) values; mapping(address => uint) indexOf; mapping(address => bool) inserted; } function get(Map storage map, address key) public view returns (uint) { return map.values[key]; } function getIndexOfKey(Map storage map, address key) public view returns (int) { if(!map.inserted[key]) { return -1; } return int(map.indexOf[key]); } function getKeyAtIndex(Map storage map, uint index) public view returns (address) { return map.keys[index]; } function size(Map storage map) public view returns (uint) { return map.keys.length; } function set(Map storage map, address key, uint val) public { if (map.inserted[key]) { map.values[key] = val; } else { map.inserted[key] = true; map.values[key] = val; map.indexOf[key] = map.keys.length; map.keys.push(key); } } function remove(Map storage map, address key) public { if (!map.inserted[key]) { return; } delete map.inserted[key]; delete map.values[key]; uint index = map.indexOf[key]; uint lastIndex = map.keys.length - 1; address lastKey = map.keys[lastIndex]; map.indexOf[lastKey] = index; delete map.indexOf[key]; map.keys[index] = lastKey; map.keys.pop(); } } 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; } } contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); constructor () { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } function owner() public view returns (address) { return _owner; } modifier onlyOwner() { require(_owner == _msgSender(), "Ownable: caller is not the owner"); _; } function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } contract ERC20 is Context, IERC20, IERC20Metadata { using SafeMath for uint256; mapping(address => uint256) private _balances; mapping(address => mapping(address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } function name() public view virtual override returns (string memory) { return _name; } function symbol() public view virtual override returns (string memory) { return _symbol; } function decimals() public view virtual override returns (uint8) { return 18; } function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } function transferFrom( address sender, address recipient, uint256 amount ) public virtual override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } 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; } function _transfer( address sender, address recipient, uint256 amount ) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } function _approve( address owner, address spender, uint256 amount ) internal virtual { 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); } function _beforeTokenTransfer( address from, address to, uint256 amount ) internal virtual {} } contract DividendPayingToken is ERC20, Ownable, DividendPayingTokenInterface, DividendPayingTokenOptionalInterface { using SafeMath for uint256; using SafeMathUint for uint256; using SafeMathInt for int256; uint256 constant internal magnitude = 2**128; uint256 internal magnifiedDividendPerShare; uint256 public totalDividendsDistributed; address public rewardToken; mapping(address => int256) internal magnifiedDividendCorrections; mapping(address => uint256) internal withdrawnDividends; constructor(string memory _name, string memory _symbol) ERC20(_name, _symbol) {} receive() external payable {} function distributeDividendsUsingAmount(uint256 amount) public onlyOwner { require(totalSupply() > 0); if (amount > 0) { magnifiedDividendPerShare = magnifiedDividendPerShare.add((amount).mul(magnitude) / totalSupply()); emit DividendsDistributed(msg.sender, amount); totalDividendsDistributed = totalDividendsDistributed.add(amount); } } function withdrawDividend() public virtual override { _withdrawDividendOfUser(payable(msg.sender)); } function _withdrawDividendOfUser(address payable user) internal returns (uint256) { uint256 _withdrawableDividend = withdrawableDividendOf(user); if (_withdrawableDividend > 0) { withdrawnDividends[user] = withdrawnDividends[user].add(_withdrawableDividend); emit DividendWithdrawn(user, _withdrawableDividend); (bool success) = IERC20(rewardToken).transfer(user, _withdrawableDividend); if(!success) { withdrawnDividends[user] = withdrawnDividends[user].sub(_withdrawableDividend); return 0; } return _withdrawableDividend; } return 0; } function dividendOf(address _owner) public view override returns(uint256) { return withdrawableDividendOf(_owner); } function withdrawableDividendOf(address _owner) public view override returns(uint256) { return accumulativeDividendOf(_owner).sub(withdrawnDividends[_owner]); } function withdrawnDividendOf(address _owner) public view override returns(uint256) { return withdrawnDividends[_owner]; } function accumulativeDividendOf(address _owner) public view override returns(uint256) { return magnifiedDividendPerShare.mul(balanceOf(_owner)).toInt256Safe() .add(magnifiedDividendCorrections[_owner]).toUint256Safe() / magnitude; } function _transfer(address from, address to, uint256 value) internal virtual override { require(false); int256 _magCorrection = magnifiedDividendPerShare.mul(value).toInt256Safe(); magnifiedDividendCorrections[from] = magnifiedDividendCorrections[from].add(_magCorrection); magnifiedDividendCorrections[to] = magnifiedDividendCorrections[to].sub(_magCorrection); } function _mint(address account, uint256 value) internal override { super._mint(account, value); magnifiedDividendCorrections[account] = magnifiedDividendCorrections[account] .sub( (magnifiedDividendPerShare.mul(value)).toInt256Safe() ); } function _burn(address account, uint256 value) internal override { super._burn(account, value); magnifiedDividendCorrections[account] = magnifiedDividendCorrections[account] .add( (magnifiedDividendPerShare.mul(value)).toInt256Safe() ); } function _setBalance(address account, uint256 newBalance) internal { uint256 currentBalance = balanceOf(account); if(newBalance > currentBalance) { uint256 mintAmount = newBalance.sub(currentBalance); _mint(account, mintAmount); } else if(newBalance < currentBalance) { uint256 burnAmount = currentBalance.sub(newBalance); _burn(account, burnAmount); } } function _setRewardToken(address token) internal onlyOwner { rewardToken = token; } } contract KryptoPets is ERC20, Ownable { IRouter public uniswapV2Router; address public immutable uniswapV2Pair; string private constant _name = "Krypto Pets"; string private constant _symbol = "KPETS"; uint8 private constant _decimals = 18; KryptoPetsDividendTracker public dividendTracker; bool public isTradingEnabled; uint256 private _tradingPausedTimestamp; // initialSupply uint256 constant initialSupply = 1000000000000000 * (10**18); // max wallet is 2% of initialSupply uint256 public maxWalletAmount = initialSupply * 200 / 10000; // max tx is 1% of initialSupply uint256 public maxTxAmount = initialSupply * 100 / 10000; bool private _swapping; uint256 public minimumTokensBeforeSwap = 25000000 * (10**18); address public liquidityWallet; address public devWallet; address public buyBackWallet; address public gamingWallet; struct CustomTaxPeriod { bytes23 periodName; uint8 blocksInPeriod; uint256 timeInPeriod; uint256 liquidityFeeOnBuy; uint256 liquidityFeeOnSell; uint256 devFeeOnBuy; uint256 devFeeOnSell; uint256 buyBackFeeOnBuy; uint256 buyBackFeeOnSell; uint256 gamingFeeOnBuy; uint256 gamingFeeOnSell; uint256 holdersFeeOnBuy; uint256 holdersFeeOnSell; } // Launch taxes uint256 private _launchTimestamp; uint256 private _launchBlockNumber; // Base taxes CustomTaxPeriod private _base = CustomTaxPeriod('base',0,0,100,100,550,550,200,200,150,150,200,200); mapping (address => bool) private _isAllowedToTradeWhenDisabled; mapping (address => bool) private _feeOnSelectedWalletTransfers; mapping (address => bool) private _isExcludedFromFee; mapping (address => bool) private _isExcludedFromMaxWalletLimit; mapping (address => bool) private _isExcludedFromMaxTransactionLimit; mapping (address => bool) public automatedMarketMakerPairs; uint256 private _liquidityFee; uint256 private _devFee; uint256 private _buyBackFee; uint256 private _gamingFee; uint256 private _holdersFee; uint256 private _totalFee; event AutomatedMarketMakerPairChange(address indexed pair, bool indexed value); event UniswapV2RouterChange(address indexed newAddress, address indexed oldAddress); event WalletChange(string indexed walletIdentifier, address indexed newWallet, address indexed oldWallet); event FeeChange(string indexed identifier, uint256 liquidityFee, uint256 devFee, uint256 buyBackFee, uint256 gamingFee, uint256 holdersFee); event CustomTaxPeriodChange(uint256 indexed newValue, uint256 indexed oldValue, string indexed taxType, bytes23 period); event AllowedWhenTradingDisabledChange(address indexed account, bool isExcluded); event MinTokenAmountBeforeSwapChange(uint256 indexed newValue, uint256 indexed oldValue); event ExcludeFromFeesChange(address indexed account, bool isExcluded); event ExcludeFromMaxWalletChange(address indexed account, bool isExcluded); event ExcludeFromMaxTransferChange(address indexed account, bool isExcluded); event FeeOnSelectedWalletTransfersChange(address indexed account, bool newValue); event DividendsSent(uint256 tokensSwapped); event SwapAndLiquify(uint256 tokensSwapped, uint256 ethReceived,uint256 tokensIntoLiqudity); event ClaimETHOverflow(uint256 amount); event FeesApplied(uint256 liquidityFee, uint256 devFee, uint256 buyBackFee, uint256 gamingFee, uint256 holdersFee, uint256 totalFee); constructor() ERC20(_name, _symbol) { liquidityWallet = owner(); devWallet = owner(); buyBackWallet = owner(); gamingWallet = owner(); dividendTracker = new KryptoPetsDividendTracker(); dividendTracker.setRewardToken(address(this)); IRouter _uniswapV2Router = IRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); // Mainnet address _uniswapV2Pair = IFactory(_uniswapV2Router.factory()).createPair( address(this), _uniswapV2Router.WETH() ); uniswapV2Router = _uniswapV2Router; uniswapV2Pair = _uniswapV2Pair; _setAutomatedMarketMakerPair(_uniswapV2Pair, true); _isExcludedFromFee[owner()] = true; _isExcludedFromFee[address(this)] = true; _isExcludedFromFee[address(dividendTracker)] = true; _isAllowedToTradeWhenDisabled[owner()] = true; _isAllowedToTradeWhenDisabled[address(this)] = true; dividendTracker.excludeFromDividends(address(dividendTracker)); dividendTracker.excludeFromDividends(address(this)); dividendTracker.excludeFromDividends(address(0x000000000000000000000000000000000000dEaD)); dividendTracker.excludeFromDividends(owner()); dividendTracker.excludeFromDividends(address(_uniswapV2Router)); _isExcludedFromMaxWalletLimit[_uniswapV2Pair] = true; _isExcludedFromMaxWalletLimit[address(dividendTracker)] = true; _isExcludedFromMaxWalletLimit[address(uniswapV2Router)] = true; _isExcludedFromMaxWalletLimit[address(this)] = true; _isExcludedFromMaxWalletLimit[owner()] = true; _isExcludedFromMaxTransactionLimit[address(dividendTracker)] = true; _isExcludedFromMaxTransactionLimit[address(this)] = true; _isExcludedFromMaxTransactionLimit[owner()] = true; _mint(owner(), initialSupply); } receive() external payable {} // Setters function activateTrading() external onlyOwner { isTradingEnabled = true; if (_launchTimestamp == 0) { _launchTimestamp = block.timestamp; _launchBlockNumber = block.number; } } function deactivateTrading() external onlyOwner { isTradingEnabled = false; } function _setAutomatedMarketMakerPair(address pair, bool value) private { require(automatedMarketMakerPairs[pair] != value, "KryptoPets: Automated market maker pair is already set to that value"); automatedMarketMakerPairs[pair] = value; if(value) { dividendTracker.excludeFromDividends(pair); } emit AutomatedMarketMakerPairChange(pair, value); } function allowTradingWhenDisabled(address account, bool allowed) external onlyOwner { _isAllowedToTradeWhenDisabled[account] = allowed; emit AllowedWhenTradingDisabledChange(account, allowed); } function excludeFromFees(address account, bool excluded) external onlyOwner { require(_isExcludedFromFee[account] != excluded, "KryptoPets: Account is already the value of 'excluded'"); _isExcludedFromFee[account] = excluded; emit ExcludeFromFeesChange(account, excluded); } function excludeFromDividends(address account) external onlyOwner { dividendTracker.excludeFromDividends(account); } function excludeFromMaxWalletLimit(address account, bool excluded) external onlyOwner { require(_isExcludedFromMaxWalletLimit[account] != excluded, "KryptoPets: Account is already the value of 'excluded'"); _isExcludedFromMaxWalletLimit[account] = excluded; emit ExcludeFromMaxWalletChange(account, excluded); } function excludeFromMaxTransactionLimit(address account, bool excluded) external onlyOwner { require(_isExcludedFromMaxTransactionLimit[account] != excluded, "KryptoPets: Account is already the value of 'excluded'"); _isExcludedFromMaxTransactionLimit[account] = excluded; emit ExcludeFromMaxTransferChange(account, excluded); } function setWallets(address newLiquidityWallet, address newDevWallet, address newBuyBackWallet, address newGamingWallet) external onlyOwner { if(liquidityWallet != newLiquidityWallet) { require(newLiquidityWallet != address(0), "KryptoPets: The liquidityWallet cannot be 0"); emit WalletChange('liquidityWallet', newLiquidityWallet, liquidityWallet); liquidityWallet = newLiquidityWallet; } if(devWallet != newDevWallet) { require(newDevWallet != address(0), "KryptoPets: The devWallet cannot be 0"); emit WalletChange('devWallet', newDevWallet, devWallet); devWallet = newDevWallet; } if(buyBackWallet != newBuyBackWallet) { require(newBuyBackWallet != address(0), "KryptoPets: The buyBackWallet cannot be 0"); emit WalletChange('buyBackWallet', newBuyBackWallet, buyBackWallet); buyBackWallet = newBuyBackWallet; } if(gamingWallet != newGamingWallet) { require(newGamingWallet != address(0), "KryptoPets: The gamingWallet cannot be 0"); emit WalletChange('gamingWallet', newGamingWallet, gamingWallet); gamingWallet = newGamingWallet; } } // Base Fees function setBaseFeesOnBuy(uint256 _liquidityFeeOnBuy, uint256 _devFeeOnBuy, uint256 _buyBackFeeOnBuy, uint256 _gamingFeeOnBuy, uint256 _holdersFeeOnBuy) external onlyOwner { _setCustomBuyTaxPeriod(_base, _liquidityFeeOnBuy, _devFeeOnBuy, _buyBackFeeOnBuy, _gamingFeeOnBuy, _holdersFeeOnBuy); emit FeeChange('baseFees-Buy', _liquidityFeeOnBuy, _devFeeOnBuy, _buyBackFeeOnBuy, _gamingFeeOnBuy, _holdersFeeOnBuy); } function setBaseFeesOnSell(uint256 _liquidityFeeOnSell, uint256 _devFeeOnSell, uint256 _buyBackFeeOnSell, uint256 _gamingFeeOnSell, uint256 _holdersFeeOnSell) external onlyOwner { _setCustomSellTaxPeriod(_base, _liquidityFeeOnSell, _devFeeOnSell, _buyBackFeeOnSell, _gamingFeeOnSell, _holdersFeeOnSell); emit FeeChange('baseFees-Sell', _liquidityFeeOnSell, _devFeeOnSell, _buyBackFeeOnSell, _gamingFeeOnSell, _holdersFeeOnSell); } function setUniswapRouter(address newAddress) external onlyOwner { require(newAddress != address(uniswapV2Router), "KryptoPets: The router already has that address"); emit UniswapV2RouterChange(newAddress, address(uniswapV2Router)); uniswapV2Router = IRouter(newAddress); } function setMinimumTokensBeforeSwap(uint256 newValue) external onlyOwner { require(newValue != minimumTokensBeforeSwap, "KryptoPets: Cannot update minimumTokensBeforeSwap to same value"); emit MinTokenAmountBeforeSwapChange(newValue, minimumTokensBeforeSwap); minimumTokensBeforeSwap = newValue; } function setFeeOnSelectedWalletTransfers(address account, bool value) external onlyOwner { require(_feeOnSelectedWalletTransfers[account] != value, "KryptoPets: The selected wallet is already set to the value "); _feeOnSelectedWalletTransfers[account] = value; emit FeeOnSelectedWalletTransfersChange(account, value); } function claim() external { dividendTracker.processAccount(payable(msg.sender), false); } function claimETHOverflow() external onlyOwner { uint256 amount = address(this).balance; (bool success,) = address(owner()).call{value : amount}(""); if (success){ emit ClaimETHOverflow(amount); } } // Getters function getTotalDividendsDistributed() external view returns (uint256) { return dividendTracker.totalDividendsDistributed(); } function getNumberOfDividendTokenHolders() external view returns(uint256) { return dividendTracker.getNumberOfTokenHolders(); } function getBaseBuyFees() external view returns (uint256, uint256, uint256, uint256, uint256){ return (_base.liquidityFeeOnBuy, _base.devFeeOnBuy, _base.buyBackFeeOnBuy, _base.gamingFeeOnBuy, _base.holdersFeeOnBuy); } function getBaseSellFees() external view returns (uint256, uint256, uint256, uint256, uint256){ return (_base.liquidityFeeOnSell, _base.devFeeOnSell, _base.buyBackFeeOnSell, _base.gamingFeeOnSell, _base.holdersFeeOnSell); } // Main function _transfer( address from, address to, uint256 amount ) internal override { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); if(amount == 0) { super._transfer(from, to, 0); return; } bool isBuyFromLp = automatedMarketMakerPairs[from]; bool isSelltoLp = automatedMarketMakerPairs[to]; if(!_isAllowedToTradeWhenDisabled[from] && !_isAllowedToTradeWhenDisabled[to]) { require(isTradingEnabled, "KryptoPets: Trading is currently disabled."); if (!_isExcludedFromMaxTransactionLimit[to] && !_isExcludedFromMaxTransactionLimit[from]) { require(amount <= maxTxAmount, "KryptoPets: Transfer amount exceeds the maxTxAmount."); } if (!_isExcludedFromMaxWalletLimit[to]) { require((balanceOf(to) + amount) <= maxWalletAmount, "KryptoPets: Expected wallet amount exceeds the maxWalletAmount."); } } _adjustTaxes(isBuyFromLp, isSelltoLp, from, to); bool canSwap = balanceOf(address(this)) >= minimumTokensBeforeSwap; if ( isTradingEnabled && canSwap && !_swapping && _totalFee > 0 && automatedMarketMakerPairs[to] ) { _swapping = true; _swapAndLiquify(); _swapping = false; } bool takeFee = !_swapping && isTradingEnabled; if(_isExcludedFromFee[from] || _isExcludedFromFee[to]){ takeFee = false; } if (takeFee && _totalFee > 0) { uint256 fee = amount * _totalFee / 10000; amount = amount - fee; super._transfer(from, address(this), fee); } super._transfer(from, to, amount); try dividendTracker.setBalance(payable(from), balanceOf(from)) {} catch {} try dividendTracker.setBalance(payable(to), balanceOf(to)) {} catch {} } function _adjustTaxes(bool isBuyFromLp, bool isSelltoLp, address from, address to) private { _liquidityFee = 0; _devFee = 0; _buyBackFee = 0; _gamingFee = 0; _holdersFee = 0; if (isBuyFromLp) { if ((block.number - _launchBlockNumber) <= 5) { _liquidityFee = 100; } else { _liquidityFee = _base.liquidityFeeOnBuy; _devFee = _base.devFeeOnBuy; _buyBackFee = _base.buyBackFeeOnBuy; _gamingFee = _base.gamingFeeOnBuy; _holdersFee = _base.holdersFeeOnBuy; } } if (isSelltoLp) { _liquidityFee = _base.liquidityFeeOnSell; _devFee = _base.devFeeOnSell; _buyBackFee = _base.buyBackFeeOnSell; _gamingFee = _base.gamingFeeOnSell; _holdersFee = _base.holdersFeeOnSell; } if (!isSelltoLp && !isBuyFromLp && (_feeOnSelectedWalletTransfers[from] || _feeOnSelectedWalletTransfers[to])) { _liquidityFee = _base.liquidityFeeOnSell; _devFee = _base.devFeeOnSell; _buyBackFee = _base.buyBackFeeOnSell; _gamingFee = _base.gamingFeeOnSell; _holdersFee = _base.holdersFeeOnSell; } _totalFee = _liquidityFee + _devFee + _buyBackFee + _gamingFee + _holdersFee; emit FeesApplied(_liquidityFee, _devFee, _buyBackFee, _gamingFee, _holdersFee, _totalFee); } function _setCustomSellTaxPeriod(CustomTaxPeriod storage map, uint256 _liquidityFeeOnSell, uint256 _devFeeOnSell, uint256 _buyBackFeeOnSell, uint256 _gamingFeeOnSell, uint256 _holdersFeeOnSell ) private { if (map.liquidityFeeOnSell != _liquidityFeeOnSell) { emit CustomTaxPeriodChange(_liquidityFeeOnSell, map.liquidityFeeOnSell, 'liquidityFeeOnSell', map.periodName); map.liquidityFeeOnSell = _liquidityFeeOnSell; } if (map.devFeeOnSell != _devFeeOnSell) { emit CustomTaxPeriodChange(_devFeeOnSell, map.devFeeOnSell, 'devFeeOnSell', map.periodName); map.devFeeOnSell = _devFeeOnSell; } if (map.buyBackFeeOnSell != _buyBackFeeOnSell) { emit CustomTaxPeriodChange(_buyBackFeeOnSell, map.buyBackFeeOnSell, 'buyBackFeeOnSell', map.periodName); map.buyBackFeeOnSell = _buyBackFeeOnSell; } if (map.gamingFeeOnSell != _gamingFeeOnSell) { emit CustomTaxPeriodChange(_gamingFeeOnSell, map.gamingFeeOnSell, 'gamingFeeOnSell', map.periodName); map.gamingFeeOnSell = _gamingFeeOnSell; } if (map.holdersFeeOnSell != _holdersFeeOnSell) { emit CustomTaxPeriodChange(_holdersFeeOnSell, map.holdersFeeOnSell, 'holdersFeeOnSell', map.periodName); map.holdersFeeOnSell = _holdersFeeOnSell; } } function _setCustomBuyTaxPeriod(CustomTaxPeriod storage map, uint256 _liquidityFeeOnBuy, uint256 _devFeeOnBuy, uint256 _buyBackFeeOnBuy, uint256 _gamingFeeOnBuy, uint256 _holdersFeeOnBuy ) private { if (map.liquidityFeeOnBuy != _liquidityFeeOnBuy) { emit CustomTaxPeriodChange(_liquidityFeeOnBuy, map.liquidityFeeOnBuy, 'liquidityFeeOnBuy', map.periodName); map.liquidityFeeOnBuy = _liquidityFeeOnBuy; } if (map.devFeeOnBuy != _devFeeOnBuy) { emit CustomTaxPeriodChange(_devFeeOnBuy, map.devFeeOnBuy, 'devFeeOnBuy', map.periodName); map.devFeeOnBuy = _devFeeOnBuy; } if (map.buyBackFeeOnBuy != _buyBackFeeOnBuy) { emit CustomTaxPeriodChange(_buyBackFeeOnBuy, map.buyBackFeeOnBuy, 'buyBackFeeOnBuy', map.periodName); map.buyBackFeeOnBuy = _buyBackFeeOnBuy; } if (map.gamingFeeOnBuy != _gamingFeeOnBuy) { emit CustomTaxPeriodChange(_gamingFeeOnBuy, map.gamingFeeOnBuy, 'gamingFeeOnBuy', map.periodName); map.gamingFeeOnBuy = _gamingFeeOnBuy; } if (map.holdersFeeOnBuy != _holdersFeeOnBuy) { emit CustomTaxPeriodChange(_holdersFeeOnBuy, map.holdersFeeOnBuy, 'holdersFeeOnBuy', map.periodName); map.holdersFeeOnBuy = _holdersFeeOnBuy; } } function _swapAndLiquify() private { uint256 contractBalance = balanceOf(address(this)); uint256 initialETHBalance = address(this).balance; uint256 totalFeePrior = _totalFee; uint256 amountToLiquify = contractBalance * _liquidityFee / _totalFee / 2; uint256 amountForHolders = contractBalance * _holdersFee / _totalFee; uint256 amountToSwap = contractBalance - amountToLiquify - amountForHolders; _swapTokensForETH(amountToSwap); uint256 ETHBalanceAfterSwap = address(this).balance - initialETHBalance; uint256 totalETHFee = _totalFee - (_liquidityFee / 2) - _holdersFee; uint256 amountETHLiquidity = ETHBalanceAfterSwap * _liquidityFee / totalETHFee / 2; uint256 amountETHDev = ETHBalanceAfterSwap * _devFee / totalETHFee; uint256 amountETHBuyBack = ETHBalanceAfterSwap * _buyBackFee / totalETHFee; uint256 amountETHGaming = ETHBalanceAfterSwap - (amountETHLiquidity + amountETHDev + amountETHBuyBack); payable(devWallet).transfer(amountETHDev); payable(buyBackWallet).transfer(amountETHBuyBack); payable(gamingWallet).transfer(amountETHGaming); if (amountToLiquify > 0) { _addLiquidity(amountToLiquify, amountETHLiquidity); emit SwapAndLiquify(amountToSwap, amountETHLiquidity, amountToLiquify); } (bool success) = IERC20(address(this)).transfer(address(dividendTracker), amountForHolders); if(success) { dividendTracker.distributeDividendsUsingAmount(amountForHolders); emit DividendsSent(amountForHolders); } _totalFee = totalFeePrior; } 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 liquidityWallet, block.timestamp ); } } contract KryptoPetsDividendTracker is DividendPayingToken { using SafeMath for uint256; using SafeMathInt for int256; using IterableMapping for IterableMapping.Map; IterableMapping.Map private tokenHoldersMap; mapping (address => bool) public excludedFromDividends; mapping (address => uint256) public lastClaimTimes; uint256 public minimumTokenBalanceForDividends; event ExcludeFromDividends(address indexed account); event Claim(address indexed account, uint256 amount, bool indexed automatic); constructor() DividendPayingToken("KryptoPets_Dividend_Tracker", "KryptoPets_Dividend_Tracker") { minimumTokenBalanceForDividends = 0 * (10**18); } function setRewardToken(address token) external onlyOwner { _setRewardToken(token); } function _transfer(address, address, uint256) internal pure override { require(false, "KryptoPets_Dividend_Tracker: No transfers allowed"); } function excludeFromDividends(address account) external onlyOwner { require(!excludedFromDividends[account]); excludedFromDividends[account] = true; _setBalance(account, 0); tokenHoldersMap.remove(account); emit ExcludeFromDividends(account); } function setTokenBalanceForDividends(uint256 newValue) external onlyOwner { require(minimumTokenBalanceForDividends != newValue, "KryptoPets_Dividend_Tracker: minimumTokenBalanceForDividends already the value of 'newValue'."); minimumTokenBalanceForDividends = newValue; } function getNumberOfTokenHolders() external view returns(uint256) { return tokenHoldersMap.keys.length; } function setBalance(address payable account, uint256 newBalance) external onlyOwner { if(excludedFromDividends[account]) { return; } if(newBalance >= minimumTokenBalanceForDividends) { _setBalance(account, newBalance); tokenHoldersMap.set(account, newBalance); } else { _setBalance(account, 0); tokenHoldersMap.remove(account); } processAccount(account, true); } function processAccount(address payable account, bool automatic) public onlyOwner returns (bool) { uint256 amount = _withdrawDividendOfUser(account); if(amount > 0) { lastClaimTimes[account] = block.timestamp; emit Claim(account, amount, automatic); return true; } return false; } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
5515:1331:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5801:165;;;;;;:::i;:::-;;:::i;:::-;;;624:25:1;;;612:2;597:18;5801:165:0;;;;;;;;6448:395;;;;;;;;;;-1:-1:-1;6448:395:0;;;;;:::i;:::-;;:::i;:::-;;5694:102;;;;;;:::i;:::-;-1:-1:-1;;;;;5776:15:0;5758:4;5776:15;;;:10;;;;;:15;;;;;;;5694:102;6185:258;;;;;;;;;;-1:-1:-1;6185:258:0;;;;;:::i;:::-;;:::i;5971:114::-;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1644:32:1;;;1626:51;;1614:2;1599:18;5971:114:0;1472:211:1;6090:90:0;;;;;;:::i;:::-;6160:15;;6090:90;5801:165;-1:-1:-1;;;;;5889:17:0;;5875:3;5889:17;;;:12;;;:17;;;;;;;;5885:44;;-1:-1:-1;;;5914:9:0;;5885:44;-1:-1:-1;;;;;;5944:16:0;;;;;;:11;;;:16;;;;;;5801:165;;;;;:::o;6448:395::-;-1:-1:-1;;;;;6511:17:0;;;;;;:12;;;:17;;;;;;;;6506:42;;6448:395;;:::o;6506:42::-;-1:-1:-1;;;;;6561:17:0;;;;;;:12;;;:17;;;;;;;;6554:24;;-1:-1:-1;;6554:24:0;;;;6590:10;;;:15;;;;;6583:22;;;6625:11;;;:16;;;;;;6663:15;;6625:16;;6561:17;6663:19;;;:::i;:::-;6646:36;;6687:15;6705:3;:8;;6714:9;6705:19;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;6705:19:0;;;6731:20;;;:11;;;:20;;;;;;;:28;;;6771:16;;;;;;;6764:23;;;;6794:15;;6705:19;;-1:-1:-1;6705:19:0;;6731:3;;6754:5;;6794:15;;;;;;:::i;:::-;;;;;;;;;;:25;;-1:-1:-1;;;;;;6794:25:0;-1:-1:-1;;;;;6794:25:0;;;;;;;;;;6824:14;;;;;;;;;:::i;:::-;;;;;;;;;;-1:-1:-1;;6824:14:0;;;;;-1:-1:-1;;;;;;6824:14:0;;;;;;-1:-1:-1;;;;;6448:395:0:o;6185:258::-;-1:-1:-1;;;;;6254:17:0;;;;;;:12;;;:17;;;;;;;;6250:189;;;-1:-1:-1;;;;;6279:15:0;;;;;;:10;;;:15;;;;;:21;;;6185:258;;;:::o;6250:189::-;-1:-1:-1;;;;;6318:17:0;;;;;;:12;;;:17;;;;;;;;:24;;-1:-1:-1;;6318:24:0;6338:4;6318:24;;;;;;6348:10;;;:15;;;;;:21;;;6394:15;;6375:11;;;:16;;;;;:34;;;6415:18;;;;;;;;;;;;-1:-1:-1;;;;;;6415:18:0;;;;;;6185:258;;;:::o;5971:114::-;6044:7;6065:3;:8;;6074:5;6065:15;;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;;;;6065:15:0;;5971:114;-1:-1:-1;;;5971:114:0:o;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:275::-;281:6;289;342:2;330:9;321:7;317:23;313:32;310:52;;;358:1;355;348:12;310:52;394:9;381:23;371:33;;423:38;457:2;446:9;442:18;423:38;:::i;:::-;413:48;;192:275;;;;;:::o;850:343::-;948:6;956;964;1017:2;1005:9;996:7;992:23;988:32;985:52;;;1033:1;1030;1023:12;985:52;1069:9;1056:23;1046:33;;1098:38;1132:2;1121:9;1117:18;1098:38;:::i;:::-;1088:48;;1183:2;1172:9;1168:18;1155:32;1145:42;;850:343;;;;;:::o;1198:269::-;1287:6;1295;1348:2;1336:9;1327:7;1323:23;1319:32;1316:52;;;1364:1;1361;1354:12;1316:52;-1:-1:-1;;1387:23:1;;;1457:2;1442:18;;;1429:32;;-1:-1:-1;1198:269:1:o;1688:201::-;1768:6;1821:2;1809:9;1800:7;1796:23;1792:32;1789:52;;;1837:1;1834;1827:12;1789:52;-1:-1:-1;1860:23:1;;1688:201;-1:-1:-1;1688:201:1:o;1894:222::-;1934:4;1962:1;1959;1956:8;1953:131;;;2006:10;2001:3;1997:20;1994:1;1987:31;2041:4;2038:1;2031:15;2069:4;2066:1;2059:15;1953:131;-1:-1:-1;2101:9:1;;1894:222::o;2121:127::-;2182:10;2177:3;2173:20;2170:1;2163:31;2213:4;2210:1;2203:15;2237:4;2234:1;2227:15;2253:127;2314:10;2309:3;2305:20;2302:1;2295:31;2345:4;2342:1;2335:15;2369:4;2366:1;2359:15
Swarm Source
ipfs://95611bfe3c7d1c4ff331889ebb4e0fb5b1887d55bb12fe0a4f048f3f8db6d6c5
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 30 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.