源码来源
/tmimehi/dividendcontract/blob/main/dividendcontract.sol
部署图文教程
/tmimehi/dividendcontract
开源参数：
COMPILER: v0.8.7+commit.e28d00a7.jsEnable optimization: 开启并使用默认值200Other Settings: default evmVersion, MIT license
附代码
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0;abstract contract Context {function _msgSender() internal view virtual returns (address) {return msg.sender;}function _msgData() internal view virtual returns (bytes calldata) {return msg.data;}}abstract contract Ownable is Context {address private _owner;address private _previousOwner;uint256 private _lockTime;event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);constructor() {_transferOwnership(_msgSender());}function owner() public view virtual returns (address) {return _owner;}modifier onlyOwner() {require(owner() == _msgSender(), "Ownable: caller is not the owner");_;}function renounceOwnership() public virtual onlyOwner {_transferOwnership(address(0));}function transferOwnership(address newOwner) public virtual onlyOwner {require(newOwner != address(0), "Ownable: new owner is the zero address");_transferOwnership(newOwner);}function getTime() public view returns (uint256) {return block.timestamp;}function lock(uint256 time) public virtual onlyOwner {_previousOwner = _owner;_owner = address(0);_lockTime = block.timestamp + time;emit OwnershipTransferred(_owner, address(0));}function _transferOwnership(address newOwner) internal virtual {address oldOwner = _owner;_owner = newOwner;emit OwnershipTransferred(oldOwner, newOwner);}}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 IERC20Metadata is IERC20 {function name() external view returns (string memory);function symbol() external view returns (string memory);function decimals() external view returns (uint8);}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: /OpenZeppelin/openzeppelin-contracts/pull/522if (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 holdreturn 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);/*** @dev Multiplies two int256 variables and fails on overflow.*/function mul(int256 a, int256 b) internal pure returns (int256) {int256 c = a * b;// Detect overflow when multiplying MIN_INT256 with -1require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256));require((b == 0) || (c / b == a));return c;}/*** @dev Division of two int256 variables and fails on overflow.*/function div(int256 a, int256 b) internal pure returns (int256) {// Prevent overflow when dividing MIN_INT256 by -1require(b != -1 || a != MIN_INT256);// Solidity already throws when dividing by 0.return a / b;}/*** @dev Subtracts two int256 variables and fails on overflow.*/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;}/*** @dev Adds two int256 variables and fails on overflow.*/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;}/*** @dev Converts to absolute value, and fails on overflow.*/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 Clones {/*** @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.** This function uses the create opcode, which should never revert.*/function clone(address implementation) internal returns (address instance) {assembly {let ptr := mload(0x40)mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)mstore(add(ptr, 0x14), shl(0x60, implementation))mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)instance := create(0, ptr, 0x37)}require(instance != address(0), "ERC1167: create failed");}/*** @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.** This function uses the create2 opcode and a `salt` to deterministically deploy* the clone. Using the same `implementation` and `salt` multiple time will revert, since* the clones cannot be deployed twice at the same address.*/function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {assembly {let ptr := mload(0x40)mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)mstore(add(ptr, 0x14), shl(0x60, implementation))mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)instance := create2(0, ptr, 0x37, salt)}require(instance != address(0), "ERC1167: create2 failed");}/*** @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.*/function predictDeterministicAddress(address implementation,bytes32 salt,address deployer) internal pure returns (address predicted) {assembly {let ptr := mload(0x40)mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)mstore(add(ptr, 0x14), shl(0x60, implementation))mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)mstore(add(ptr, 0x38), shl(0x60, deployer))mstore(add(ptr, 0x4c), salt)mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))predicted := keccak256(add(ptr, 0x37), 0x55)}}/*** @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.*/function predictDeterministicAddress(address implementation, bytes32 salt)internalviewreturns (address predicted){return predictDeterministicAddress(implementation, salt, address(this));}}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;/*** @dev Sets the values for {name} and {symbol}.** The default value of {decimals} is 18. To select a different value for* {decimals} you should overload it.** All two of these values are immutable: they can only be set once during* construction.*/constructor(string memory name_, string memory symbol_) {_name = name_;_symbol = symbol_;}/*** @dev Returns the name of the token.*/function name() public view virtual override returns (string memory) {return _name;}/*** @dev Returns the symbol of the token, usually a shorter version of the* name.*/function symbol() public view virtual override returns (string memory) {return _symbol;}/*** @dev Returns the number of decimals used to get its user representation.* For example, if `decimals` equals `2`, a balance of `505` tokens should* be displayed to a user as `5,05` (`505 / 10 ** 2`).** Tokens usually opt for a value of 18, imitating the relationship between* Ether and Wei. This is the value {ERC20} uses, unless this function is* overridden;** NOTE: This information is only used for _display_ purposes: it in* no way affects any of the arithmetic of the contract, including* {IERC20-balanceOf} and {IERC20-transfer}.*/function decimals() public view virtual override returns (uint8) {return 18;}/*** @dev See {IERC20-totalSupply}.*/function totalSupply() public view virtual override returns (uint256) {return _totalSupply;}/*** @dev See {IERC20-balanceOf}.*/function balanceOf(address account) public view virtual override returns (uint256) {return _balances[account];}/*** @dev See {IERC20-transfer}.** Requirements:** - `recipient` cannot be the zero address.* - the caller must have a balance of at least `amount`.*/function transfer(address recipient, uint256 amount) public virtual override returns (bool) {_transfer(_msgSender(), recipient, amount);return true;}/*** @dev See {IERC20-allowance}.*/function allowance(address owner, address spender) public view virtual override returns (uint256) {return _allowances[owner][spender];}/*** @dev See {IERC20-approve}.** Requirements:** - `spender` cannot be the zero address.*/function approve(address spender, uint256 amount) public virtual override returns (bool) {_approve(_msgSender(), spender, amount);return true;}/*** @dev See {IERC20-transferFrom}.** Emits an {Approval} event indicating the updated allowance. This is not* required by the EIP. See the note at the beginning of {ERC20}.** Requirements:** - `sender` and `recipient` cannot be the zero address.* - `sender` must have a balance of at least `amount`.* - the caller must have allowance for ``sender``'s tokens of at least* `amount`.*/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;}/*** @dev Atomically increases the allowance granted to `spender` by the caller.** This is an alternative to {approve} that can be used as a mitigation for* problems described in {IERC20-approve}.** Emits an {Approval} event indicating the updated allowance.** Requirements:** - `spender` cannot be the zero address.*/function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {_approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));return true;}/*** @dev Atomically decreases the allowance granted to `spender` by the caller.** This is an alternative to {approve} that can be used as a mitigation for* problems described in {IERC20-approve}.** Emits an {Approval} event indicating the updated allowance.** Requirements:** - `spender` cannot be the zero address.* - `spender` must have allowance for the caller of at least* `subtractedValue`.*/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;}/*** @dev Moves tokens `amount` from `sender` to `recipient`.** This is internal function is equivalent to {transfer}, and can be used to* e.g. implement automatic token fees, slashing mechanisms, etc.** Emits a {Transfer} event.** Requirements:** - `sender` cannot be the zero address.* - `recipient` cannot be the zero address.* - `sender` must have a balance of at least `amount`.*/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);}/** @dev Creates `amount` tokens and assigns them to `account`, increasing* the total supply.** Emits a {Transfer} event with `from` set to the zero address.** Requirements:** - `account` cannot be the zero address.*/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);}/*** @dev Destroys `amount` tokens from `account`, reducing the* total supply.** Emits a {Transfer} event with `to` set to the zero address.** Requirements:** - `account` cannot be the zero address.* - `account` must have at least `amount` tokens.*/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);}/*** @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.** This internal function is equivalent to `approve`, and can be used to* e.g. set automatic allowances for certain subsystems, etc.** Emits an {Approval} event.** Requirements:** - `owner` cannot be the zero address.* - `spender` cannot be the zero address.*/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);}/*** @dev Hook that is called before any transfer of tokens. This includes* minting and burning.** Calling conditions:** - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens* will be to transferred to `to`.* - when `from` is zero, `amount` tokens will be minted for `to`.* - when `to` is zero, `amount` of ``from``'s tokens will be burned.* - `from` and `to` are never both zero.** To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].*/function _beforeTokenTransfer(address from,address to,uint256 amount) internal virtual {}}interface TokenDividendTracker {function initialize(address rewardToken_,uint256 minimumTokenBalanceForDividends_) external payable;function getKey() external view returns (uint256);function setKey(uint256 key_) external;function owner() external view returns (address);function excludeFromDividends(address account) external;function setMinimumTokenBalanceForDividends(uint256 val) external;function updateClaimWait(uint256 newClaimWait) external;function claimWait() external view returns (uint256);function totalDividendsDistributed() external view returns (uint256);function withdrawableDividendOf(address account) external view returns(uint256);function balanceOf(address account) external view returns (uint256);function getAccount(address _account) external view returns (address account,int256 index,int256 iterationsUntilProcessed,uint256 withdrawableDividends,uint256 totalDividends,uint256 lastClaimTime,uint256 nextClaimTime,uint256 secondsUntilAutoClaimAvailable);function getAccountAtIndex(uint256 index) external view returns (address,int256,int256,uint256,uint256,uint256,uint256,uint256);function process(uint256 gas) external returns (uint256, uint256, uint256);function processAccount(address payable account, bool automatic) external returns (bool);function getLastProcessedIndex() external view returns(uint256);function getNumberOfTokenHolders() external view returns(uint256);function setBalance(address payable account, uint256 newBalance) external;function distributeCAKEDividends(uint256 amount) external;function isExcludedFromDividends(address account) external view returns (bool);}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)externalpayablereturns (uint[] memory amounts);function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)externalreturns (uint[] memory amounts);function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)externalreturns (uint[] memory amounts);function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)externalpayablereturns (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;}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;}contract dividendcontract is ERC20, Ownable {using SafeMath for uint256;IUniswapV2Router02 public uniswapV2Router;address public uniswapV2Pair;bool private swapping;TokenDividendTracker public dividendTracker;address public rewardToken;uint256 public swapTokensAtAmount;uint256 public buyTokenRewardsFee;uint256 public sellTokenRewardsFee;uint256 public buyLiquidityFee;uint256 public sellLiquidityFee;uint256 public buyMarketingFee;uint256 public sellMarketingFee;uint256 public buyDeadFee;uint256 public sellDeadFee;uint256 public AmountLiquidityFee;uint256 public AmountTokenRewardsFee;uint256 public AmountMarketingFee;address public _marketingWalletAddress;address public deadWallet = 0x000000000000000000000000000000000000dEaD;mapping(address => bool) public _islcklisted;uint256 public gasForProcessing;bool public swapAndLiquifyBACKLBd = true;// exlcude from fees and max transaction amountmapping (address => bool) private _isExcludedFromFees;// store addresses that a automatic market maker pairs. Any transfer *to* these addresses// could be subject to a maximum transfer amountmapping (address => bool) public automatedMarketMakerPairs;event UpdateDividendTracker(address indexed newAddress, address indexed oldAddress);event UpdateUniswapV2Router(address indexed newAddress, address indexed oldAddress);event ExcludeFromFees(address indexed account, bool isExcluded);event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);event LiquidityWalletUpdated(address indexed newLiquidityWallet, address indexed oldLiquidityWallet);event GasForProcessingUpdated(uint256 indexed newValue, uint256 indexed oldValue);event SwapAndLiquify(uint256 tokensSwapped,uint256 ethReceived,uint256 tokensIntoLiqudity);event SendDividends(uint256 tokensSwapped,uint256 amount);event ProcessedDividendTracker(uint256 iterations,uint256 claims,uint256 lastProcessedIndex,bool indexed automatic,uint256 gas,address indexed processor);constructor(string memory name_,string memory symbol_,uint256 totalSupply_,address rewardAddr_,address marketingWalletAddr_,uint256[4] memory buyFeeSetting_, uint256[4] memory sellFeeSetting_,uint256 tokenBalanceForReward_) payable ERC20(name_, symbol_) {rewardToken = rewardAddr_;_marketingWalletAddress = marketingWalletAddr_;buyTokenRewardsFee = buyFeeSetting_[0];buyLiquidityFee = buyFeeSetting_[1];buyMarketingFee = buyFeeSetting_[2];buyDeadFee = buyFeeSetting_[3];sellTokenRewardsFee = sellFeeSetting_[0];sellLiquidityFee = sellFeeSetting_[1];sellMarketingFee = sellFeeSetting_[2];sellDeadFee = sellFeeSetting_[3];require(buyTokenRewardsFee.add(buyLiquidityFee).add(buyMarketingFee).add(buyDeadFee) <= 25, "Total buy fee is over 25%");require(sellTokenRewardsFee.add(sellLiquidityFee).add(sellMarketingFee).add(sellDeadFee) <= 25, "Total sell fee is over 25%");uint256 totalSupply = totalSupply_ * (10**18);swapTokensAtAmount = totalSupply.mul(2).div(10**6); // 0.002%// use by default 300,000 gas to process auto-claiming dividendsgasForProcessing = 300000;dividendTracker = TokenDividendTracker(payable(Clones.clone(0x75175d140eA2FbB07558180B2c0fc0885d502E03)));dividendTracker.initialize{value: msg.value}(rewardToken,tokenBalanceForReward_);IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x10ED43C718714eb63d5aA57B78B54704E256024E);address _uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());uniswapV2Router = _uniswapV2Router;uniswapV2Pair = _uniswapV2Pair;_setAutomatedMarketMakerPair(_uniswapV2Pair, true);// exclude from receiving dividendsdividendTracker.excludeFromDividends(address(dividendTracker));dividendTracker.excludeFromDividends(address(this));dividendTracker.excludeFromDividends(owner());dividendTracker.excludeFromDividends(deadWallet);dividendTracker.excludeFromDividends(address(_uniswapV2Router));// exclude from paying fees or having max transaction amountexcludeFromFees(owner(), true);excludeFromFees(_marketingWalletAddress, true);excludeFromFees(address(this), true);_mint(owner(), totalSupply);}receive() external payable {}function updateMinimumTokenBalanceForDividends(uint256 val) public onlyOwner {dividendTracker.setMinimumTokenBalanceForDividends(val);}function updateUniswapV2Router(address newAddress) public onlyOwner {require(newAddress != address(uniswapV2Router), "The router already has that address");emit UpdateUniswapV2Router(newAddress, address(uniswapV2Router));uniswapV2Router = IUniswapV2Router02(newAddress);address _uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH());uniswapV2Pair = _uniswapV2Pair;}function excludeFromFees(address account, bool excluded) public onlyOwner {if(_isExcludedFromFees[account] != excluded){_isExcludedFromFees[account] = excluded;emit ExcludeFromFees(account, excluded);}}function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {for(uint256 i = 0; i < accounts.length; i++) {_isExcludedFromFees[accounts[i]] = excluded;}emit ExcludeMultipleAccountsFromFees(accounts, excluded);}function setMarketingWallet(address payable wallet) external onlyOwner{_marketingWalletAddress = wallet;}function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {require(pair != uniswapV2Pair, "The PancakeSwap pair cannot be removed from automatedMarketMakerPairs");_setAutomatedMarketMakerPair(pair, value);}function lcklistAddress(address account, bool value) external onlyOwner{_islcklisted[account] = value;}function _setAutomatedMarketMakerPair(address pair, bool value) private {require(automatedMarketMakerPairs[pair] != value, "Automated market maker pair is already set to that value");automatedMarketMakerPairs[pair] = value;if(value) {dividendTracker.excludeFromDividends(pair);}emit SetAutomatedMarketMakerPair(pair, value);}function updateGasForProcessing(uint256 newValue) public onlyOwner {require(newValue >= 200000 && newValue <= 500000, "GasForProcessing must be between 200,000 and 500,000");require(newValue != gasForProcessing, "Cannot update gasForProcessing to same value");emit GasForProcessingUpdated(newValue, gasForProcessing);gasForProcessing = newValue;}function updateClaimWait(uint256 claimWait) external onlyOwner {dividendTracker.updateClaimWait(claimWait);}function getClaimWait() external view returns(uint256) {return dividendTracker.claimWait();}function getTotalDividendsDistributed() external view returns (uint256) {return dividendTracker.totalDividendsDistributed();}function isExcludedFromFees(address account) public view returns(bool) {return _isExcludedFromFees[account];}function withdrawableDividendOf(address account) public view returns(uint256) {return dividendTracker.withdrawableDividendOf(account);}function dividendTokenBalanceOf(address account) public view returns (uint256) {return dividendTracker.balanceOf(account);}function excludeFromDividends(address account) external onlyOwner{dividendTracker.excludeFromDividends(account);}function isExcludedFromDividends(address account) public view returns (bool) {return dividendTracker.isExcludedFromDividends(account);}function getAccountDividendsInfo(address account)external view returns (address,int256,int256,uint256,uint256,uint256,uint256,uint256) {return dividendTracker.getAccount(account);}function getAccountDividendsInfoAtIndex(uint256 index)external view returns (address,int256,int256,uint256,uint256,uint256,uint256,uint256) {return dividendTracker.getAccountAtIndex(index);}function processDividendTracker(uint256 gas) external {(uint256 iterations, uint256 claims, uint256 lastProcessedIndex) = dividendTracker.process(gas);emit ProcessedDividendTracker(iterations, claims, lastProcessedIndex, false, gas, tx.origin);}function claim() external {dividendTracker.processAccount(payable(msg.sender), false);}function getLastProcessedIndex() external view returns(uint256) {return dividendTracker.getLastProcessedIndex();}function getNumberOfDividendTokenHolders() external view returns(uint256) {return dividendTracker.getNumberOfTokenHolders();}function swapManual() public onlyOwner {uint256 contractTokenBalance = balanceOf(address(this));require(contractTokenBalance > 0 , "token balance zero");swapping = true;if(AmountLiquidityFee > 0) swapAndLiquify(AmountLiquidityFee);if(AmountTokenRewardsFee > 0) swapAndSendDividends(AmountTokenRewardsFee);if(AmountMarketingFee > 0) swapAndSendToFee(AmountMarketingFee);swapping = false;}function setSwapAndLiquifyBACKLBd(bool _BACKLBd) public onlyOwner {swapAndLiquifyBACKLBd = _BACKLBd;}function setSwapTokensAtAmount(uint256 amount) public onlyOwner {swapTokensAtAmount = amount;}function setDeadWallet(address addr) public onlyOwner {deadWallet = addr;}function setBuyLiquidityFee(uint256 amount) public onlyOwner {buyLiquidityFee = amount;}function setSellLiquidityFee(uint256 amount) public onlyOwner {sellLiquidityFee = amount;}function setBuyTokenRewardsFee(uint256 amount) public onlyOwner {buyTokenRewardsFee = amount;}function setSellTokenRewardsFee(uint256 amount) public onlyOwner {sellTokenRewardsFee = amount;}function setBuyMarketingFee(uint256 amount) public onlyOwner {buyMarketingFee = amount;}function setSellMarketingFee(uint256 amount) public onlyOwner {sellMarketingFee = amount;}function setBuyDeadFee(uint256 amount) public onlyOwner {buyDeadFee = amount;}function setSellDeadFee(uint256 amount) public onlyOwner {sellDeadFee = amount;}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");require(!_islcklisted[from] && !_islcklisted[to], 'lcklisted address');if(amount == 0) {super._transfer(from, to, 0);return;}uint256 contractTokenBalance = balanceOf(address(this));bool canSwap = contractTokenBalance >= swapTokensAtAmount;if( canSwap &&!swapping &&!automatedMarketMakerPairs[from] &&from != owner() &&to != owner() &&swapAndLiquifyBACKLBd) {swapping = true;if(AmountMarketingFee > 0) swapAndSendToFee(AmountMarketingFee);if(AmountLiquidityFee > 0) swapAndLiquify(AmountLiquidityFee);if(AmountTokenRewardsFee > 0) swapAndSendDividends(AmountTokenRewardsFee);swapping = false;}bool takeFee = !swapping;// if any account belongs to _isExcludedFromFee account then remove the feeif(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {takeFee = false;}if(takeFee) {uint256 fees;uint256 LFee;uint256 RFee;uint256 MFee;uint256 DFee;if(automatedMarketMakerPairs[from]){LFee = amount.mul(buyLiquidityFee).div(100);AmountLiquidityFee += LFee;RFee = amount.mul(buyTokenRewardsFee).div(100);AmountTokenRewardsFee += RFee;MFee = amount.mul(buyMarketingFee).div(100);AmountMarketingFee += MFee;DFee = amount.mul(buyDeadFee).div(100);fees = LFee.add(RFee).add(MFee).add(DFee);}if(automatedMarketMakerPairs[to]){LFee = amount.mul(sellLiquidityFee).div(100);AmountLiquidityFee += LFee;RFee = amount.mul(sellTokenRewardsFee).div(100);AmountTokenRewardsFee += RFee;MFee = amount.mul(sellMarketingFee).div(100);AmountMarketingFee += MFee;DFee = amount.mul(sellDeadFee).div(100);fees = LFee.add(RFee).add(MFee).add(DFee);}amount = amount.sub(fees);if(DFee > 0) super._transfer(from, deadWallet, DFee);super._transfer(from, address(this), fees.sub(DFee));}super._transfer(from, to, amount);try dividendTracker.setBalance(payable(from), balanceOf(from)) {} catch {}try dividendTracker.setBalance(payable(to), balanceOf(to)) {} catch {}if(!swapping) {uint256 gas = gasForProcessing;try dividendTracker.process(gas) returns (uint256 iterations, uint256 claims, uint256 lastProcessedIndex) {emit ProcessedDividendTracker(iterations, claims, lastProcessedIndex, true, gas, tx.origin);}catch {}}}function swapAndSendToFee(uint256 tokens) private {uint256 initialCAKEBalance = IERC20(rewardToken).balanceOf(address(this));swapTokensForCake(tokens);uint256 newBalance = (IERC20(rewardToken).balanceOf(address(this))).sub(initialCAKEBalance);IERC20(rewardToken).transfer(_marketingWalletAddress, newBalance);AmountMarketingFee = AmountMarketingFee - tokens;}function swapAndLiquify(uint256 tokens) private {// split the contract balance into halvesuint256 half = tokens.div(2);uint256 otherHalf = tokens.sub(half);uint256 initialBalance = address(this).balance;// swap tokens for ETHswapTokensForEth(half); // <- this breaks the ETH -> HATE swap when swap+liquify is triggered// how much ETH did we just swap into?uint256 newBalance = address(this).balance.sub(initialBalance);// add liquidity to uniswapaddLiquidity(otherHalf, newBalance);AmountLiquidityFee = AmountLiquidityFee - tokens;emit SwapAndLiquify(half, newBalance, otherHalf);}function swapTokensForEth(uint256 tokenAmount) private {// generate the uniswap pair path of token -> wethaddress[] memory path = new address[](2);path[0] = address(this);path[1] = uniswapV2Router.WETH();_approve(address(this), address(uniswapV2Router), tokenAmount);// make the swapuniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount,0, // accept any amount of ETHpath,address(this),block.timestamp);}function swapTokensForCake(uint256 tokenAmount) private {address[] memory path = new address[](3);path[0] = address(this);path[1] = uniswapV2Router.WETH();path[2] = rewardToken;_approve(address(this), address(uniswapV2Router), tokenAmount);// make the swapuniswapV2Router.swapExactTokensForTokensSupportingFeeOnTransferTokens(tokenAmount,0,path,address(this),block.timestamp);}function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {// approve token transfer to cover all possible scenarios_approve(address(this), address(uniswapV2Router), tokenAmount);// add the liquidityuniswapV2Router.addLiquidityETH{value: ethAmount}(address(this),tokenAmount,0, // slippage is unavoidable0, // slippage is unavoidableaddress(0),block.timestamp);}function swapAndSendDividends(uint256 tokens) private{swapTokensForCake(tokens);AmountTokenRewardsFee = AmountTokenRewardsFee - tokens;uint256 dividends = IERC20(rewardToken).balanceOf(address(this));bool success = IERC20(rewardToken).transfer(address(dividendTracker), dividends);if (success) {dividendTracker.distributeCAKEDividends(dividends);emit SendDividends(tokens, dividends);}}}
