ERC-20
Overview
Max Total Supply
230,133,963.329859747388467168 eVAULT_Dividend_Tracker
Holders
298
Market
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract (WITH 18 Decimals)
Balance
78,924.958649057523943243 eVAULT_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:
eVAULTDividendTracker
Compiler Version
v0.8.4+commit.c7e474f2
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2021-08-13 */ /** *Submitted for verification at Etherscan.io on 2021-07-21 */ // SPDX-License-Identifier: Unlicensed pragma solidity ^0.8.4; //////////////////////////////// ///////////// ERC ////////////// //////////////////////////////// /* * @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 payable(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; } } /** * @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; } } 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); } /** * @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 = 18; } /** * @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 { } } //////////////////////////////// ////////// Dividend //////////// //////////////////////////////// /* @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 ); } /* @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); } /* @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 = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48; // 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; uint256 public gasForTransfer; constructor(string memory _name, string memory _symbol) ERC20(_name, _symbol) { gasForTransfer = 3000; } 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 distributeDividends(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(payable(msg.sender)); } function setDividendTokenAddress(address newToken) public { dividendToken = newToken; } /// @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 _withdrawDividendOfUser(address payable user) internal returns (uint256) { uint256 _withdrawableDividend = withdrawableDividendOf(user); if (_withdrawableDividend > 0) { withdrawnDividends[user] = withdrawnDividends[user].add(_withdrawableDividend); emit DividendWithdrawn(user, _withdrawableDividend); bool success = IERC20(dividendToken).transfer(user, _withdrawableDividend); 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); } } } //////////////////////////////// ///////// Interfaces /////////// //////////////////////////////// interface IUniswapV2Factory { event PairCreated(address indexed token0, address indexed token1, address pair, uint); function feeTo() external view returns (address); function feeToSetter() external view returns (address); function getPair(address tokenA, address tokenB) external view returns (address pair); function allPairs(uint) external view returns (address pair); function allPairsLength() external view returns (uint); function createPair(address tokenA, address tokenB) external returns (address pair); function setFeeTo(address) external; function setFeeToSetter(address) external; } interface IUniswapV2Pair { event Approval(address indexed owner, address indexed spender, uint value); event Transfer(address indexed from, address indexed to, uint value); function name() external pure returns (string memory); function symbol() external pure returns (string memory); function decimals() external pure returns (uint8); function totalSupply() external view returns (uint); function balanceOf(address owner) external view returns (uint); function allowance(address owner, address spender) external view returns (uint); function approve(address spender, uint value) external returns (bool); function transfer(address to, uint value) external returns (bool); function transferFrom(address from, address to, uint value) external returns (bool); function DOMAIN_SEPARATOR() external view returns (bytes32); function PERMIT_TYPEHASH() external pure returns (bytes32); function nonces(address owner) external view returns (uint); function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external; event Mint(address indexed sender, uint amount0, uint amount1); event Burn(address indexed sender, uint amount0, uint amount1, address indexed to); event Swap( address indexed sender, uint amount0In, uint amount1In, uint amount0Out, uint amount1Out, address indexed to ); event Sync(uint112 reserve0, uint112 reserve1); function MINIMUM_LIQUIDITY() external pure returns (uint); function factory() external view returns (address); function token0() external view returns (address); function token1() external view returns (address); function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast); function price0CumulativeLast() external view returns (uint); function price1CumulativeLast() external view returns (uint); function kLast() external view returns (uint); function mint(address to) external returns (uint liquidity); function burn(address to) external returns (uint amount0, uint amount1); function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external; function skim(address to) external; function sync() external; function initialize(address, address) external; } interface IUniswapV2Router01 { function factory() external pure returns (address); function WETH() external pure returns (address); function addLiquidity( address tokenA, address tokenB, uint amountADesired, uint amountBDesired, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB, uint liquidity); function addLiquidityETH( address token, uint amountTokenDesired, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external payable returns (uint amountToken, uint amountETH, uint liquidity); function removeLiquidity( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline ) external returns (uint amountA, uint amountB); function removeLiquidityETH( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountToken, uint amountETH); function removeLiquidityWithPermit( address tokenA, address tokenB, uint liquidity, uint amountAMin, uint amountBMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountA, uint amountB); function removeLiquidityETHWithPermit( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountToken, uint amountETH); function swapExactTokensForTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapTokensForExactTokens( uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline ) external returns (uint[] memory amounts); function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts); function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts); function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB); function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut); function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn); function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts); function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts); } interface IUniswapV2Router02 is IUniswapV2Router01 { function removeLiquidityETHSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline ) external returns (uint amountETH); function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens( address token, uint liquidity, uint amountTokenMin, uint amountETHMin, address to, uint deadline, bool approveMax, uint8 v, bytes32 r, bytes32 s ) external returns (uint amountETH); function swapExactTokensForTokensSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; function swapExactETHForTokensSupportingFeeOnTransferTokens( uint amountOutMin, address[] calldata path, address to, uint deadline ) external payable; function swapExactTokensForETHSupportingFeeOnTransferTokens( uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline ) external; } //////////////////////////////// ////////// Libraries /////////// //////////////////////////////// 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(); } } /** * @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; } } /** * @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); } } /** * @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; } } //////////////////////////////// /////////// Tokens ///////////// //////////////////////////////// contract eVAULT is ERC20, Ownable { using SafeMath for uint256; IUniswapV2Router02 public uniswapV2Router; address public immutable uniswapV2Pair; bool private liquidating; eVAULTDividendTracker public dividendTracker; address public liquidityWallet; uint256 public constant MAX_SELL_TRANSACTION_AMOUNT = 10000000 * (10**18); uint256 public constant ETH_REWARDS_FEE = 5; uint256 public constant LIQUIDITY_FEE = 5; uint256 public constant TOTAL_FEES = ETH_REWARDS_FEE + LIQUIDITY_FEE; bool _swapEnabled = false; bool openForPresale = false; mapping (address => bool) private _isBlackListedBot; address[] private _blackListedBots; address private _dividendToken = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48; bool _maxBuyEnabled = true; // use by default 150,000 gas to process auto-claiming dividends uint256 public gasForProcessing = 150000; // liquidate tokens for ETH when the contract reaches 100k tokens by default uint256 public liquidateTokensAtAmount = 100000 * (10**18); // whether the token can already be traded bool public tradingEnabled; function activate() public onlyOwner { require(!tradingEnabled, "eVAULT: Trading is already enabled"); _swapEnabled = true; tradingEnabled = true; } // exclude from fees and max transaction amount mapping (address => bool) private _isExcludedFromFees; // addresses that can make transfers before presale is over mapping (address => bool) public 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 UpdatedDividendTracker(address indexed newAddress, address indexed oldAddress); event UpdatedUniswapV2Router(address indexed newAddress, address indexed oldAddress); event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value); event LiquidityWalletUpdated(address indexed newLiquidityWallet, address indexed oldLiquidityWallet); event GasForProcessingUpdated(uint256 indexed newValue, uint256 indexed oldValue); event LiquidationThresholdUpdated(uint256 indexed newValue, uint256 indexed oldValue); event Liquified( uint256 tokensSwapped, uint256 ethReceived, uint256 tokensIntoLiqudity ); event SwapAndSendToDev( uint256 tokensSwapped, uint256 ethReceived ); event SentDividends( uint256 tokensSwapped, uint256 amount ); event ProcessedDividendTracker( uint256 iterations, uint256 claims, uint256 lastProcessedIndex, bool indexed automatic, uint256 gas, address indexed processor ); constructor() ERC20("Ethereum Vault", "eVAULT") { dividendTracker = new eVAULTDividendTracker(); liquidityWallet = owner(); 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(owner()); dividendTracker.excludeFromDividends(address(_uniswapV2Router)); dividendTracker.excludeFromDividends(address(0x000000000000000000000000000000000000dEaD)); // exclude from paying fees or having max transaction amount excludeFromFees(liquidityWallet); excludeFromFees(address(this)); // enable owner 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(), 1000000000 * (10**18)); } receive() external payable { } function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner { require(pair != uniswapV2Pair, "eVAULT: The Uniswap pair cannot be removed from automatedMarketMakerPairs"); _setAutomatedMarketMakerPair(pair, value); } function _setAutomatedMarketMakerPair(address pair, bool value) private { require(automatedMarketMakerPairs[pair] != value, "eVAULT: Automated market maker pair is already set to that value"); automatedMarketMakerPairs[pair] = value; if(value) { dividendTracker.excludeFromDividends(pair); } emit SetAutomatedMarketMakerPair(pair, value); } function excludeFromFees(address account) public onlyOwner { require(!_isExcludedFromFees[account], "eVAULT: Account is already excluded from fees"); _isExcludedFromFees[account] = true; } function updateGasForTransfer(uint256 gasForTransfer) external onlyOwner { dividendTracker.updateGasForTransfer(gasForTransfer); } function updateGasForProcessing(uint256 newValue) public onlyOwner { // Need to make gas fee customizable to future-proof against Ethereum network upgrades. require(newValue != gasForProcessing, "eVAULT: Cannot update gasForProcessing to same value"); emit GasForProcessingUpdated(newValue, gasForProcessing); gasForProcessing = newValue; } function updateClaimWait(uint256 claimWait) external onlyOwner { dividendTracker.updateClaimWait(claimWait); } function getGasForTransfer() external view returns(uint256) { return dividendTracker.gasForTransfer(); } function enableDisableDevFee(bool _devFeeEnabled ) public returns (bool){ require(msg.sender == liquidityWallet, "Only Dev Address can disable dev fee"); _swapEnabled = _devFeeEnabled; return(_swapEnabled); } function setOpenForPresale(bool open )external onlyOwner { openForPresale = open; } function setMaxBuyEnabled(bool enabled ) external onlyOwner { _maxBuyEnabled = enabled; } 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 addBotToBlackList(address account) external onlyOwner() { require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not blacklist Uniswap router.'); require(!_isBlackListedBot[account], "Account is already blacklisted"); _isBlackListedBot[account] = true; _blackListedBots.push(account); } function removeBotFromBlackList(address account) external onlyOwner() { require(_isBlackListedBot[account], "Account is not blacklisted"); for (uint256 i = 0; i < _blackListedBots.length; i++) { if (_blackListedBots[i] == account) { _blackListedBots[i] = _blackListedBots[_blackListedBots.length - 1]; _isBlackListedBot[account] = false; _blackListedBots.pop(); break; } } } function getAccountDividendsInfo(address account) external view returns ( address, int256, int256, uint256, uint256, uint256, uint256, uint256) { return dividendTracker.getAccount(account); } function getAccountDividendsInfoAtIndex(uint256 index) external view returns ( address, int256, int256, uint256, uint256, uint256, uint256, uint256) { return dividendTracker.getAccountAtIndex(index); } function processDividendTracker(uint256 gas) external { (uint256 iterations, uint256 claims, uint256 lastProcessedIndex) = dividendTracker.process(gas); emit ProcessedDividendTracker(iterations, claims, lastProcessedIndex, false, gas, tx.origin); } function claim() external { dividendTracker.processAccount(payable(msg.sender), false); } function getLastProcessedIndex() external view returns(uint256) { return dividendTracker.getLastProcessedIndex(); } function getNumberOfDividendTokenHolders() external view returns(uint256) { return dividendTracker.getNumberOfTokenHolders(); } function _transfer( address from, address to, uint256 amount ) internal override { require(from != address(0), "ERC20: transfer from the zero address"); require(to != address(0), "ERC20: transfer to the zero address"); require(!_isBlackListedBot[to], "You have no power here!"); require(!_isBlackListedBot[msg.sender], "You have no power here!"); require(!_isBlackListedBot[from], "You have no power here!"); //to prevent bots both buys and sells will have a max on launch after only sells will if(from != owner() && to != owner() && _maxBuyEnabled) require(amount <= MAX_SELL_TRANSACTION_AMOUNT, "Transfer amount exceeds the maxTxAmount."); bool tradingIsEnabled = tradingEnabled; // only whitelisted addresses can make transfers before the public presale is over. if (!tradingIsEnabled) { //turn transfer on to allow for whitelist form/mutlisend presale if(!openForPresale){ require(canTransferBeforeTradingIsEnabled[from], "eVAULT: This account cannot send tokens until trading is enabled"); } } if ((from == uniswapV2Pair || to == uniswapV2Pair) && tradingIsEnabled) { //require(!antiBot.scanAddress(from, uniswapV2Pair, tx.origin), "Beep Beep Boop, You're a piece of poop"); // require(!antiBot.scanAddress(to, uniswair, tx.origin), "Beep Beep Boop, You're a piece of poop"); } if (amount == 0) { super._transfer(from, to, 0); return; } if (!liquidating && 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 <= MAX_SELL_TRANSACTION_AMOUNT, "Sell transfer amount exceeds the MAX_SELL_TRANSACTION_AMOUNT."); } uint256 contractTokenBalance = balanceOf(address(this)); bool canSwap = contractTokenBalance >= liquidateTokensAtAmount; if (tradingIsEnabled && canSwap && _swapEnabled && !liquidating && !automatedMarketMakerPairs[from] && from != liquidityWallet && to != liquidityWallet ) { liquidating = true; uint256 swapTokens = contractTokenBalance.mul(LIQUIDITY_FEE).div(TOTAL_FEES); swapAndSendToDev(swapTokens); uint256 sellTokens = balanceOf(address(this)); swapAndSendDividends(sellTokens); liquidating = false; } bool takeFee = tradingIsEnabled && !liquidating; // if any account belongs to _isExcludedFromFee account then remove the fee if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) { takeFee = false; } if (takeFee) { uint256 fees = amount.mul(TOTAL_FEES).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 (!liquidating) { uint256 gas = gasForProcessing; try dividendTracker.process(gas) returns (uint256 iterations, uint256 claims, uint256 lastProcessedIndex) { emit ProcessedDividendTracker(iterations, claims, lastProcessedIndex, true, gas, tx.origin); } catch { } } } function swapAndSendToDev(uint256 tokens) private { uint256 tokenBalance = tokens; // 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(tokenBalance); // <- 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); address payable _devAndMarketingAddress = payable(0x6A08eEC4ba2Fe826A9434b77B55D414Ef3EDf1b3); _devAndMarketingAddress.transfer(newBalance); emit SwapAndSendToDev(tokens, newBalance); } function swapTokensForDividendToken(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 dividend token path, recipient, block.timestamp ); } function swapAndSendDividends(uint256 tokens) private { swapTokensForDividendToken(tokens, address(this)); uint256 dividends = IERC20(_dividendToken).balanceOf(address(this)); bool success = IERC20(_dividendToken).transfer(address(dividendTracker), dividends); if (success) { dividendTracker.distributeDividends(dividends); emit SentDividends(tokens, dividends); } } 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 ); } } contract eVAULTDividendTracker 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 immutable minimumTokenBalanceForDividends; event ExcludeFromDividends(address indexed account); event GasForTransferUpdated(uint256 indexed newValue, uint256 indexed oldValue); event ClaimWaitUpdated(uint256 indexed newValue, uint256 indexed oldValue); event Claim(address indexed account, uint256 amount, bool indexed automatic); constructor() DividendPayingToken("eVAULT_Dividend_Tracker", "eVAULT_Dividend_Tracker") { claimWait = 3600; minimumTokenBalanceForDividends = 10000 * (10**18); //must hold 10000+ tokens } function _transfer(address, address, uint256) pure internal override { require(false, "eVAULT_Dividend_Tracker: No transfers allowed"); } function withdrawDividend() pure public override { require(false, "eVAULT_Dividend_Tracker: withdrawDividend disabled. Use the 'claim' function on the main eVAULT contract."); } function excludeFromDividends(address account) external onlyOwner { require(!excludedFromDividends[account]); excludedFromDividends[account] = true; _setBalance(account, 0); tokenHoldersMap.remove(account); emit ExcludeFromDividends(account); } function updateGasForTransfer(uint256 newGasForTransfer) external onlyOwner { require(newGasForTransfer != gasForTransfer, "eVAULT_Dividend_Tracker: Cannot update gasForTransfer to same value"); emit GasForTransferUpdated(newGasForTransfer, gasForTransfer); gasForTransfer = newGasForTransfer; } function updateClaimWait(uint256 newClaimWait) external onlyOwner { require(newClaimWait >= 1800 && newClaimWait <= 86400, "eVAULT_Dividend_Tracker: claimWait must be updated to between 1 and 24 hours"); require(newClaimWait != claimWait, "eVAULT_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 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"}],"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":"uint256","name":"newValue","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"oldValue","type":"uint256"}],"name":"GasForTransferUpdated","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":[{"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":"distributeDividends","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":[],"name":"dividendToken","outputs":[{"internalType":"address","name":"","type":"address"}],"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":[],"name":"gasForTransfer","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[{"internalType":"address","name":"newToken","type":"address"}],"name":"setDividendTokenAddress","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":"newGasForTransfer","type":"uint256"}],"name":"updateGasForTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawDividend","outputs":[],"stateMutability":"pure","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
64191:7087:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23161:393;;;:::i;:::-;;8060:91;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10206:169;;;;;;;;;;-1:-1:-1;10206:169:0;;;;;:::i;:::-;;:::i;:::-;;;4707:14:1;;4700:22;4682:41;;4670:2;4655:18;10206:169:0;4637:92:1;66759:119:0;;;;;;;;;;-1:-1:-1;66843:15:0;:27;66759:119;;;11334:25:1;;;11322:2;11307:18;66759:119:0;11289:76:1;20960:73:0;;;;;;;;;;-1:-1:-1;20960:73:0;;;;-1:-1:-1;;;;;20960:73:0;;;;;;-1:-1:-1;;;;;3505:32:1;;;;3487:51;;3475:2;3460:18;20960:73:0;3442:102:1;9159:108:0;;;;;;;;;;-1:-1:-1;9247:12:0;;9159:108;;64538:50;;;;;;;;;;-1:-1:-1;64538:50:0;;;;;:::i;:::-;;;;;;;;;;;;;;10857:321;;;;;;;;;;-1:-1:-1;10857:321:0;;;;;:::i;:::-;;:::i;26620:247::-;;;;;;;;;;-1:-1:-1;26620:247:0;;;;;:::i;:::-;;:::i;64433:33::-;;;;;;;;;;;;;;;;9003:91;;;;;;;;;;-1:-1:-1;9077:9:0;;9003:91;;9077:9;;;;13315:36:1;;13303:2;13288:18;9003:91:0;13270:87:1;65578:283:0;;;;;;;;;;-1:-1:-1;65578:283:0;;;;;:::i;:::-;;:::i;23564:378::-;;;;;;;;;;-1:-1:-1;23564:378:0;;;;;:::i;:::-;;:::i;11587:218::-;;;;;;;;;;-1:-1:-1;11587:218:0;;;;;:::i;:::-;;:::i;64475:54::-;;;;;;;;;;-1:-1:-1;64475:54:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;68566:505;;;;;;;;;;-1:-1:-1;68566:505:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;4193:32:1;;;;4175:51;;4257:2;4242:18;;4235:34;;;;4285:18;;;4278:34;;;;4343:2;4328:18;;4321:34;;;;4386:3;4371:19;;4364:35;-1:-1:-1;4415:19:1;;4408:35;4474:3;4459:19;;4452:35;4518:3;4503:19;;4496:35;4162:3;4147:19;68566:505:0;4129:408:1;65379:191:0;;;;;;;;;;;;;:::i;64597:24::-;;;;;;;;;;;;;;;;9330:127;;;;;;;;;;-1:-1:-1;9330:127:0;;;;;:::i;:::-;-1:-1:-1;;;;;9431:18:0;9404:7;9431:18;;;;;;;;;;;;9330:127;2809:148;;;;;;;;;;;;;:::i;24228:97::-;;;;;;;;;;-1:-1:-1;24228:97:0;;;;;:::i;:::-;24295:13;:24;;-1:-1:-1;;;;;;24295:24:0;-1:-1:-1;;;;;24295:24:0;;;;;;;;;;24228:97;22072:40;;;;;;;;;;;;;;;;2158:87;;;;;;;;;;-1:-1:-1;2231:6:0;;-1:-1:-1;;;;;2231:6:0;2158:87;;25334:124;;;;;;;;;;-1:-1:-1;25334:124:0;;;;;:::i;:::-;;:::i;8270:95::-;;;;;;;;;;;;;:::i;65881:327::-;;;;;;;;;;-1:-1:-1;65881:327:0;;;;;:::i;:::-;;:::i;12308:269::-;;;;;;;;;;-1:-1:-1;12308:269:0;;;;;:::i;:::-;;:::i;25669:168::-;;;;;;;;;;-1:-1:-1;25669:168:0;;;;;:::i;:::-;;:::i;9670:175::-;;;;;;;;;;-1:-1:-1;9670:175:0;;;;;:::i;:::-;;:::i;26050:129::-;;;;;;;;;;-1:-1:-1;26050:129:0;;;;;:::i;:::-;-1:-1:-1;;;;;26147:26:0;26124:7;26147:26;;;:18;:26;;;;;;;26050:129;70932:343;;;;;;;;;;-1:-1:-1;70932:343:0;;;;;:::i;:::-;;:::i;64628:56::-;;;;;;;;;;;;;;;9908:151;;;;;;;;;;-1:-1:-1;9908:151:0;;;;;:::i;:::-;-1:-1:-1;;;;;10024:18:0;;;9997:7;10024:18;;;-1:-1:-1;10024:18:0;;;;;;;;:27;;;;;;;;;;;;;9908:151;69306:460;;;;;;;;;;-1:-1:-1;69306:460:0;;;;;:::i;:::-;;:::i;66646:105::-;;;;;;;;;;-1:-1:-1;66725:18:0;;66646:105;;66216:422;;;;;;;;;;-1:-1:-1;66216:422:0;;;;;:::i;:::-;;:::i;3112:244::-;;;;;;;;;;-1:-1:-1;3112:244:0;;;;;:::i;:::-;;:::i;22117:29::-;;;;;;;;;;;;;;;;66888:1670;;;;;;;;;;-1:-1:-1;66888:1670:0;;;;;:::i;:::-;;:::i;69774:1150::-;;;;;;;;;;-1:-1:-1;69774:1150:0;;;;;:::i;:::-;;:::i;:::-;;;;13051:25:1;;;13107:2;13092:18;;13085:34;;;;13135:18;;;13128:34;13039:2;13024:18;69774:1150:0;13006:162:1;23161:393:0;23247:1;23231:13;9247:12;;;9159:108;23231:13;:17;23223:26;;;;;;23262:9;:13;23258:291;;23314:91;23383:13;9247:12;;;9159:108;23383:13;23354:26;23355:9;-1:-1:-1;;;23354:15:0;:26::i;:::-;:42;;;;:::i;:::-;23314:25;;;:29;:91::i;:::-;23286:25;:119;23419:43;;23452:9;11334:25:1;;23440:10:0;;23419:43;;11322:2:1;11307:18;23419:43:0;;;;;;;23501:25;;:40;;23531:9;23501:29;:40::i;:::-;23473:25;:68;23258:291;23161:393::o;8060:91::-;8105:13;8138:5;8131:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8060:91;:::o;10206:169::-;10289:4;10306:39;883:10;10329:7;10338:6;10306:8;:39::i;:::-;-1:-1:-1;10363:4:0;10206:169;;;;;:::o;10857:321::-;10963:4;10980:36;10990:6;10998:9;11009:6;10980:9;:36::i;:::-;11027:121;11036:6;883:10;11058:89;11096:6;11058:89;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;11058:19:0;;;;;;-1:-1:-1;11058:19:0;;;;;;;;883:10;11058:33;;;;;;;;;;:37;:89::i;:::-;11027:8;:121::i;:::-;-1:-1:-1;11166:4:0;10857:321;;;;;:::o;26620:247::-;-1:-1:-1;;;;;26796:36:0;;26697:7;26796:36;;;:28;:36;;;;;;;;;9431:18;;;;;;;26720:25;;-1:-1:-1;;;;26720:129:0;;:113;;:63;;:48;;:25;:29;:48::i;:::-;:61;:63::i;:::-;:75;;:113::i;:::-;:127;:129::i;:::-;:141;;;;:::i;65578:283::-;2231:6;;-1:-1:-1;;;;;2231:6:0;883:10;2378:23;2370:68;;;;-1:-1:-1;;;2370:68:0;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;65661:30:0;::::1;;::::0;;;:21:::1;:30;::::0;;;;;::::1;;65660:31;65652:40;;;::::0;::::1;;-1:-1:-1::0;;;;;65700:30:0;::::1;;::::0;;;:21:::1;:30;::::0;;;;:37;;-1:-1:-1;;65700:37:0::1;-1:-1:-1::0;65700:37:0::1;::::0;;65747:23:::1;::::0;65700:30;;65747:11:::1;:23::i;:::-;65778:31;::::0;-1:-1:-1;;;65778:31:0;;:15:::1;:31;::::0;::::1;11574:25:1::0;-1:-1:-1;;;;;11635:32:1;;11615:18;;;11608:60;65778:22:0::1;::::0;::::1;::::0;11547:18:1;;65778:31:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;65824:29:0::1;::::0;-1:-1:-1;;;;;65824:29:0;::::1;::::0;-1:-1:-1;65824:29:0::1;::::0;-1:-1:-1;65824:29:0;;::::1;65578:283:::0;:::o;23564:378::-;23647:1;23631:13;9247:12;;;9159:108;23631:13;:17;23623:26;;;;;;23662:10;;23658:279;;23711:88;23777:13;9247:12;;;9159:108;23777:13;23751:23;23752:6;-1:-1:-1;;;23751:12:0;:23::i;23711:88::-;23683:25;:116;23813:40;;11334:25:1;;;23834:10:0;;23813:40;;11322:2:1;11307:18;23813:40:0;;;;;;;23892:25;;:37;;23922:6;23892:29;:37::i;:::-;23864:25;:65;23658:279;23564:378;:::o;11587:218::-;883:10;11675:4;11724:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;11724:34:0;;;;;;;;;;11675:4;;11692:83;;11724:34;;:50;;11763:10;11724:38;:50::i;68566:505::-;68652:7;68674:6;68695;68716:7;68738;68760;68782;68804;68833:15;:20;;;;:22;;;;;;;;;;;;;11334:25:1;;11322:2;11307:18;;11289:76;68833:22:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;68824:5;:31;68821:137;;-1:-1:-1;68880:42:0;;-1:-1:-1;;;;;;;;68880:42:0;;-1:-1:-1;68880:42:0;;-1:-1:-1;68880:42:0;;-1:-1:-1;68880:42:0;;-1:-1:-1;68880:42:0;68872:74;;68821:137;68988:36;;-1:-1:-1;;;68988:36:0;;:15;:36;;;12588:25:1;12629:18;;;12622:34;;;68970:15:0;;68988:29;;;;12561:18:1;;68988:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;68970:54;;69044:19;69055:7;69044:10;:19::i;:::-;69037:26;;;;;;;;;;;;;;;;;68566:505;;;;;;;;;;:::o;65379:191::-;65439:123;;-1:-1:-1;;;65439:123:0;;8399:2:1;65439:123:0;;;8381:21:1;8438:3;8418:18;;;8411:31;8478:34;8458:18;;;8451:62;8549:34;8529:18;;;8522:62;8621:34;8600:19;;;8593:63;-1:-1:-1;;;8672:19:1;;;8665:40;8722:19;;65439:123:0;8371:376:1;2809:148:0;2231:6;;-1:-1:-1;;;;;2231:6:0;883:10;2378:23;2370:68;;;;-1:-1:-1;;;2370:68:0;;;;;;;:::i;:::-;2900:6:::1;::::0;2879:40:::1;::::0;2916:1:::1;::::0;-1:-1:-1;;;;;2900:6:0::1;::::0;2879:40:::1;::::0;2916:1;;2879:40:::1;2930:6;:19:::0;;-1:-1:-1;;;;;;2930:19:0::1;::::0;;2809:148::o;25334:124::-;25399:7;25422:30;25445:6;25422:22;:30::i;8270:95::-;8317:13;8350:7;8343:14;;;;;:::i;65881:327::-;2231:6;;-1:-1:-1;;;;;2231:6:0;883:10;2378:23;2370:68;;;;-1:-1:-1;;;2370:68:0;;;;;;;:::i;:::-;65997:14:::1;;65976:17;:35;;65968:115;;;::::0;-1:-1:-1;;;65968:115:0;;8954:2:1;65968:115:0::1;::::0;::::1;8936:21:1::0;8993:2;8973:18;;;8966:30;9032:34;9012:18;;;9005:62;9103:34;9083:18;;;9076:62;-1:-1:-1;;;9154:19:1;;;9147:34;9198:19;;65968:115:0::1;8926:297:1::0;65968:115:0::1;66140:14;::::0;66099:56:::1;::::0;66121:17;;66099:56:::1;::::0;;;::::1;66166:14;:34:::0;65881:327::o;12308:269::-;12401:4;12418:129;883:10;12441:7;12450:96;12489:15;12450:96;;;;;;;;;;;;;;;;;883:10;12450:25;;;;:11;:25;;;;;;;;-1:-1:-1;;;;;12450:34:0;;;;;;;;;;;;:38;:96::i;25669:168::-;-1:-1:-1;;;;;25804:26:0;;25746:7;25804:26;;;:18;:26;;;;;;25769:62;;:30;25804:26;25769:22;:30::i;:::-;:34;;:62::i;9670:175::-;9756:4;9773:42;883:10;9797:9;9808:6;9773:9;:42::i;70932:343::-;2231:6;;71023:4;;-1:-1:-1;;;;;2231:6:0;883:10;2378:23;2370:68;;;;-1:-1:-1;;;2370:68:0;;;;;;;:::i;:::-;71040:14:::1;71057:32;71081:7;71057:23;:32::i;:::-;71040:49:::0;-1:-1:-1;71102:10:0;;71099:147:::1;;-1:-1:-1::0;;;;;71123:23:0;::::1;;::::0;;;:14:::1;:23;::::0;;;;;;;;71149:15:::1;71123:41:::0;;71184:33;;11334:25:1;;;71184:33:0;::::1;;::::0;71123:23;71184:33:::1;::::0;11307:18:1;71184:33:0::1;;;;;;;71233:4;71226:11;;;;;71099:147;-1:-1:-1::0;71262:5:0::1;::::0;70932:343;-1:-1:-1;;;70932:343:0:o;69306:460::-;2231:6;;-1:-1:-1;;;;;2231:6:0;883:10;2378:23;2370:68;;;;-1:-1:-1;;;2370:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;69401:30:0;::::1;;::::0;;;:21:::1;:30;::::0;;;;;::::1;;69398:59;;;69306:460:::0;;:::o;69398:59::-:1;69483:31;69469:10;:45;69466:254;;69531:32;69543:7;69552:10;69531:11;:32::i;:::-;69572:40;::::0;-1:-1:-1;;;69572:40:0;;:15:::1;:40;::::0;::::1;12236:25:1::0;-1:-1:-1;;;;;12297:32:1;;12277:18;;;12270:60;12346:18;;;12339:34;;;69572:19:0::1;::::0;::::1;::::0;12209:18:1;;69572:40:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;69466:254;;;69648:23;69660:7;69669:1;69648:11;:23::i;:::-;69680:31;::::0;-1:-1:-1;;;69680:31:0;;:15:::1;:31;::::0;::::1;11574:25:1::0;-1:-1:-1;;;;;11635:32:1;;11615:18;;;11608:60;69680:22:0::1;::::0;::::1;::::0;11547:18:1;;69680:31:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;69466:254;69729:29;69744:7;69753:4;69729:14;:29::i;:::-;;69306:460:::0;;:::o;66216:422::-;2231:6;;-1:-1:-1;;;;;2231:6:0;883:10;2378:23;2370:68;;;;-1:-1:-1;;;2370:68:0;;;;;;;:::i;:::-;66317:4:::1;66301:12;:20;;:45;;;;;66341:5;66325:12;:21;;66301:45;66293:134;;;::::0;-1:-1:-1;;;66293:134:0;;6768:2:1;66293:134:0::1;::::0;::::1;6750:21:1::0;6807:2;6787:18;;;6780:30;6846:34;6826:18;;;6819:62;6917:34;6897:18;;;6890:62;-1:-1:-1;;;6968:19:1;;;6961:43;7021:19;;66293:134:0::1;6740:306:1::0;66293:134:0::1;66462:9;;66446:12;:25;;66438:100;;;::::0;-1:-1:-1;;;66438:100:0;;7609:2:1;66438:100:0::1;::::0;::::1;7591:21:1::0;7648:2;7628:18;;;7621:30;7687:34;7667:18;;;7660:62;7758:32;7738:18;;;7731:60;7808:19;;66438:100:0::1;7581:252:1::0;66438:100:0::1;66585:9;::::0;66554:41:::1;::::0;66571:12;;66554:41:::1;::::0;;;::::1;66606:9;:24:::0;66216:422::o;3112:244::-;2231:6;;-1:-1:-1;;;;;2231:6:0;883:10;2378:23;2370:68;;;;-1:-1:-1;;;2370:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;3201:22:0;::::1;3193:73;;;::::0;-1:-1:-1;;;3193:73:0;;5958:2:1;3193:73:0::1;::::0;::::1;5940:21:1::0;5997:2;5977:18;;;5970:30;6036:34;6016:18;;;6009:62;-1:-1:-1;;;6087:18:1;;;6080:36;6133:19;;3193:73:0::1;5930:228:1::0;3193:73:0::1;3303:6;::::0;3282:38:::1;::::0;-1:-1:-1;;;;;3282:38:0;;::::1;::::0;3303:6:::1;::::0;3282:38:::1;::::0;3303:6:::1;::::0;3282:38:::1;3331:6;:17:::0;;-1:-1:-1;;;;;;3331:17:0::1;-1:-1:-1::0;;;;;3331:17:0;;;::::1;::::0;;;::::1;::::0;;3112:244::o;66888:1670::-;67316:38;;-1:-1:-1;;;67316:38:0;;:15;:38;;;11574:25:1;-1:-1:-1;;;;;11635:32:1;;11615:18;;;11608:60;67287:8:0;;66970:15;;;;;;;;;;;;;;67316:29;;;;11547:18:1;;67316:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;67308:46;-1:-1:-1;;;;;;67412:10:0;;67409:582;;67459:18;;67450:5;67442:35;67439:541;;;67542:18;;67525:37;;:5;;:9;:37::i;:::-;67498:64;;67439:541;;;67681:18;;67651:15;:27;67616:32;;-1:-1:-1;67651:220:0;;67870:1;67651:220;;;67791:18;;67759:15;:27;:51;;:31;:51::i;:::-;67616:255;-1:-1:-1;67921:43:0;:5;67616:255;67921:9;:43::i;:::-;67894:70;;67439:541;;68029:31;68052:7;68029:22;:31::i;:::-;68005:55;;68088:31;68111:7;68088:22;:31::i;:::-;-1:-1:-1;;;;;68148:23:0;;;;;;:14;:23;;;;;;68071:48;;-1:-1:-1;68148:23:0;-1:-1:-1;68148:23:0;68200:126;;68325:1;68200:126;;;68275:9;;68257:28;;:13;;:17;:28::i;:::-;68184:142;;68388:15;68372:13;:31;:178;;68549:1;68372:178;;;68459:34;:13;68477:15;68459:17;:34::i;:::-;68339:211;;66888:1670;;;;;;;;;:::o;69774:1150::-;69886:15;:27;69820:7;;;;;;69926:25;69923:81;;-1:-1:-1;;69976:18:0;;69970:1;;-1:-1:-1;69970:1:0;;-1:-1:-1;69962:33:0;;69923:81;70043:18;;70013:27;;70118:9;70100:27;;70137:18;70167:14;70195:615;70211:3;70201:7;:13;:50;;;;;70231:20;70218:10;:33;70201:50;70195:615;;;70262:21;;;;:::i;:::-;70320:15;:27;70262:21;;-1:-1:-1;70297:50:0;;;-1:-1:-1;70294:98:0;;70381:1;70359:23;;70294:98;70402:15;70420;:20;;70441:19;70420:41;;;;;;-1:-1:-1;;;70420:41:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;70420:41:0;70488:23;;;:14;:23;;;;;;;;70420:41;;-1:-1:-1;70475:37:0;;:12;:37::i;:::-;70472:134;;;70527:38;70550:7;70560:4;70527:14;:38::i;:::-;70524:73;;;70578:8;;;;:::i;:::-;;;;70524:73;70616:12;;;;:::i;:::-;;;;70639:18;70660:9;70639:30;;70693:10;70683:7;:20;70680:91;;;70725:36;70737:23;:7;70749:10;70737:11;:23::i;:::-;70725:7;;:11;:36::i;:::-;70715:46;;70680:91;70791:10;-1:-1:-1;70195:615:0;;-1:-1:-1;70195:615:0;;70819:18;:40;;;70877:10;;-1:-1:-1;70889:6:0;-1:-1:-1;70840:19:0;;-1:-1:-1;;;;69774:1150:0;;;;;;:::o;42428:220::-;42486:7;42510:6;42506:20;;-1:-1:-1;42525:1:0;42518:8;;42506:20;42537:9;42549:5;42553:1;42549;:5;:::i;:::-;42537:17;-1:-1:-1;42582:1:0;42573:5;42577:1;42537:17;42573:5;:::i;:::-;:10;42565:56;;;;-1:-1:-1;;;42565:56:0;;9430:2:1;42565:56:0;;;9412:21:1;9469:2;9449:18;;;9442:30;9508:34;9488:18;;;9481:62;-1:-1:-1;;;9559:18:1;;;9552:31;9600:19;;42565:56:0;9402:223:1;42565:56:0;42639:1;42428:220;-1:-1:-1;;;42428:220:0:o;41549:179::-;41607:7;;41639:5;41643:1;41639;:5;:::i;:::-;41627:17;;41668:1;41663;:6;;41655:46;;;;-1:-1:-1;;;41655:46:0;;7253:2:1;41655:46:0;;;7235:21:1;7292:2;7272:18;;;7265:30;7331:29;7311:18;;;7304:57;7378:18;;41655:46:0;7225:177:1;15455:346:0;-1:-1:-1;;;;;15557:19:0;;15549:68;;;;-1:-1:-1;;;15549:68:0;;10595:2:1;15549:68:0;;;10577:21:1;10634:2;10614:18;;;10607:30;10673:34;10653:18;;;10646:62;-1:-1:-1;;;10724:18:1;;;10717:34;10768:19;;15549:68:0;10567:226:1;15549:68:0;-1:-1:-1;;;;;15636:21:0;;15628:68;;;;-1:-1:-1;;;15628:68:0;;6365:2:1;15628:68:0;;;6347:21:1;6404:2;6384:18;;;6377:30;6443:34;6423:18;;;6416:62;-1:-1:-1;;;6494:18:1;;;6487:32;6536:19;;15628:68:0;6337:224:1;15628:68:0;-1:-1:-1;;;;;15709:18:0;;;;;;;-1:-1:-1;15709:18:0;;;;;;;;:27;;;;;;;;;;;;;:36;;;15761:32;;11334:25:1;;;15761:32:0;;;;;;;;;;;;15455:346;;;:::o;65220:151::-;65300:63;;-1:-1:-1;;;65300:63:0;;5544:2:1;65300:63:0;;;5526:21:1;5583:2;5563:18;;;5556:30;5622:34;5602:18;;;5595:62;-1:-1:-1;;;5673:18:1;;;5666:43;5726:19;;65300:63:0;5516:235:1;44376:166:0;44462:7;44498:12;44490:6;;;;44482:29;;;;-1:-1:-1;;;44482:29:0;;;;;;;;:::i;:::-;-1:-1:-1;44529:5:0;44533:1;44529;:5;:::i;:::-;44522:12;44376:166;-1:-1:-1;;;;44376:166:0:o;47741:134::-;47797:6;47830:1;47847:6;;;;47839:15;;;;;47324:162;47380:6;;47406:5;47410:1;47406;:5;:::i;:::-;47395:16;;47432:1;47427;:6;;:16;;;;;47442:1;47437;:6;;47427:16;47426:38;;;;47453:1;47449;:5;:14;;;;;47462:1;47458;:5;47449:14;47418:47;;;;;47492:117;47548:7;47577:1;47572;:6;;47564:15;;;;;;-1:-1:-1;47601:1:0;47492:117::o;28625:407::-;-1:-1:-1;;;;;9431:18:0;;28699:22;9431:18;;;;;;;;;;;28754:27;;;28751:276;;;28792:18;28813:30;:10;28828:14;28813;:30::i;:::-;28792:51;;28852:26;28858:7;28867:10;28852:5;:26::i;:::-;28751:276;69729:29:::1;69306:460:::0;;:::o;28751:276::-;28908:14;28895:10;:27;28892:135;;;28933:18;28954:30;:14;28973:10;28954:18;:30::i;:::-;28933:51;;28993:26;28999:7;29008:10;28993:5;:26::i;42011:158::-;42069:7;42102:1;42097;:6;;42089:49;;;;-1:-1:-1;;;42089:49:0;;8040:2:1;42089:49:0;;;8022:21:1;8079:2;8059:18;;;8052:30;8118:32;8098:18;;;8091:60;8168:18;;42089:49:0;8012:180:1;42089:49:0;42156:5;42160:1;42156;:5;:::i;24494:627::-;24567:7;24583:29;24615:28;24638:4;24615:22;:28::i;:::-;24583:60;-1:-1:-1;24654:25:0;;24650:449;;-1:-1:-1;;;;;24717:24:0;;;;;;:18;:24;;;;;;:51;;24746:21;24717:28;:51::i;:::-;-1:-1:-1;;;;;24690:24:0;;;;;;:18;:24;;;;;;;;;:78;;;;24782:46;11334:25:1;;;24690:24:0;;24782:46;;11307:18:1;24782:46:0;;;;;;;24859:13;;24852:59;;-1:-1:-1;;;24852:59:0;;-1:-1:-1;;;;;3749:32:1;;;24852:59:0;;;3731:51:1;3798:18;;;3791:34;;;24837:12:0;;24859:13;;24852:30;;3704:18:1;;24852:59:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;24837:74;;24926:7;24922:131;;-1:-1:-1;;;;;24973:24:0;;;;;;:18;:24;;;;;;:51;;25002:21;24973:28;:51::i;:::-;-1:-1:-1;;;;;24946:24:0;;;;;;;;:18;:24;;;;;:78;;;;-1:-1:-1;24946:24:0;;;-1:-1:-1;;24494:627:0:o;24922:131::-;-1:-1:-1;25070:21:0;24494:627;-1:-1:-1;;24494:627:0:o;24650:449::-;-1:-1:-1;25114:1:0;;24494:627;-1:-1:-1;;24494:627:0:o;47165:153::-;47221:6;47250:1;47245;:6;;:20;;;;-1:-1:-1;47264:1:0;47255:5;47259:1;47264;47255:5;:::i;:::-;:10;;47245:20;47244:46;;;;47275:1;47271;:5;:18;;;;-1:-1:-1;47288:1:0;47280:5;47284:1;47288;47280:5;:::i;:::-;:9;47271:18;47236:55;;;;;;47307:5;47311:1;47307;:5;:::i;69079:219::-;69146:4;69179:15;69163:13;:31;69160:67;;;-1:-1:-1;69213:5:0;;69079:219;-1:-1:-1;69079:219:0:o;69160:67::-;69281:9;;69243:34;:15;69263:13;69243:19;:34::i;:::-;:47;;;69079:219;-1:-1:-1;;69079:219:0:o;27824:260::-;27896:27;27908:7;27917:5;27896:11;:27::i;:::-;27972:106;28023:53;28024:36;28054:5;28024:25;;:29;;:36;;;;:::i;28023:53::-;-1:-1:-1;;;;;27972:37:0;;;;;;:28;:37;;;;;;;:49;:106::i;:::-;-1:-1:-1;;;;;27932:37:0;;;;;;;;:28;:37;;;;;:146;;;;-1:-1:-1;27824:260:0:o;28359:::-;28431:27;28443:7;28452:5;28431:11;:27::i;:::-;28507:106;28558:53;28559:36;28589:5;28559:25;;:29;;:36;;;;:::i;28558:53::-;-1:-1:-1;;;;;28507:37:0;;;;;;:28;:37;;;;;;;:49;:106::i;13888:378::-;-1:-1:-1;;;;;13972:21:0;;13964:65;;;;-1:-1:-1;;;13964:65:0;;11000:2:1;13964:65:0;;;10982:21:1;11039:2;11019:18;;;11012:30;11078:33;11058:18;;;11051:61;11129:18;;13964:65:0;10972:181:1;13964:65:0;14119:12;;:24;;14136:6;14119:16;:24::i;:::-;14104:12;:39;-1:-1:-1;;;;;14175:18:0;;:9;:18;;;;;;;;;;;:30;;14198:6;14175:22;:30::i;:::-;-1:-1:-1;;;;;14154:18:0;;:9;:18;;;;;;;;;;;:51;;;;14221:37;;11334:25:1;;;14154:18:0;;:9;;14221:37;;11307:18:1;14221:37:0;;;;;;;;13888:378;;:::o;14599:418::-;-1:-1:-1;;;;;14683:21:0;;14675:67;;;;-1:-1:-1;;;14675:67:0;;10193:2:1;14675:67:0;;;10175:21:1;10232:2;10212:18;;;10205:30;10271:34;10251:18;;;10244:62;-1:-1:-1;;;10322:18:1;;;10315:31;10363:19;;14675:67:0;10165:223:1;14675:67:0;14838:68;14861:6;14838:68;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;14838:18:0;;:9;:18;;;;;;;;;;;;;:22;:68::i;:::-;-1:-1:-1;;;;;14817:18:0;;:9;:18;;;;;;;;;;:89;14932:12;;:24;;14949:6;14932:16;:24::i;:::-;14917:12;:39;14972:37;;11334:25:1;;;14998:1:0;;-1:-1:-1;;;;;14972:37:0;;;;;11322:2:1;11307:18;14972:37:0;11289:76:1;14:257;73:6;126:2;114:9;105:7;101:23;97:32;94:2;;;147:6;139;132:22;94:2;191:9;178:23;210:31;235:5;210:31;:::i;276:261::-;346:6;399:2;387:9;378:7;374:23;370:32;367:2;;;420:6;412;405:22;367:2;457:9;451:16;476:31;501:5;476:31;:::i;542:400::-;615:6;623;676:2;664:9;655:7;651:23;647:32;644:2;;;697:6;689;682:22;644:2;741:9;728:23;760:31;785:5;760:31;:::i;:::-;810:5;-1:-1:-1;867:2:1;852:18;;839:32;880:30;839:32;880:30;:::i;:::-;929:7;919:17;;;634:308;;;;;:::o;947:333::-;1023:6;1031;1084:2;1072:9;1063:7;1059:23;1055:32;1052:2;;;1105:6;1097;1090:22;1052:2;1149:9;1136:23;1168:31;1193:5;1168:31;:::i;:::-;1218:5;1270:2;1255:18;;;;1242:32;;-1:-1:-1;;;1042:238:1:o;1285:398::-;1353:6;1361;1414:2;1402:9;1393:7;1389:23;1385:32;1382:2;;;1435:6;1427;1420:22;1382:2;1479:9;1466:23;1498:31;1523:5;1498:31;:::i;:::-;1548:5;-1:-1:-1;1605:2:1;1590:18;;1577:32;1618:33;1577:32;1618:33;:::i;1688:466::-;1765:6;1773;1781;1834:2;1822:9;1813:7;1809:23;1805:32;1802:2;;;1855:6;1847;1840:22;1802:2;1899:9;1886:23;1918:31;1943:5;1918:31;:::i;:::-;1968:5;-1:-1:-1;2025:2:1;2010:18;;1997:32;2038:33;1997:32;2038:33;:::i;:::-;1792:362;;2090:7;;-1:-1:-1;;;2144:2:1;2129:18;;;;2116:32;;1792:362::o;2489:255::-;2556:6;2609:2;2597:9;2588:7;2584:23;2580:32;2577:2;;;2630:6;2622;2615:22;2577:2;2667:9;2661:16;2686:28;2708:5;2686:28;:::i;2749:193::-;2818:6;2871:2;2859:9;2850:7;2846:23;2842:32;2839:2;;;2892:6;2884;2877:22;2839:2;-1:-1:-1;2920:16:1;;2829:113;-1:-1:-1;2829:113:1:o;2947:190::-;3006:6;3059:2;3047:9;3038:7;3034:23;3030:32;3027:2;;;3080:6;3072;3065:22;3027:2;-1:-1:-1;3108:23:1;;3017:120;-1:-1:-1;3017:120:1:o;4734:603::-;4846:4;4875:2;4904;4893:9;4886:21;4936:6;4930:13;4979:6;4974:2;4963:9;4959:18;4952:34;5004:4;5017:140;5031:6;5028:1;5025:13;5017:140;;;5126:14;;;5122:23;;5116:30;5092:17;;;5111:2;5088:26;5081:66;5046:10;;5017:140;;;5175:6;5172:1;5169:13;5166:2;;;5245:4;5240:2;5231:6;5220:9;5216:22;5212:31;5205:45;5166:2;-1:-1:-1;5321:2:1;5300:15;-1:-1:-1;;5296:29:1;5281:45;;;;5328:2;5277:54;;4855:482;-1:-1:-1;;;4855:482:1:o;9630:356::-;9832:2;9814:21;;;9851:18;;;9844:30;9910:34;9905:2;9890:18;;9883:62;9977:2;9962:18;;9804:182::o;13362:267::-;13401:3;13429:11;;;-1:-1:-1;;;;;13475:27:1;;;13468:35;;13456:10;;13452:52;13449:2;;;13507:18;;:::i;:::-;-1:-1:-1;;;13554:19:1;;;13547:27;;13539:36;;13536:2;;;13578:18;;:::i;:::-;-1:-1:-1;;13614:9:1;;13409:220::o;13634:128::-;13674:3;13705:1;13701:6;13698:1;13695:13;13692:2;;;13711:18;;:::i;:::-;-1:-1:-1;13747:9:1;;13682:80::o;13767:217::-;13807:1;13833;13823:2;;-1:-1:-1;;;13858:31:1;;13912:4;13909:1;13902:15;13940:4;13858:31;13930:15;13823:2;-1:-1:-1;13969:9:1;;13813:171::o;13989:168::-;14029:7;14095:1;14091;14087:6;14083:14;14080:1;14077:21;14072:1;14065:9;14058:17;14054:45;14051:2;;;14102:18;;:::i;:::-;-1:-1:-1;14142:9:1;;14041:116::o;14162:270::-;14201:4;14230:12;;;-1:-1:-1;;;14277:19:1;;14270:27;;14258:10;;14254:44;14251:2;;;14301:18;;:::i;:::-;-1:-1:-1;;;;;14348:27:1;;14341:35;;14333:44;;14330:2;;;14380:18;;:::i;:::-;-1:-1:-1;;14417:9:1;;14210:222::o;14437:125::-;14477:4;14505:1;14502;14499:8;14496:2;;;14510:18;;:::i;:::-;-1:-1:-1;14547:9:1;;14486:76::o;14567:380::-;14646:1;14642:12;;;;14689;;;14710:2;;14764:4;14756:6;14752:17;14742:27;;14710:2;14817;14809:6;14806:14;14786:18;14783:38;14780:2;;;14863:10;14858:3;14854:20;14851:1;14844:31;14898:4;14895:1;14888:15;14926:4;14923:1;14916:15;14780:2;;14622:325;;;:::o;14952:135::-;14991:3;-1:-1:-1;;15012:17:1;;15009:2;;;15032:18;;:::i;:::-;-1:-1:-1;15079:1:1;15068:13;;14999:88::o;15092:127::-;15153:10;15148:3;15144:20;15141:1;15134:31;15184:4;15181:1;15174:15;15208:4;15205:1;15198:15;15224:131;-1:-1:-1;;;;;15299:31:1;;15289:42;;15279:2;;15345:1;15342;15335:12;15360:118;15446:5;15439:13;15432:21;15425:5;15422:32;15412:2;;15468:1;15465;15458:12
Swarm Source
ipfs://4ae3db7679aab0c02330100588886fad979aae08829b63dba1f8c5e98037d9f7
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.