ERC-20
Overview
Max Total Supply
76,713,257,084,369.49189202 SafeBank_Dividend_Tracker
Holders
225
Market
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract (WITH 9 Decimals)
Balance
3,065,503,619.406692034 SafeBank_Dividend_TrackerValue
$0.00Loading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
This contract contains unverified libraries: IterableMapping
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.
Contract Name:
SafeBankDividendTracker
Compiler Version
v0.7.6+commit.7338295f
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2021-08-14 */ /** *Submitted for verification at Etherscan.io on 2021-07-18 */ /** *Submitted for verification at BscScan.com on 2021-07-17 */ /** //Contract Developed by Snipe.Finance for SafeBTC team $$$$$$\ $$$$$$\ $$$$$$$\ $$\ $$ __$$\ $$ __$$\ $$ __$$\ $$ | $$ / \__|$$$$$$\ $$ / \__$$$$$$\ $$ | $$ |$$$$$$\ $$$$$$$\ $$ | $$\ \$$$$$$\ \____$$\$$$$\ $$ __$$\$$$$$$$\ |\____$$\$$ __$$\$$ | $$ | \____$$\ $$$$$$$ $$ _| $$$$$$$$ $$ __$$\ $$$$$$$ $$ | $$ $$$$$$ / $$\ $$ $$ __$$ $$ | $$ ____$$ | $$ $$ __$$ $$ | $$ $$ _$$< \$$$$$$ \$$$$$$$ $$ | \$$$$$$$\$$$$$$$ \$$$$$$$ $$ | $$ $$ | \$$\ \______/ \_______\__| \_______\_______/ \_______\__| \__\__| \__| */ pragma solidity ^0.7.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); } // File: contracts/Context.sol pragma solidity >=0.6.0 <0.8.0; /* * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with GSN meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } } // File: contracts/IUniswapV2Router01.sol pragma solidity >=0.6.2; interface IUniswapV2Router01 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity); function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); function removeLiquidity( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB); function removeLiquidityETH( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountToken, uint amountETH); function removeLiquidityWithPermit( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountA, uint amountB); function removeLiquidityETHWithPermit( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountToken, uint amountETH); function swapExactTokensForTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut); function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn); function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); } // File: contracts/IUniswapV2Router02.sol pragma solidity >=0.6.2; 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; } // File: contracts/IUniswapV2Factory.sol pragma solidity >=0.5.0; interface IUniswapV2Factory { event PairCreated(address indexed token0, address indexed token1, address pair, uint); function feeTo() external view returns (address); function feeToSetter() external view returns (address); function getPair(address tokenA, address tokenB) external view returns (address pair); function allPairs(uint) external view returns (address pair); function allPairsLength() external view returns (uint); function createPair(address tokenA, address tokenB) external returns (address pair); function setFeeTo(address) external; function setFeeToSetter(address) external; } // File: contracts/IUniswapV2Pair.sol pragma solidity >=0.5.0; 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; } // File: contracts/IterableMapping.sol // pragma solidity ^0.7.6; library IterableMapping { // Iterable mapping from address to uint; 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(); } } // File: contracts/Ownable.sol // pragma solidity ^0.7.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ 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 () { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(owner() == _msgSender(), "Ownable: caller is not the owner"); _; } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = 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"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } // File: contracts/IDividendPayingTokenOptional.sol pragma solidity ^0.7.6; /// @title Dividend-Paying Token Optional Interface /// @author Roger Wu (https://github.com/roger-wu) /// @dev OPTIONAL functions for a dividend-paying token contract. interface IDividendPayingTokenOptional { /// @notice View the amount of dividend in wei that an address can withdraw. /// @param _owner The address of a token holder. /// @return The amount of dividend in wei that `_owner` can withdraw. function withdrawableDividendOf(address _owner) external view returns(uint256); /// @notice View the amount of dividend in wei that an address has withdrawn. /// @param _owner The address of a token holder. /// @return The amount of dividend in wei that `_owner` has withdrawn. function withdrawnDividendOf(address _owner) external view returns(uint256); /// @notice View the amount of dividend in wei that an address has earned in total. /// @dev accumulativeDividendOf(_owner) = withdrawableDividendOf(_owner) + withdrawnDividendOf(_owner) /// @param _owner The address of a token holder. /// @return The amount of dividend in wei that `_owner` has earned in total. function accumulativeDividendOf(address _owner) external view returns(uint256); } // File: contracts/IDividendPayingToken.sol pragma solidity ^0.7.6; /// @title Dividend-Paying Token Interface /// @author Roger Wu (https://github.com/roger-wu) /// @dev An interface for a dividend-paying token contract. interface IDividendPayingToken { /// @notice View the amount of dividend in wei that an address can withdraw. /// @param _owner The address of a token holder. /// @return The amount of dividend in wei that `_owner` can withdraw. function dividendOf(address _owner) external view returns(uint256); /// @notice Distributes ether to token holders as dividends. /// @dev SHOULD distribute the paid ether to token holders as dividends. /// SHOULD NOT directly transfer ether to token holders in this function. /// MUST emit a `DividendsDistributed` event when the amount of distributed ether is greater than 0. function distributeDividends() external payable; /// @notice Withdraws the ether distributed to the sender. /// @dev SHOULD transfer `dividendOf(msg.sender)` wei to `msg.sender`, and `dividendOf(msg.sender)` SHOULD be 0 after the transfer. /// MUST emit a `DividendWithdrawn` event if the amount of ether transferred is greater than 0. function withdrawDividend() external; /// @dev This event MUST emit when ether is distributed to token holders. /// @param from The address which sends ether to this contract. /// @param weiAmount The amount of distributed ether in wei. event DividendsDistributed( address indexed from, uint256 weiAmount ); /// @dev This event MUST emit when an address withdraws their dividend. /// @param to The address which withdraws ether from this contract. /// @param weiAmount The amount of withdrawn ether in wei. event DividendWithdrawn( address indexed to, uint256 weiAmount, address indexed tokenWithdrawn ); } // File: contracts/SafeMathInt.sol pragma solidity ^0.7.6; /** * @title SafeMathInt * @dev Math operations with safety checks that revert on error * @dev SafeMath adapted for int256 * Based on code of https://github.com/RequestNetwork/requestNetwork/blob/master/packages/requestNetworkSmartContracts/contracts/base/math/SafeMathInt.sol */ library SafeMathInt { function mul(int256 a, int256 b) internal pure returns (int256) { // Prevent overflow when multiplying INT256_MIN with -1 // https://github.com/RequestNetwork/requestNetwork/issues/43 require(!(a == - 2**255 && b == -1) && !(b == - 2**255 && a == -1)); int256 c = a * b; require((b == 0) || (c / b == a)); return c; } function div(int256 a, int256 b) internal pure returns (int256) { // Prevent overflow when dividing INT256_MIN by -1 // https://github.com/RequestNetwork/requestNetwork/issues/43 require(!(a == - 2**255 && b == -1) && (b > 0)); return a / b; } function sub(int256 a, int256 b) internal pure returns (int256) { require((b >= 0 && a - b <= a) || (b < 0 && a - b > a)); return a - b; } 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 toUint256Safe(int256 a) internal pure returns (uint256) { require(a >= 0); return uint256(a); } } // File: contracts/SafeMathUint.sol pragma solidity ^0.7.6; /** * @title SafeMathUint * @dev Math operations with safety checks that revert on error */ library SafeMathUint { function toInt256Safe(uint256 a) internal pure returns (int256) { int256 b = int256(a); require(b >= 0); return b; } } // File: contracts/ERC20.sol // pragma solidity ^0.7.0; /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin guidelines: functions revert instead * of returning `false` on failure. This behavior is nonetheless conventional * and does not conflict with the expectations of ERC20 applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20 is Context, IERC20 { 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; uint8 private _decimals; /** * @dev Sets the values for {name} and {symbol}, initializes {decimals} with * a default value of 18. * * To select a different value for {decimals}, use {_setupDecimals}. * * All three of these values are immutable: they can only be set once during * construction. */ constructor (string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; _decimals = 9; } /** * @dev Returns the name of the token. */ function name() public view virtual returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual 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 {_setupDecimals} is * called. * * 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 returns (uint8) { return _decimals; } /** * @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: * * - `to` 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 Sets {decimals} to a value other than the default one of 18. * * WARNING: This function should only be called from the constructor. Most * applications that interact with token contracts will not expect * {decimals} to ever change, and may work incorrectly if it does. */ function _setupDecimals(uint8 decimals_) internal virtual { _decimals = decimals_; } /** * @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 { } } // File: contracts/SafeMath.sol // pragma solidity ^0.7.0; /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } /** * @dev Returns the substraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b > a) return (false, 0); return (true, a - b); } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, 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 (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a / b); } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a % b); } /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath: subtraction overflow"); return a - b; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) return 0; uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @dev Returns the integer division of two unsigned integers, reverting on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "SafeMath: division by zero"); return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "SafeMath: modulo by zero"); return a % b; } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {trySub}. * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); return a - b; } /** * @dev Returns the integer division of two unsigned integers, reverting with custom message on * division by zero. The result is rounded towards zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryDiv}. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting with custom message when dividing by zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryMod}. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); return a % b; } } // File: contracts/SafeBankDividendPayingToken.sol // pragma solidity ^0.7.6; /// @title Dividend-Paying Token /// @author Roger Wu (https://github.com/roger-wu) /// @dev A mintable ERC20 token that allows anyone to pay and distribute ether /// to token holders as dividends and allows token holders to withdraw their dividends. /// Reference: the source code of PoWH3D: https://etherscan.io/address/0xB3775fB83F7D12A36E0475aBdD1FCA35c091efBe#code contract DividendPayingToken is ERC20, IDividendPayingToken, IDividendPayingTokenOptional { using SafeMath for uint256; using SafeMathUint for uint256; using SafeMathInt for int256; // With `magnitude`, we can properly distribute dividends even if the amount of received ether is small. // For more discussion about choosing the value of `magnitude`, // see https://github.com/ethereum/EIPs/issues/1726#issuecomment-472352728 uint256 constant internal magnitude = 2**128; uint256 internal magnifiedDividendPerShare; uint256 internal lastAmount; address public DividendToken = address(0); // About dividendCorrection: // If the token balance of a `_user` is never changed, the dividend of `_user` can be computed with: // `dividendOf(_user) = dividendPerShare * balanceOf(_user)`. // When `balanceOf(_user)` is changed (via minting/burning/transferring tokens), // `dividendOf(_user)` should not be changed, // but the computed value of `dividendPerShare * balanceOf(_user)` is changed. // To keep the `dividendOf(_user)` unchanged, we add a correction term: // `dividendOf(_user) = dividendPerShare * balanceOf(_user) + dividendCorrectionOf(_user)`, // where `dividendCorrectionOf(_user)` is updated whenever `balanceOf(_user)` is changed: // `dividendCorrectionOf(_user) = dividendPerShare * (old balanceOf(_user)) - (new balanceOf(_user))`. // So now `dividendOf(_user)` returns the same value before and after `balanceOf(_user)` is changed. mapping(address => int256) internal magnifiedDividendCorrections; mapping(address => uint256) internal withdrawnDividends; uint256 public totalDividendsDistributed; constructor(string memory _name, string memory _symbol) public ERC20(_name, _symbol) { } receive() external payable { } /// @notice Distributes ether to token holders as dividends. /// @dev It reverts if the total supply of tokens is 0. /// It emits the `DividendsDistributed` event if the amount of received ether is greater than 0. /// About undistributed ether: /// In each distribution, there is a small amount of ether not distributed, /// the magnified amount of which is /// `(msg.value * magnitude) % totalSupply()`. /// With a well-chosen `magnitude`, the amount of undistributed ether /// (de-magnified) in a distribution can be less than 1 wei. /// We can actually keep track of the undistributed ether in a distribution /// and try to distribute it in the next distribution, /// but keeping track of such data on-chain costs much more than /// the saved ether, so we don't do that. function distributeDividends() public override payable { require(totalSupply() > 0); if (msg.value > 0) { magnifiedDividendPerShare = magnifiedDividendPerShare.add( (msg.value).mul(magnitude) / totalSupply() ); emit DividendsDistributed(msg.sender, msg.value); totalDividendsDistributed = totalDividendsDistributed.add(msg.value); } } function distributeTokenDividends(uint256 amount) public { require(totalSupply() > 0); if (amount > 0) { magnifiedDividendPerShare = magnifiedDividendPerShare.add( (amount).mul(magnitude) / totalSupply() ); emit DividendsDistributed(msg.sender, amount); totalDividendsDistributed = totalDividendsDistributed.add(amount); } } /// @notice Withdraws the ether distributed to the sender. /// @dev It emits a `DividendWithdrawn` event if the amount of withdrawn ether is greater than 0. function withdrawDividend() public virtual override { _withdrawDividendOfUser(msg.sender); } /// @notice Withdraws the ether distributed to the sender. /// @dev It emits a `DividendWithdrawn` event if the amount of withdrawn ether is greater than 0. /// modified to support BNB dividend function _withdrawDividendOfUser(address payable user) internal returns (uint256) { uint256 _withdrawableDividend = withdrawableDividendOf(user); if (_withdrawableDividend > 0) { withdrawnDividends[user] = withdrawnDividends[user].add(_withdrawableDividend); bool success = false; if(DividendToken == address(0)){ (bool sent, bytes memory data) = user.call{value: _withdrawableDividend}(""); success = sent; emit DividendWithdrawn(user, _withdrawableDividend, DividendToken); }else{ success = IERC20(DividendToken).transfer(user, _withdrawableDividend); emit DividendWithdrawn(user, _withdrawableDividend, DividendToken); } if(!success) { withdrawnDividends[user] = withdrawnDividends[user].sub(_withdrawableDividend); return 0; } return _withdrawableDividend; } return 0; } /// @notice View the amount of dividend in wei that an address can withdraw. /// @param _owner The address of a token holder. /// @return The amount of dividend in wei that `_owner` can withdraw. function dividendOf(address _owner) public view override returns(uint256) { return withdrawableDividendOf(_owner); } /// @notice View the amount of dividend in wei that an address can withdraw. /// @param _owner The address of a token holder. /// @return The amount of dividend in wei that `_owner` can withdraw. function withdrawableDividendOf(address _owner) public view override returns(uint256) { return accumulativeDividendOf(_owner).sub(withdrawnDividends[_owner]); } /// @notice View the amount of dividend in wei that an address has withdrawn. /// @param _owner The address of a token holder. /// @return The amount of dividend in wei that `_owner` has withdrawn. function withdrawnDividendOf(address _owner) public view override returns(uint256) { return withdrawnDividends[_owner]; } /// @notice View the amount of dividend in wei that an address has earned in total. /// @dev accumulativeDividendOf(_owner) = withdrawableDividendOf(_owner) + withdrawnDividendOf(_owner) /// = (magnifiedDividendPerShare * balanceOf(_owner) + magnifiedDividendCorrections[_owner]) / magnitude /// @param _owner The address of a token holder. /// @return The amount of dividend in wei that `_owner` has earned in total. function accumulativeDividendOf(address _owner) public view override returns(uint256) { return magnifiedDividendPerShare.mul(balanceOf(_owner)).toInt256Safe() .add(magnifiedDividendCorrections[_owner]).toUint256Safe() / magnitude; } /// @dev Internal function that transfer tokens from one address to another. /// Update magnifiedDividendCorrections to keep dividends unchanged. /// @param from The address to transfer from. /// @param to The address to transfer to. /// @param value The amount to be transferred. 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); } /// @dev Internal function that mints tokens to an account. /// Update magnifiedDividendCorrections to keep dividends unchanged. /// @param account The account that will receive the created tokens. /// @param value The amount that will be created. function _mint(address account, uint256 value) internal override { super._mint(account, value); magnifiedDividendCorrections[account] = magnifiedDividendCorrections[account] .sub( (magnifiedDividendPerShare.mul(value)).toInt256Safe() ); } /// @dev Internal function that burns an amount of the token of a given account. /// Update magnifiedDividendCorrections to keep dividends unchanged. /// @param account The account whose tokens will be burnt. /// @param value The amount that will be burnt. 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); } } } // File: contracts/SafeBank.sol // pragma solidity ^0.7.6; contract SafeBank is ERC20, Ownable { using SafeMath for uint256; IUniswapV2Router02 public uniswapV2Router; address public immutable uniswapV2Pair; address public DividendToken = address(0); bool private swapping; SafeBankDividendTracker public dividendTracker; address public burnAddress; uint256 public maxBuyTranscationAmount = 100000000000000 * (10**9); uint256 public maxSellTransactionAmount = 100000000000000 * (10**9); uint256 public swapTokensAtAmount = 5000000 * (10**9); uint256 public _maxWalletToken = 100000000000000 * (10**9); // added address payable public wallet1Address; address payable public wallet2Address; address payable public wallet3Address; address public wallet1TokenAddressForFee; address public wallet2TokenAddressForFee; address public wallet3TokenAddressForFee; uint256 public wallet1Fee; uint256 public wallet2Fee; uint256 public wallet3Fee; uint256 public tokenRewardsFee; uint256 public liquidityFee; uint256 public totalFees; // fee aggiuntiva alla vendita del 20% uint256 public sellFeeIncreaseFactor = 1200; // autoclaim gas to 400k uint256 public gasForProcessing = 400000; address public presaleAddress = address(0); // timestamp for when the token can be traded freely on PanackeSwap uint256 public tradingEnabledTimestamp = 1626624000; // exlcude from fees and max transaction amount mapping (address => bool) private _isExcludedFromFees; mapping (address => bool) public _isExcludedMaxSellTransactionAmount; // addresses that can make transfers before presale is over mapping (address => bool) private canTransferBeforeTradingIsEnabled; // store addresses that a automatic market maker pairs. Any transfer *to* these addresses // could be subject to a maximum transfer amount mapping (address => bool) public automatedMarketMakerPairs; event UpdateDividendTracker(address indexed newAddress, address indexed oldAddress); event UpdateUniswapV2Router(address indexed newAddress, address indexed oldAddress); // added event UpdateDividendToken(address indexed newAddress, address indexed oldAddress); // event ExcludeFromFees(address indexed account, bool isExcluded); event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded); event ExcludedMaxSellTransactionAmount(address indexed account, bool isExcluded); event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value); event BurnWalletUpdated(address indexed newBurnWallet, address indexed oldBurnWallet); event GasForProcessingUpdated(uint256 indexed newValue, uint256 indexed oldValue); event FixedSaleBuy(address indexed account, uint256 indexed amount, bool indexed earlyParticipant, uint256 numberOfBuyers); 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() public ERC20("SafeBank", "sBANK") { uint256 _tokenRewardsFee = 3; uint256 _liquidityFee = 2; uint256 _wallet1Fee = 1; uint256 _wallet2Fee = 2; uint256 _wallet3Fee = 2; tokenRewardsFee = _tokenRewardsFee; liquidityFee = _liquidityFee; wallet1Fee = _wallet1Fee; wallet2Fee = _wallet2Fee; wallet3Fee = _wallet3Fee; totalFees = _tokenRewardsFee.add(_liquidityFee).add(_wallet1Fee).add(_wallet2Fee).add(_wallet3Fee); dividendTracker = new SafeBankDividendTracker(); burnAddress = address(0xdead); IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D); // Create a uniswap pair for this new token address _uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()) .createPair(address(this), _uniswapV2Router.WETH()); uniswapV2Router = _uniswapV2Router; uniswapV2Pair = _uniswapV2Pair; _setAutomatedMarketMakerPair(_uniswapV2Pair, true); // exclude from receiving dividends dividendTracker.excludeFromDividends(address(dividendTracker)); dividendTracker.excludeFromDividends(address(this)); dividendTracker.excludeFromDividends(address(_uniswapV2Router)); dividendTracker.excludeFromDividends(owner()); // exclude from paying fees or having max transaction amount excludeFromFees(burnAddress, true); excludeFromFees(address(this), true); excludeFromFees(owner(), true); // enable owner and fixed-sale wallet to send tokens before presales are over canTransferBeforeTradingIsEnabled[owner()] = true; /* _mint is an internal function in ERC20.sol that is only called here, and CANNOT be called ever again */ _mint(owner(), 100000000000000 * (10**9)); } receive() external payable { } // added function updateTradingEnabledTime (uint256 newTimeInEpoch) external onlyOwner { tradingEnabledTimestamp = newTimeInEpoch; } function updateMinimumBalanceForDividends (uint256 newAmountNoDecimials) external onlyOwner { dividendTracker.updateMinimumBalanceForDividends(newAmountNoDecimials); } function updateSellIncreaseFee (uint256 newFeeWholeNumber) external onlyOwner { sellFeeIncreaseFactor = newFeeWholeNumber; } function updateMaxWalletAmount(uint256 newAmountNoDecimials) external onlyOwner { _maxWalletToken = newAmountNoDecimials * (10**9); } function updateSwapAtAmount(uint256 newAmountNoDecimials) external onlyOwner { swapTokensAtAmount = newAmountNoDecimials * (10**9); } function updateTokenForDividend(address newAddress) external onlyOwner { dividendTracker.updateTokenForDividend(newAddress); DividendToken = newAddress; emit UpdateDividendToken(newAddress, address(DividendToken)); } function updateWallet1Address(address payable newAddress) external onlyOwner { wallet1Address = newAddress; excludeFromFees(wallet1Address, true); dividendTracker.excludeFromDividends(wallet1Address); } function updateWallet2Address(address payable newAddress) external onlyOwner { wallet2Address = newAddress; excludeFromFees(wallet2Address, true); dividendTracker.excludeFromDividends(wallet2Address); } function updateWallet3Address(address payable newAddress) external onlyOwner { wallet3Address = newAddress; excludeFromFees(wallet3Address, true); dividendTracker.excludeFromDividends(wallet3Address); } function updateWallet1TokenFeeAddress(address newAddress) external onlyOwner { wallet1TokenAddressForFee = newAddress; } function updateWallet2TokenFeeAddress(address newAddress) external onlyOwner { wallet2TokenAddressForFee = newAddress; } function updateWallet3TokenFeeAddress(address newAddress) external onlyOwner { wallet3TokenAddressForFee = newAddress; } function updateFees(uint256 _tokenRewardsFee, uint256 _liquidityFee, uint256 _wallet1Fee, uint256 _wallet2Fee, uint256 _wallet3Fee) external onlyOwner { tokenRewardsFee = _tokenRewardsFee; liquidityFee = _liquidityFee; wallet1Fee = _wallet1Fee; wallet2Fee = _wallet2Fee; wallet3Fee = _wallet3Fee; totalFees = tokenRewardsFee.add(liquidityFee).add(wallet1Fee).add(wallet2Fee).add(wallet3Fee); } // function whitelistDxSale(address _presaleAddress, address _routerAddress) external onlyOwner { presaleAddress = _presaleAddress; canTransferBeforeTradingIsEnabled[presaleAddress] = true; dividendTracker.excludeFromDividends(_presaleAddress); excludeFromFees(_presaleAddress, true); canTransferBeforeTradingIsEnabled[_routerAddress] = true; dividendTracker.excludeFromDividends(_routerAddress); excludeFromFees(_routerAddress, true); } function updateDividendTracker(address newAddress) external onlyOwner { require(newAddress != address(dividendTracker), "SafeBank: The dividend tracker already has that address"); SafeBankDividendTracker newDividendTracker = SafeBankDividendTracker(payable(newAddress)); require(newDividendTracker.owner() == address(this), "SafeBank: The new dividend tracker must be owned by the SafeBank token contract"); newDividendTracker.excludeFromDividends(address(newDividendTracker)); newDividendTracker.excludeFromDividends(address(this)); newDividendTracker.excludeFromDividends(address(uniswapV2Router)); emit UpdateDividendTracker(newAddress, address(dividendTracker)); dividendTracker = newDividendTracker; } function updateUniswapV2Router(address newAddress) external onlyOwner { require(newAddress != address(uniswapV2Router), "SafeBank: The router already has that address"); emit UpdateUniswapV2Router(newAddress, address(uniswapV2Router)); uniswapV2Router = IUniswapV2Router02(newAddress); } function excludeFromFees(address account, bool excluded) public onlyOwner { //require(_isExcludedFromFees[account] != excluded, "SafeBank: Account is already the value of 'excluded'"); _isExcludedFromFees[account] = excluded; emit ExcludeFromFees(account, excluded); } function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) external onlyOwner { for(uint256 i = 0; i < accounts.length; i++) { _isExcludedFromFees[accounts[i]] = excluded; } emit ExcludeMultipleAccountsFromFees(accounts, excluded); } function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner { require(pair != uniswapV2Pair, "SafeBank: The PancakeSwap pair cannot be removed from automatedMarketMakerPairs"); _setAutomatedMarketMakerPair(pair, value); } function _setAutomatedMarketMakerPair(address pair, bool value) private { require(automatedMarketMakerPairs[pair] != value, "SafeBank: 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, "SafeBank: gasForProcessing must be between 200,000 and 500,000"); require(newValue != gasForProcessing, "SafeBank: 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 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(msg.sender, false); } function getLastProcessedIndex() external view returns(uint256) { return dividendTracker.getLastProcessedIndex(); } function getNumberOfDividendTokenHolders() external view returns(uint256) { return dividendTracker.getNumberOfTokenHolders(); } function getTradingIsEnabled() public view returns (bool) { return block.timestamp >= tradingEnabledTimestamp; } 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 ( from != owner() && to != owner() && to != address(0) && to != address(0xdead) && to != uniswapV2Pair ) { require( amount <= maxBuyTranscationAmount, "Transfer amount exceeds the maxTxAmount." ); uint256 contractBalanceRecepient = balanceOf(to); require( contractBalanceRecepient + amount <= _maxWalletToken, "Exceeds maximum wallet token amount." ); } bool tradingIsEnabled = getTradingIsEnabled(); // only whitelisted addresses can make transfers after the fixed-sale has started // and before the public presale is over if(!tradingIsEnabled) { require(canTransferBeforeTradingIsEnabled[from], "SafeBank: This account cannot send tokens until trading is enabled"); } if(amount == 0) { super._transfer(from, to, 0); return; } if( !swapping && tradingIsEnabled && automatedMarketMakerPairs[to] && // sells only by detecting transfer to automated market maker pair from != address(uniswapV2Router) && //router -> pair is removing liquidity which shouldn't have max !_isExcludedFromFees[to] //no max for those excluded from fees ) { require(amount <= maxSellTransactionAmount, "Sell transfer amount exceeds the maxSellTransactionAmount."); } uint256 contractTokenBalance = balanceOf(address(this)); bool canSwap = contractTokenBalance >= swapTokensAtAmount; if( tradingIsEnabled && canSwap && !swapping && !automatedMarketMakerPairs[from] && from != burnAddress && to != burnAddress ) { swapping = true; uint256 swapTokens = contractTokenBalance.mul(liquidityFee).div(totalFees); swapAndLiquify(swapTokens); uint256 sellTokens = balanceOf(address(this)); swapAndSendDividends(sellTokens); swapping = false; } bool takeFee = tradingIsEnabled && !swapping; // if any account belongs to _isExcludedFromFee account then remove the fee if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) { takeFee = false; } if(takeFee) { uint256 fees = amount.mul(totalFees).div(100); // if sell, multiply by 1.2 if(automatedMarketMakerPairs[to]) { fees = fees.mul(sellFeeIncreaseFactor).div(100); } amount = amount.sub(fees); super._transfer(from, address(this), fees); } 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 { } } } // made public for testing function swapAndLiquify(uint256 tokens) public { // split the contract balance into halves uint256 half = tokens.div(2); uint256 otherHalf = tokens.sub(half); // capture the contract's current ETH balance. // this is so that we can capture exactly the amount of ETH that the // swap creates, and not make the liquidity event include any ETH that // has been manually sent to the contract uint256 initialBalance = address(this).balance; // swap tokens for ETH swapTokensForEth(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); // calculate the portions of the liquidity to add to wallet1fee uint256 wallet1feeBalance = newBalance.div(totalFees).mul(wallet1Fee); uint256 wallet1feePortion = otherHalf.div(totalFees).mul(wallet1Fee); // calculate the portions of the liquidity to add to wallet2fee uint256 wallet2feeBalance = newBalance.div(totalFees).mul(wallet2Fee); uint256 wallet2feePortion = otherHalf.div(totalFees).mul(wallet2Fee); // calculate the portions of the liquidity to add to wallet3fee uint256 wallet3feeBalance = newBalance.div(totalFees).mul(wallet3Fee); uint256 wallet3feePortion = otherHalf.div(totalFees).mul(wallet3Fee); uint256 walletTotalBalance = wallet1feeBalance + wallet2feeBalance + wallet3feeBalance; uint256 walletTotalPortion = wallet1feePortion + wallet2feePortion + wallet3feePortion; uint256 finalBalance = newBalance.sub(walletTotalBalance); uint256 finalHalf = otherHalf.sub(walletTotalPortion); // added to manage receiving eth or any token 1 if(wallet1TokenAddressForFee != address(0)){ swapEthForTokens(wallet1feeBalance, wallet1TokenAddressForFee, wallet1Address); //_transfer(address(this), burnAddress, wallet1feePortion); //emit Transfer(address(this), burnAddress, wallet1feePortion); }else{ (bool sent, bytes memory data) = wallet1Address.call{value: wallet1feeBalance}(""); if(sent){ //_transfer(address(this), burnAddress, wallet1feePortion); //emit Transfer(address(this), burnAddress, wallet1feePortion); } else { addLiquidity(wallet1feePortion, wallet1feeBalance); } } // added to manage receiving eth or any token 2 if(wallet2TokenAddressForFee != address(0)){ swapEthForTokens(wallet2feeBalance, wallet2TokenAddressForFee, wallet2Address); //_transfer(address(this), burnAddress, wallet2feePortion); //emit Transfer(address(this), burnAddress, wallet2feePortion); }else{ (bool sent, bytes memory data) = wallet2Address.call{value: wallet2feeBalance}(""); if(sent){ //_transfer(address(this), burnAddress, wallet2feePortion); //emit Transfer(address(this), burnAddress, wallet2feePortion); } else { addLiquidity(wallet2feePortion, wallet2feeBalance); } } // added to manage receiving eth or any token 3 if(wallet3TokenAddressForFee != address(0)){ swapEthForTokens(wallet3feeBalance, wallet3TokenAddressForFee, wallet3Address); //_transfer(address(this), burnAddress, wallet3feePortion); //emit Transfer(address(this), burnAddress, wallet3feePortion); }else{ (bool sent, bytes memory data) = wallet3Address.call{value: wallet3feeBalance}(""); if(sent){ //_transfer(address(this), burnAddress, wallet3feePortion); //emit Transfer(address(this), burnAddress, wallet3feePortion); } else { addLiquidity(wallet3feePortion, wallet3feeBalance); } } // add liquidity to uniswap addLiquidity(finalHalf, finalBalance); emit SwapAndLiquify(half, newBalance, otherHalf); } // added in order to sell eth for something else like usdt,busd,etc function swapEthForTokens(uint256 ethAmount, address tokenAddress, address receiver) private { // generate the uniswap pair path of weth -> token address[] memory path = new address[](2); path[0] = uniswapV2Router.WETH(); path[1] = tokenAddress; // make the swap uniswapV2Router.swapExactETHForTokensSupportingFeeOnTransferTokens{value: ethAmount}( 0, // accept any amount of ETH path, receiver, block.timestamp ); } function swapTokensForEth(uint256 tokenAmount) private { // generate the uniswap pair path of token -> weth address[] memory path = new address[](2); path[0] = address(this); path[1] = uniswapV2Router.WETH(); _approve(address(this), address(uniswapV2Router), tokenAmount); // make the swap uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens( tokenAmount, 0, // accept any amount of ETH path, address(this), block.timestamp ); } function swapTokensForTokens(uint256 tokenAmount, address recipient) private { // generate the uniswap pair path of weth -> busd address[] memory path = new address[](3); path[0] = address(this); path[1] = uniswapV2Router.WETH(); path[2] = DividendToken; _approve(address(this), address(uniswapV2Router), tokenAmount); // make the swap uniswapV2Router.swapExactTokensForTokensSupportingFeeOnTransferTokens( tokenAmount, 0, // accept any amount of BUSD path, recipient, block.timestamp ); } function addLiquidity(uint256 tokenAmount, uint256 ethAmount) public { // approve token transfer to cover all possible scenarios _approve(address(this), address(uniswapV2Router), tokenAmount); // add the liquidity uniswapV2Router.addLiquidityETH{value: ethAmount}( address(this), tokenAmount, 0, // slippage is unavoidable 0, // slippage is unavoidable burnAddress, block.timestamp ); } // modified to support BNB dividend function swapAndSendDividends(uint256 tokens) private { address payable diviTracker = address(dividendTracker); bool success = false; uint256 dividends; if(DividendToken != address(0)){ swapTokensForTokens(tokens, address(this)); dividends = IERC20(DividendToken).balanceOf(address(this)); success = IERC20(DividendToken).transfer(address(dividendTracker), dividends); }else{ uint256 initialBalance = address(this).balance; swapTokensForEth(tokens); uint256 newBalance = address(this).balance.sub(initialBalance); dividends = newBalance; (bool sent, bytes memory data) = diviTracker.call{value: newBalance}(""); success = sent; } if (success) { dividendTracker.distributeTokenDividends(dividends); emit SendDividends(tokens, dividends); } } } contract SafeBankDividendTracker is DividendPayingToken, Ownable { using SafeMath for uint256; using SafeMathInt for int256; using IterableMapping for IterableMapping.Map; IterableMapping.Map private tokenHoldersMap; uint256 public lastProcessedIndex; mapping (address => bool) public excludedFromDividends; mapping (address => uint256) public lastClaimTimes; uint256 public claimWait; uint256 public minimumTokenBalanceForDividends; event ExcludeFromDividends(address indexed account); event ClaimWaitUpdated(uint256 indexed newValue, uint256 indexed oldValue); event Claim(address indexed account, uint256 amount, bool indexed automatic); constructor() public DividendPayingToken("SafeBank_Dividend_Tracker", "SafeBank_Dividend_Tracker") { claimWait = 3600; minimumTokenBalanceForDividends = 1000000000 * (10**9); //min 1 billion } // added function updateMinimumBalanceForDividends(uint256 newAmountNoDecimials) external onlyOwner{ minimumTokenBalanceForDividends = newAmountNoDecimials * (10**9); } function updateTokenForDividend(address newAddress) external onlyOwner { DividendToken = newAddress; } // function _transfer(address, address, uint256) internal override { require(false, "SafeBank_Dividend_Tracker: No transfers allowed"); } function withdrawDividend() public override { require(false, "SafeBank_Dividend_Tracker: withdrawDividend disabled. Use the 'claim' function on the main SafeBank contract."); } function updateClaimWait(uint256 newClaimWait) external onlyOwner { require(newClaimWait >= 3600 && newClaimWait <= 86400, "SafeBank_Dividend_Tracker: claimWait must be updated to between 1 and 24 hours"); require(newClaimWait != claimWait, "SafeBank_Dividend_Tracker: Cannot update claimWait to same value"); emit ClaimWaitUpdated(newClaimWait, claimWait); claimWait = newClaimWait; } function getLastProcessedIndex() external view returns(uint256) { return lastProcessedIndex; } function getNumberOfTokenHolders() external view returns(uint256) { return tokenHoldersMap.keys.length; } function getAccount(address _account) public view returns ( address account, int256 index, int256 iterationsUntilProcessed, uint256 withdrawableDividends, uint256 totalDividends, uint256 lastClaimTime, uint256 nextClaimTime, uint256 secondsUntilAutoClaimAvailable) { account = _account; index = tokenHoldersMap.getIndexOfKey(account); iterationsUntilProcessed = -1; if(index >= 0) { if(uint256(index) > lastProcessedIndex) { iterationsUntilProcessed = index.sub(int256(lastProcessedIndex)); } else { uint256 processesUntilEndOfArray = tokenHoldersMap.keys.length > lastProcessedIndex ? tokenHoldersMap.keys.length.sub(lastProcessedIndex) : 0; iterationsUntilProcessed = index.add(int256(processesUntilEndOfArray)); } } withdrawableDividends = withdrawableDividendOf(account); totalDividends = accumulativeDividendOf(account); lastClaimTime = lastClaimTimes[account]; nextClaimTime = lastClaimTime > 0 ? lastClaimTime.add(claimWait) : 0; secondsUntilAutoClaimAvailable = nextClaimTime > block.timestamp ? nextClaimTime.sub(block.timestamp) : 0; } function getAccountAtIndex(uint256 index) public view returns ( address, int256, int256, uint256, uint256, uint256, uint256, uint256) { if(index >= tokenHoldersMap.size()) { return (0x0000000000000000000000000000000000000000, -1, -1, 0, 0, 0, 0, 0); } address account = tokenHoldersMap.getKeyAtIndex(index); return getAccount(account); } function excludeFromDividends(address account) external onlyOwner { require(!excludedFromDividends[account]); excludedFromDividends[account] = true; _setBalance(account, 0); tokenHoldersMap.remove(account); //emit ExcludeFromDividends(account); } function canAutoClaim(uint256 lastClaimTime) private view returns (bool) { if(lastClaimTime > block.timestamp) { return false; } return block.timestamp.sub(lastClaimTime) >= claimWait; } 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 process(uint256 gas) public returns (uint256, uint256, uint256) { uint256 numberOfTokenHolders = tokenHoldersMap.keys.length; if(numberOfTokenHolders == 0) { return (0, 0, lastProcessedIndex); } uint256 _lastProcessedIndex = lastProcessedIndex; uint256 gasUsed = 0; uint256 gasLeft = gasleft(); uint256 iterations = 0; uint256 claims = 0; while(gasUsed < gas && iterations < numberOfTokenHolders) { _lastProcessedIndex++; if(_lastProcessedIndex >= tokenHoldersMap.keys.length) { _lastProcessedIndex = 0; } address account = tokenHoldersMap.keys[_lastProcessedIndex]; if(canAutoClaim(lastClaimTimes[account])) { if(processAccount(payable(account), true)) { claims++; } } iterations++; uint256 newGasLeft = gasleft(); if(gasLeft > newGasLeft) { gasUsed = gasUsed.add(gasLeft.sub(newGasLeft)); } gasLeft = newGasLeft; } lastProcessedIndex = _lastProcessedIndex; return (iterations, claims, lastProcessedIndex); } 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
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"bool","name":"automatic","type":"bool"}],"name":"Claim","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"newValue","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"oldValue","type":"uint256"}],"name":"ClaimWaitUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"weiAmount","type":"uint256"},{"indexed":true,"internalType":"address","name":"tokenWithdrawn","type":"address"}],"name":"DividendWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"weiAmount","type":"uint256"}],"name":"DividendsDistributed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"ExcludeFromDividends","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DividendToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"accumulativeDividendOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimWait","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"distributeDividends","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"distributeTokenDividends","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"dividendOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"excludeFromDividends","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"excludedFromDividends","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"getAccount","outputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"int256","name":"index","type":"int256"},{"internalType":"int256","name":"iterationsUntilProcessed","type":"int256"},{"internalType":"uint256","name":"withdrawableDividends","type":"uint256"},{"internalType":"uint256","name":"totalDividends","type":"uint256"},{"internalType":"uint256","name":"lastClaimTime","type":"uint256"},{"internalType":"uint256","name":"nextClaimTime","type":"uint256"},{"internalType":"uint256","name":"secondsUntilAutoClaimAvailable","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getAccountAtIndex","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"int256","name":"","type":"int256"},{"internalType":"int256","name":"","type":"int256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLastProcessedIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getNumberOfTokenHolders","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"lastClaimTimes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastProcessedIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minimumTokenBalanceForDividends","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"gas","type":"uint256"}],"name":"process","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"account","type":"address"},{"internalType":"bool","name":"automatic","type":"bool"}],"name":"processAccount","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"account","type":"address"},{"internalType":"uint256","name":"newBalance","type":"uint256"}],"name":"setBalance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalDividendsDistributed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newClaimWait","type":"uint256"}],"name":"updateClaimWait","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newAmountNoDecimials","type":"uint256"}],"name":"updateMinimumBalanceForDividends","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newAddress","type":"address"}],"name":"updateTokenForDividend","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawDividend","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"withdrawableDividendOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"withdrawnDividendOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
75078:7260:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43330:393;;;:::i;:::-;;23842:91;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25988:169;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;25988:169:0;;-1:-1:-1;;;;;25988:169:0;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;77258:119;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;24941:108;;;;;;;;;;;;;:::i;75427:50::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;75427:50:0;-1:-1:-1;;;;;75427:50:0;;:::i;26639:321::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;26639:321:0;;;;;;;;;;;;;;;;;:::i;47050:247::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;47050:247:0;-1:-1:-1;;;;;47050:247:0;;:::i;75322:33::-;;;;;;;;;;;;;:::i;24785:91::-;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;79584:310;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;79584:310:0;-1:-1:-1;;;;;79584:310:0;;:::i;27369:218::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;27369:218:0;;-1:-1:-1;;;;;27369:218:0;;;;;;:::i;76035:173::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;76035:173:0;;:::i;76216:116::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;76216:116:0;-1:-1:-1;;;;;76216:116:0;;:::i;75364:54::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;75364:54:0;-1:-1:-1;;;;;75364:54:0;;:::i;79065:511::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;79065:511:0;;:::i;:::-;;;;-1:-1:-1;;;;;79065:511:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76505:195;;;;;;;;;;;;;:::i;75486:24::-;;;;;;;;;;;;;:::i;25112:127::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;25112:127:0;-1:-1:-1;;;;;25112:127:0;;:::i;16189:148::-;;;;;;;;;;;;;:::i;42298:40::-;;;;;;;;;;;;;:::i;15538:87::-;;;;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;15538:87:0;;;;;;;;;;;;;;45764:124;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;45764:124:0;-1:-1:-1;;;;;45764:124:0;;:::i;24052:95::-;;;;;;;;;;;;;:::i;28090:269::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;28090:269:0;;-1:-1:-1;;;;;28090:269:0;;;;;;:::i;46099:168::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;46099:168:0;-1:-1:-1;;;;;46099:168:0;;:::i;25452:175::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;25452:175:0;;-1:-1:-1;;;;;25452:175:0;;;;;;:::i;46480:129::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;46480:129:0;-1:-1:-1;;;;;46480:129:0;;:::i;43733:383::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;43733:383:0;;:::i;81965:364::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;81965:364:0;;-1:-1:-1;;;;;81965:364:0;;;;;;;;:::i;75517:46::-;;;;;;;;;;;;;:::i;25690:151::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;25690:151:0;;;;;;;;;;:::i;80144:499::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;80144:499:0;;-1:-1:-1;;;;;80144:499:0;;;;;;:::i;41218:41::-;;;;;;;;;;;;;:::i;77142:108::-;;;;;;;;;;;;;:::i;76708:426::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;76708:426:0;;:::i;16492:244::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;16492:244:0;-1:-1:-1;;;;;16492:244:0;;:::i;77387:1670::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;77387:1670:0;-1:-1:-1;;;;;77387:1670:0;;:::i;80651:1306::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;80651:1306:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;43330:393;43416:1;43400:13;:11;:13::i;:::-;:17;43392:26;;;;;;43431:9;:13;43427:291;;43483:91;43552:13;:11;:13::i;:::-;43523:26;43524:9;41122:6;43523:15;:26::i;:::-;:42;;;;;43483:25;;;43523:42;;43483:29;:91::i;:::-;43455:25;:119;43588:43;;;43621:9;43588:43;;;;43609:10;;43588:43;;;;;;;;;;43670:25;;:40;;43700:9;43670:29;:40::i;:::-;43642:25;:68;43427:291;43330:393::o;23842:91::-;23920:5;23913:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23887:13;;23913:12;;23920:5;;23913:12;;23920:5;23913:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23842:91;:::o;25988:169::-;26071:4;26088:39;26097:12;:10;:12::i;:::-;26111:7;26120:6;26088:8;:39::i;:::-;-1:-1:-1;26145:4:0;25988:169;;;;;:::o;77258:119::-;77342:15;:27;77258:119;:::o;24941:108::-;25029:12;;24941:108;:::o;75427:50::-;;;;;;;;;;;;;:::o;26639:321::-;26745:4;26762:36;26772:6;26780:9;26791:6;26762:9;:36::i;:::-;26809:121;26818:6;26826:12;:10;:12::i;:::-;26840:89;26878:6;26840:89;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;26840:19:0;;;;;;-1:-1:-1;26840:19:0;;;;;;26860:12;:10;:12::i;:::-;-1:-1:-1;;;;;26840:33:0;;;;;;;;;;;;-1:-1:-1;26840:33:0;;;;:37;:89::i;:::-;26809:8;:121::i;:::-;-1:-1:-1;26948:4:0;26639:321;;;;;:::o;47050:247::-;-1:-1:-1;;;;;47226:36:0;;47127:7;47226:36;;;:28;:36;;;;;;41122:6;;47150:129;;:113;;:63;:48;47180:17;47226:36;47180:9;:17::i;:::-;47150:25;;;:29;:48::i;:::-;:61;:63::i;:::-;:75;;:113::i;:::-;:127;:129::i;:::-;:141;;;;;;47143:148;;47050:247;;;;:::o;75322:33::-;;;;:::o;24785:91::-;24859:9;;;;24785:91;:::o;79584:310::-;15769:12;:10;:12::i;:::-;-1:-1:-1;;;;;15758:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;15758:23:0;;15750:68;;;;;-1:-1:-1;;;15750:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;79670:30:0;::::1;;::::0;;;:21:::1;:30;::::0;;;;;::::1;;79669:31;79661:40;;;::::0;::::1;;-1:-1:-1::0;;;;;79712:30:0;::::1;;::::0;;;:21:::1;:30;::::0;;;;:37;;;::::1;-1:-1:-1::0;79712:37:0::1;::::0;;79762:23:::1;::::0;79712:30;;79762:11:::1;:23::i;:::-;79796:31;::::0;;;;;:15:::1;:31;::::0;::::1;::::0;-1:-1:-1;;;;;79796:31:0;::::1;::::0;;;;;;:22:::1;::::0;::::1;::::0;:31;;;;;-1:-1:-1;;79796:31:0;;;;;;;:22;:31;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;79584:310:::0;:::o;27369:218::-;27457:4;27474:83;27483:12;:10;:12::i;:::-;27497:7;27506:50;27545:10;27506:11;:25;27518:12;:10;:12::i;:::-;-1:-1:-1;;;;;27506:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;27506:25:0;;;:34;;;;;;;;;;;:38;:50::i;76035:173::-;15769:12;:10;:12::i;:::-;-1:-1:-1;;;;;15758:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;15758:23:0;;15750:68;;;;;-1:-1:-1;;;15750:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76194:5:::1;76170:30;76136:31;:64:::0;76035:173::o;76216:116::-;15769:12;:10;:12::i;:::-;-1:-1:-1;;;;;15758:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;15758:23:0;;15750:68;;;;;-1:-1:-1;;;15750:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76298:13:::1;:26:::0;;;::::1;-1:-1:-1::0;;;;;76298:26:0;;;::::1;::::0;;;::::1;::::0;;76216:116::o;75364:54::-;;;;;;;;;;;;;;;:::o;79065:511::-;79151:7;79173:6;79194;79215:7;79237;79259;79281;79303;79335:15;:20;;;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;79335:22:0;79326:31;;79323:137;;-1:-1:-1;79382:42:0;;-1:-1:-1;79426:2:0;;-1:-1:-1;79426:2:0;;-1:-1:-1;79382:42:0;;-1:-1:-1;79382:42:0;;-1:-1:-1;79382:42:0;;-1:-1:-1;79382:42:0;;-1:-1:-1;79382:42:0;79374:74;;79323:137;79472:15;79490;:29;;;;79520:5;79490:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;79490:36:0;;-1:-1:-1;79546:19:0;79490:36;79546:10;:19::i;:::-;79539:26;;;;;;;;;;;;;;;;;79065:511;;;;;;;;;;:::o;76505:195::-;76560:127;;-1:-1:-1;;;76560:127:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75486:24;;;;:::o;25112:127::-;-1:-1:-1;;;;;25213:18:0;25186:7;25213:18;;;;;;;;;;;;25112:127::o;16189:148::-;15769:12;:10;:12::i;:::-;-1:-1:-1;;;;;15758:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;15758:23:0;;15750:68;;;;;-1:-1:-1;;;15750:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16280:6:::1;::::0;16259:40:::1;::::0;16296:1:::1;::::0;-1:-1:-1;;;;;16280:6:0::1;::::0;16259:40:::1;::::0;16296:1;;16259:40:::1;16310:6;:19:::0;;;::::1;::::0;;16189:148::o;42298:40::-;;;;:::o;15538:87::-;15611:6;;-1:-1:-1;;;;;15611:6:0;;15538:87::o;45764:124::-;45829:7;45852:30;45875:6;45852:22;:30::i;24052:95::-;24132:7;24125:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24099:13;;24125:14;;24132:7;;24125:14;;24132:7;24125:14;;;;;;;;;;;;;;;;;;;;;;;;28090:269;28183:4;28200:129;28209:12;:10;:12::i;:::-;28223:7;28232:96;28271:15;28232:96;;;;;;;;;;;;;;;;;:11;:25;28244:12;:10;:12::i;:::-;-1:-1:-1;;;;;28232:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;28232:25:0;;;:34;;;;;;;;;;;;:38;:96::i;46099:168::-;-1:-1:-1;;;;;46234:26:0;;46176:7;46234:26;;;:18;:26;;;;;;46199:62;;:30;46234:26;46199:22;:30::i;:::-;:34;;:62::i;25452:175::-;25538:4;25555:42;25565:12;:10;:12::i;:::-;25579:9;25590:6;25555:9;:42::i;46480:129::-;-1:-1:-1;;;;;46577:26:0;46554:7;46577:26;;;:18;:26;;;;;;;46480:129::o;43733:383::-;43821:1;43805:13;:11;:13::i;:::-;:17;43797:26;;;;;;43836:10;;43832:279;;43885:88;43951:13;:11;:13::i;:::-;43925:23;43926:6;41122;43925:12;:23::i;43885:88::-;43857:25;:116;43987:40;;;;;;;;44008:10;;43987:40;;;;;;;;;;44066:25;;:37;;44096:6;44066:29;:37::i;:::-;44038:25;:65;43832:279;43733:383;:::o;81965:364::-;82056:4;15769:12;:10;:12::i;:::-;-1:-1:-1;;;;;15758:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;15758:23:0;;15750:68;;;;;-1:-1:-1;;;15750:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;82073:14:::1;82090:32;82114:7;82090:23;:32::i;:::-;82073:49:::0;-1:-1:-1;82138:10:0;;82135:162:::1;;-1:-1:-1::0;;;;;82165:23:0;::::1;;::::0;;;:14:::1;:23;::::0;;;;;;;;82191:15:::1;82165:41:::0;;82226:33;;;;;;;;::::1;;::::0;82165:23;82226:33:::1;::::0;;;;;;;::::1;82281:4;82274:11;;;;;82135:162;-1:-1:-1::0;82316:5:0::1;::::0;81965:364;-1:-1:-1;;;81965:364:0:o;75517:46::-;;;;:::o;25690:151::-;-1:-1:-1;;;;;25806:18:0;;;25779:7;25806:18;;;-1:-1:-1;25806:18:0;;;;;;;;:27;;;;;;;;;;;;;25690:151::o;80144:499::-;15769:12;:10;:12::i;:::-;-1:-1:-1;;;;;15758:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;15758:23:0;;15750:68;;;;;-1:-1:-1;;;15750:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;80242:30:0;::::1;;::::0;;;:21:::1;:30;::::0;;;;;::::1;;80239:68;;;80289:7;;80239:68;80336:31;;80322:10;:45;80319:275;;80384:32;80396:7;80405:10;80384:11;:32::i;:::-;80431:40;::::0;;;;;:15:::1;:40;::::0;::::1;::::0;-1:-1:-1;;;;;80431:40:0;::::1;::::0;;;;;;;;;;;;:19:::1;::::0;::::1;::::0;:40;;;;;-1:-1:-1;;80431:40:0;;;;;;;:19;:40;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;80319:275;;;80513:23;80525:7;80534:1;80513:11;:23::i;:::-;80551:31;::::0;;;;;:15:::1;:31;::::0;::::1;::::0;-1:-1:-1;;;;;80551:31:0;::::1;::::0;;;;;;:22:::1;::::0;::::1;::::0;:31;;;;;-1:-1:-1;;80551:31:0;;;;;;;:22;:31;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;80319:275;80606:29;80621:7;80630:4;80606:14;:29::i;:::-;;15829:1;80144:499:::0;;:::o;41218:41::-;;;-1:-1:-1;;;;;41218:41:0;;:::o;77142:108::-;77224:18;;77142:108;:::o;76708:426::-;15769:12;:10;:12::i;:::-;-1:-1:-1;;;;;15758:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;15758:23:0;;15750:68;;;;;-1:-1:-1;;;15750:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76809:4:::1;76793:12;:20;;:45;;;;;76833:5;76817:12;:21;;76793:45;76785:136;;;;-1:-1:-1::0;;;76785:136:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76956:9;;76940:12;:25;;76932:102;;;;-1:-1:-1::0;;;76932:102:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77081:9;::::0;77050:41:::1;::::0;77067:12;;77050:41:::1;::::0;;;::::1;77102:9;:24:::0;76708:426::o;16492:244::-;15769:12;:10;:12::i;:::-;-1:-1:-1;;;;;15758:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;15758:23:0;;15750:68;;;;;-1:-1:-1;;;15750:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;16581:22:0;::::1;16573:73;;;;-1:-1:-1::0;;;16573:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16683:6;::::0;16662:38:::1;::::0;-1:-1:-1;;;;;16662:38:0;;::::1;::::0;16683:6:::1;::::0;16662:38:::1;::::0;16683:6:::1;::::0;16662:38:::1;16711:6;:17:::0;;;::::1;-1:-1:-1::0;;;;;16711:17:0;;;::::1;::::0;;;::::1;::::0;;16492:244::o;77387:1670::-;77815:38;;;;;;:15;:38;;;;-1:-1:-1;;;;;77815:38:0;;;;;;;;77786:8;;77469:15;;;;;;;;;;;;;;77815:29;;;;:38;;;;;;;;;;;;;;:29;:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;77815:38:0;;-1:-1:-1;77893:2:0;;-1:-1:-1;77920:1:0;77911:10;;77908:582;;77958:18;;77949:5;77941:35;77938:541;;;78041:18;;78024:37;;:5;;:9;:37::i;:::-;77997:64;;77938:541;;;78180:18;;78150:15;:27;78115:32;;-1:-1:-1;78150:220:0;;78369:1;78150:220;;;78290:18;;78258:15;:27;:51;;:31;:51::i;:::-;78115:255;-1:-1:-1;78420:43:0;:5;78115:255;78420:9;:43::i;:::-;78393:70;;77938:541;;78528:31;78551:7;78528:22;:31::i;:::-;78504:55;;78587:31;78610:7;78587:22;:31::i;:::-;-1:-1:-1;;;;;78647:23:0;;;;;;:14;:23;;;;;;78570:48;;-1:-1:-1;78647:23:0;-1:-1:-1;78647:23:0;78699:126;;78824:1;78699:126;;;78774:9;;78756:28;;:13;;:17;:28::i;:::-;78683:142;;78887:15;78871:13;:31;:178;;79048:1;78871:178;;;78958:34;:13;78976:15;78958:17;:34::i;:::-;78838:211;;77387:1670;;;;;;;;;:::o;80651:1306::-;80766:15;:27;80697:7;;;;;;80809:25;80806:90;;-1:-1:-1;;80865:18:0;;80859:1;;-1:-1:-1;80859:1:0;;-1:-1:-1;80851:33:0;;80806:90;80938:18;;80908:27;;81019:9;81001:27;;81041:18;81074:14;81105:732;81121:3;81111:7;:13;:50;;;;;81141:20;81128:10;:33;81111:50;81105:732;;;81242:15;:27;81178:21;;;;;81219:50;;81216:113;;81312:1;81290:23;;81216:113;81345:15;81363;:20;;81384:19;81363:41;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;81363:41:0;81437:23;;;:14;:23;;;;;;;;81363:41;;-1:-1:-1;81424:37:0;;:12;:37::i;:::-;81421:170;;;81485:38;81508:7;81518:4;81485:14;:38::i;:::-;81482:94;;;81548:8;;;;;81482:94;81607:12;;;;;81636:18;81657:9;81636:30;;81696:10;81686:7;:20;81683:106;;;81737:36;81749:23;:7;81761:10;81749:11;:23::i;:::-;81737:7;;:11;:36::i;:::-;81727:46;;81683:106;81815:10;-1:-1:-1;81105:732:0;;-1:-1:-1;81105:732:0;;81849:18;:40;;;81910:10;;-1:-1:-1;81922:6:0;-1:-1:-1;81870:19:0;;-1:-1:-1;;;;80651:1306:0;;;;;;:::o;36365:220::-;36423:7;36447:6;36443:20;;-1:-1:-1;36462:1:0;36455:8;;36443:20;36486:5;;;36490:1;36486;:5;:1;36510:5;;;;;:10;36502:56;;;;-1:-1:-1;;;36502:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36576:1;36365:220;-1:-1:-1;;;36365:220:0:o;35486:179::-;35544:7;35576:5;;;35600:6;;;;35592:46;;;;;-1:-1:-1;;;35592:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;4157:106;4245:10;4157:106;:::o;31237:346::-;-1:-1:-1;;;;;31339:19:0;;31331:68;;;;-1:-1:-1;;;31331:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;31418:21:0;;31410:68;;;;-1:-1:-1;;;31410:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;31491:18:0;;;;;;;-1:-1:-1;31491:18:0;;;;;;;;:27;;;;;;;;;;;;;:36;;;31543:32;;;;;;;;;;;;;;;;;31237:346;;;:::o;76349:148::-;76424:65;;-1:-1:-1;;;76424:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38313:166;38399:7;38435:12;38427:6;;;;38419:29;;;;-1:-1:-1;38419:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;38466:5:0;;;38313:166::o;21572:134::-;21628:6;21661:1;21678:6;;;;21670:15;;;;;21091:162;21147:6;21173:5;;;21194:6;;;;;;:16;;;21209:1;21204;:6;;21194:16;21193:38;;;;21220:1;21216;:5;:14;;;;;21229:1;21225;:5;21216:14;21185:47;;;;;21259:117;21315:7;21344:1;21339;:6;;21331:15;;;;;;-1:-1:-1;21368:1:0;21259:117::o;49055:407::-;49129:22;49154:18;49164:7;49154:9;:18::i;:::-;49129:43;;49197:14;49184:10;:27;49181:276;;;49222:18;49243:30;:10;49258:14;49243;:30::i;:::-;49222:51;;49282:26;49288:7;49297:10;49282:5;:26::i;:::-;49181:276;;;;49338:14;49325:10;:27;49322:135;;;49363:18;49384:30;:14;49403:10;49384:18;:30::i;:::-;49363:51;;49423:26;49429:7;49438:10;49423:5;:26::i;:::-;49322:135;49055:407;;;:::o;35948:158::-;36006:7;36039:1;36034;:6;;36026:49;;;;;-1:-1:-1;;;36026:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;36093:5:0;;;35948:158::o;44594:957::-;44667:7;44683:29;44715:28;44738:4;44715:22;:28::i;:::-;44683:60;-1:-1:-1;44754:25:0;;44750:779;;-1:-1:-1;;;;;44817:24:0;;;;;;:18;:24;;;;;;:51;;44846:21;44817:28;:51::i;:::-;-1:-1:-1;;;;;44790:24:0;;;;;;;:18;:24;;;;;:78;;;;44915:13;;;44912:430;;44991:43;;44959:9;;;;-1:-1:-1;;;;;44991:9:0;;;45008:21;;44959:9;44991:43;44959:9;44991:43;45008:21;44991:9;:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;45130:13:0;;45083:61;;;;;;;;44958:76;;-1:-1:-1;44958:76:0;;-1:-1:-1;44958:76:0;;-1:-1:-1;;;;;;45130:13:0;;;;45083:61;;;;;;;;;;;;;;44912:430;;;;;45197:13;;45190:59;;;;;;-1:-1:-1;;;;;45190:59:0;;;;;;;;;;;;;;;45197:13;;;;;45190:30;;:59;;;;;;;;;;;;;;-1:-1:-1;45197:13:0;45190:59;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;45190:59:0;45316:13;;45269:61;;;;;;;;45190:59;;-1:-1:-1;;;;;;45316:13:0;;;;45269:61;;;;;;;;;45190:59;45269:61;;;44912:430;45356:7;45352:131;;-1:-1:-1;;;;;45403:24:0;;;;;;:18;:24;;;;;;:51;;45432:21;45403:28;:51::i;:::-;-1:-1:-1;;;;;45376:24:0;;;;;;:18;:24;;;;;:78;;;;:24;-1:-1:-1;45465:8:0;;-1:-1:-1;;45465:8:0;45352:131;-1:-1:-1;45500:21:0;-1:-1:-1;45493:28:0;;44750:779;-1:-1:-1;45544:1:0;;44594:957;-1:-1:-1;;44594:957:0:o;20932:153::-;20988:6;21017:1;21012;:6;;:20;;;;;21031:1;21026;21022;:5;:10;;21012:20;21011:46;;;;21042:1;21038;:5;:18;;;;;21055:1;21051;21047;:5;:9;21038:18;21003:55;;;;;79902:234;79969:4;80005:15;79989:13;:31;79986:76;;;-1:-1:-1;80045:5:0;80038:12;;79986:76;80119:9;;80081:34;:15;80101:13;80081:19;:34::i;:::-;:47;;;79902:234;-1:-1:-1;;79902:234:0:o;48254:260::-;48326:27;48338:7;48347:5;48326:11;:27::i;:::-;48402:106;48453:53;48454:36;48484:5;48454:25;;:29;;:36;;;;:::i;48453:53::-;-1:-1:-1;;;;;48402:37:0;;;;;;:28;:37;;;;;;;:49;:106::i;:::-;-1:-1:-1;;;;;48362:37:0;;;;;;;;:28;:37;;;;;:146;;;;-1:-1:-1;48254:260:0:o;48789:::-;48861:27;48873:7;48882:5;48861:11;:27::i;:::-;48937:106;48988:53;48989:36;49019:5;48989:25;;:29;;:36;;;;:::i;48988:53::-;-1:-1:-1;;;;;48937:37:0;;;;;;:28;:37;;;;;;;:49;:106::i;29670:378::-;-1:-1:-1;;;;;29754:21:0;;29746:65;;;;;-1:-1:-1;;;29746:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;29824:49;29853:1;29857:7;29866:6;29824:20;:49::i;:::-;29901:12;;:24;;29918:6;29901:16;:24::i;:::-;29886:12;:39;-1:-1:-1;;;;;29957:18:0;;:9;:18;;;;;;;;;;;:30;;29980:6;29957:22;:30::i;:::-;-1:-1:-1;;;;;29936:18:0;;:9;:18;;;;;;;;;;;:51;;;;30003:37;;;;;;;29936:18;;:9;;30003:37;;;;;;;;;;29670:378;;:::o;30381:418::-;-1:-1:-1;;;;;30465:21:0;;30457:67;;;;-1:-1:-1;;;30457:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30537:49;30558:7;30575:1;30579:6;30537:20;:49::i;:::-;30620:68;30643:6;30620:68;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;30620:18:0;;:9;:18;;;;;;;;;;;;;:22;:68::i;:::-;-1:-1:-1;;;;;30599:18:0;;:9;:18;;;;;;;;;;:89;30714:12;;:24;;30731:6;30714:16;:24::i;:::-;30699:12;:39;30754:37;;;;;;;;30780:1;;-1:-1:-1;;;;;30754:37:0;;;;;;;;;;;;30381:418;;:::o
Swarm Source
ipfs://43bdd2b2c90e37a5c23bb70551b59ca84fad3c035a12762ff29c15c0bcfe9c8d
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.