Token

Earnator_Dividend_Tracker (Earnator_Dividend_Tracker)

ERC-20

Overview

Max Total Supply

1,513,200.25426843030938077 Earnator_Dividend_Tracker

Holders

119

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0xbd02d57f1fe9434cbca812fba4203235de8de25b

Filtered by Token Holder

0xD192CD5F45caC89AD2735305382D2B5318358dBC

Balance

0.649883354968752489 Earnator_Dividend_Tracker

Value

$0.00

0xd192cd5f45cac89ad2735305382d2b5318358dbc

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

EarnatorDividendTracker

Compiler Version

v0.8.21+commit.d9974bed

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2024-03-02
*/

/**
 *Submitted for verification at Etherscan.io on 2023-09-03
*/

// SPDX-License-Identifier: MIT

/**
 An easy-to-use App that lets you earn rewards.
 Telegram : https://t.me/earnator
 Website : https://www.earnator.xyz/
 Twitter : https://twitter.com/earnatorxyz
 X : https://twitter.com/earnatorxyz
 
*/
pragma solidity ^0.8.15;

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}
interface IERC20 {
    /**
     * @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 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 `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 `from` to `to` 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 from, address to, uint256 amount) external returns (bool);
}

interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }
    function name() public view virtual override returns (string memory) {
        return _name;
    }
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    function _transfer(address from, address to, uint256 amount) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}

    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}

library SafeMath {
    /**
     * @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) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * 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);
        uint256 c = a - b;

        return c;
    }

    /**
     * @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) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts 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) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message 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, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts 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) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message 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, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

library SafeMathInt {
    int256 private constant MIN_INT256 = int256(1) << 255;
    int256 private constant MAX_INT256 = ~(int256(1) << 255);

    /**
     * @dev Multiplies two int256 variables and fails on overflow.
     */
    function mul(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a * b;

        // Detect overflow when multiplying MIN_INT256 with -1
        require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256));
        require((b == 0) || (c / b == a));
        return c;
    }

    /**
     * @dev Division of two int256 variables and fails on overflow.
     */
    function div(int256 a, int256 b) internal pure returns (int256) {
        // Prevent overflow when dividing MIN_INT256 by -1
        require(b != -1 || a != MIN_INT256);

        // Solidity already throws when dividing by 0.
        return a / b;
    }

    /**
     * @dev Subtracts two int256 variables and fails on overflow.
     */
    function sub(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a - b;
        require((b >= 0 && c <= a) || (b < 0 && c > a));
        return c;
    }

    /**
     * @dev Adds two int256 variables and fails on overflow.
     */
    function add(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a + b;
        require((b >= 0 && c >= a) || (b < 0 && c < a));
        return c;
    }

    /**
     * @dev Converts to absolute value, and fails on overflow.
     */
    function abs(int256 a) internal pure returns (int256) {
        require(a != MIN_INT256);
        return a < 0 ? -a : a;
    }


    function toUint256Safe(int256 a) internal pure returns (uint256) {
        require(a >= 0);
        return uint256(a);
    }
}

library SafeMathUint {
  function toInt256Safe(uint256 a) internal pure returns (int256) {
    int256 b = int256(a);
    require(b >= 0);
    return b;
  }
}

interface DividendPayingTokenInterface {
  /// @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 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;
  
  /// @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);


  /// @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
  );
  
}

interface IPair {
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function token0() external view returns (address);

}

interface IFactory{
        function createPair(address tokenA, address tokenB) external returns (address pair);
        function getPair(address tokenA, address tokenB) external view returns (address pair);
}

interface IUniswapRouter {
    function factory() external pure returns (address);
    function WETH() external pure returns (address);
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
    
    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;
    
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline) external;
}

contract DividendPayingToken is ERC20, DividendPayingTokenInterface, Ownable {

  using SafeMath for uint256;
  using SafeMathUint for uint256;
  using SafeMathInt for int256;

  address public LP_Token;


  // 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;

  // 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 totalDividendsWithdrawn;

  constructor(string memory _name, string memory _symbol) ERC20(_name, _symbol) {}

  function distributeLPDividends(uint256 amount) public onlyOwner{
    require(totalSupply() > 0);

    if (amount > 0) {
      magnifiedDividendPerShare = magnifiedDividendPerShare.add(
        (amount).mul(magnitude) / totalSupply()
      );
      emit DividendsDistributed(msg.sender, amount);

      totalDividendsDistributed = totalDividendsDistributed.add(amount);
    }
  }

  /// @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));
  }

  /// @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);
      totalDividendsWithdrawn += _withdrawableDividend;
      emit DividendWithdrawn(user, _withdrawableDividend);
      bool success = IERC20(LP_Token).transfer(user, _withdrawableDividend);

      if(!success) {
        withdrawnDividends[user] = withdrawnDividends[user].sub(_withdrawableDividend);
        totalDividendsWithdrawn -= _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);
    }
  }
}

contract EARNATOR_OFFICIAL is ERC20, Ownable {
    IUniswapRouter public router;
    address public pair;

    bool private swapping;
    bool public swapEnabled = true;
    bool public claimEnabled;
    bool public tradingEnabled;

    EarnatorDividendTracker public dividendTracker;

    address public devWallet;

    uint256 public swapTokensAtAmount;
    uint256 public maxBuyAmount;
    uint256 public maxSellAmount;
    uint256 public maxWallet;

    struct Taxes {
        uint256 liquidity;
        uint256 dev;
    }

    Taxes public buyTaxes = Taxes(2, 2);
    Taxes public sellTaxes = Taxes(2, 2);

    uint256 public totalBuyTax = 4;
    uint256 public totalSellTax = 4;

    mapping(address => bool) public _isBot;

    mapping(address => bool) private _isExcludedFromFees;
    mapping(address => bool) public automatedMarketMakerPairs;
    mapping(address => bool) private _isExcludedFromMaxWallet;

    ///////////////
    //   Events  //
    ///////////////

    event ExcludeFromFees(address indexed account, bool isExcluded);
    event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);
    event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
    event GasForProcessingUpdated(
        uint256 indexed newValue,
        uint256 indexed oldValue
    );
    event SendDividends(uint256 tokensSwapped, uint256 amount);
    event ProcessedDividendTracker(
        uint256 iterations,
        uint256 claims,
        uint256 lastProcessedIndex,
        bool indexed automatic,
        uint256 gas,
        address indexed processor
    );

    constructor(address _developerwallet) ERC20("EARNATOR", "EARN") {
        dividendTracker = new EarnatorDividendTracker();
        setDevWallet(_developerwallet);

        IUniswapRouter _router = IUniswapRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
        address _pair = IFactory(_router.factory()).createPair(
            address(this),
            _router.WETH()
        );

        router = _router;
        pair = _pair;
        setSwapTokensAtAmount(30000); //
        updateMaxWalletAmount(100000);
        setMaxBuyAndSell(100000, 100000);
        

        _setAutomatedMarketMakerPair(_pair, true);

        dividendTracker.updateLP_Token(pair);

        dividendTracker.excludeFromDividends(address(dividendTracker), true);
        dividendTracker.excludeFromDividends(address(this), true);
        dividendTracker.excludeFromDividends(owner(), true);
        dividendTracker.excludeFromDividends(address(0xdead), true);
        dividendTracker.excludeFromDividends(address(_router), true);

        excludeFromMaxWallet(address(_pair), true);
        excludeFromMaxWallet(address(this), true);
        excludeFromMaxWallet(address(_router), true);

        excludeFromFees(owner(), true);
        excludeFromFees(address(this), true);

        _mint(owner(), 10000000 * (10**18));
    }

    receive() external payable {}

    function updateDividendTracker(address newAddress) public onlyOwner {
        EarnatorDividendTracker newDividendTracker = EarnatorDividendTracker(
            payable(newAddress)
        );
        newDividendTracker.excludeFromDividends(
            address(newDividendTracker),
            true
        );
        newDividendTracker.excludeFromDividends(address(this), true);
        newDividendTracker.excludeFromDividends(owner(), true);
        newDividendTracker.excludeFromDividends(address(router), true);
        dividendTracker = newDividendTracker;
    }

    /// @notice Manual claim the dividends
    function claim() external {
        require(claimEnabled, "Claim not enabled");
        dividendTracker.processAccount(payable(msg.sender));
    }

    function updateMaxWalletAmount(uint256 newNum) public onlyOwner {
        require(newNum >= 100_000, "Cannot set maxWallet lower than 1%");
        maxWallet = newNum * 10**18;
    }

    function setMaxBuyAndSell(uint256 maxBuy, uint256 maxSell)
        public
        onlyOwner
    {
        require(maxBuy >= 25_000, "Cannot set maxbuy lower than 0.25% ");
        require(maxSell >= 25_000, "Cannot set maxsell lower than 0.25% ");
        maxBuyAmount = maxBuy * 10**18;
        maxSellAmount = maxSell * 10**18;
    }

    function setSwapTokensAtAmount(uint256 amount) public onlyOwner {
        swapTokensAtAmount = amount * 10**18;
    }

    function excludeFromMaxWallet(address account, bool excluded)
        public
        onlyOwner
    {
        _isExcludedFromMaxWallet[account] = excluded;
    }

    /// @notice Withdraw tokens sent by mistake.
    /// @param tokenAddress The address of the token to withdraw
    function rescueETH20Tokens(address tokenAddress) external onlyOwner {
        IERC20(tokenAddress).transfer(
            owner(),
            IERC20(tokenAddress).balanceOf(address(this))
        );
    }

    /// @notice Send remaining ETH to dev
    /// @dev It will send all ETH to dev
    function forceSend() external onlyOwner {
        uint256 ETHbalance = address(this).balance;
        (bool success, ) = payable(devWallet).call{value: ETHbalance}("");
        require(success);
    }

    function trackerRescueETH20Tokens(address tokenAddress) external onlyOwner {
        dividendTracker.trackerRescueETH20Tokens(msg.sender, tokenAddress);
    }

    function updateRouter(address newRouter) external onlyOwner {
        router = IUniswapRouter(newRouter);
    }

    /////////////////////////////////
    // Exclude / Include functions //
    /////////////////////////////////

    function excludeFromFees(address account, bool excluded) public onlyOwner {
        require(
            _isExcludedFromFees[account] != excluded,
            "Account is already the value of 'excluded'"
        );
        _isExcludedFromFees[account] = excluded;

        emit ExcludeFromFees(account, excluded);
    }

    /// @dev "true" to exlcude, "false" to include
    function excludeFromDividends(address account, bool value)
        public
        onlyOwner
    {
        dividendTracker.excludeFromDividends(account, value);
    }

    function setDevWallet(address newWallet) public onlyOwner {
        devWallet = newWallet;
    }

    function setBuyTaxes(uint256 _liquidity, uint256 _dev) public onlyOwner {
        require(_liquidity + _dev <= 25, "Fee must be <= 25%");
        buyTaxes = Taxes(_liquidity, _dev);
        totalBuyTax = _liquidity + _dev;
    }

    function setSellTaxes(uint256 _liquidity, uint256 _dev) public  onlyOwner {
        require(_liquidity <= 25, "Fee must be <= 25%");
        sellTaxes = Taxes(_liquidity, _dev);
        totalSellTax = _liquidity + _dev;
    }

    /// @notice Enable or disable internal swaps
    /// @dev Set "true" to enable internal swaps for liquidity, treasury and dividends
    function setSwapEnabled(bool _enabled) external onlyOwner {
        swapEnabled = _enabled;
    }

    function activateTrading() external onlyOwner {
        require(!tradingEnabled, "Trading already enabled");
        tradingEnabled = true;
        setBuyTaxes(5,20);
        setSellTaxes(5,20);
        // transfer(address(this), 1000000);
    }

    function setClaimEnabled(bool state) external onlyOwner {
        claimEnabled = state;
    }

    /// @param bot The bot address
    /// @param value "true" to blacklist, "false" to unblacklist
    function setBot(address bot, bool value) external onlyOwner {
        require(_isBot[bot] != value);
        _isBot[bot] = value;
    }

    function setLP_Token(address _lpToken) external onlyOwner {
        dividendTracker.updateLP_Token(_lpToken);
    }

    /// @dev Set new pairs created due to listing in new DEX
    function setAutomatedMarketMakerPair(address newPair, bool value)
        external
        onlyOwner
    {
        _setAutomatedMarketMakerPair(newPair, value);
    }

    function _setAutomatedMarketMakerPair(address newPair, bool value) private {
        require(
            automatedMarketMakerPairs[newPair] != value,
            "Automated market maker pair is already set to that value"
        );
        automatedMarketMakerPairs[newPair] = value;

        if (value) {
            dividendTracker.excludeFromDividends(newPair, true);
        }

        emit SetAutomatedMarketMakerPair(newPair, value);
    }

    //////////////////////
    // Getter Functions //
    //////////////////////

    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 getAccountInfo(address account)
        external
        view
        returns (
            address,
            uint256,
            uint256,
            uint256,
            uint256
        )
    {
        return dividendTracker.getAccount(account);
    }

    ////////////////////////
    // Transfer Functions //
    ////////////////////////

    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal override {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        if (
            !_isExcludedFromFees[from] && !_isExcludedFromFees[to] && !swapping
        ) {
            require(tradingEnabled, "Trading not active");
            if (automatedMarketMakerPairs[to]) {
                require(
                    amount <= maxSellAmount,
                    "You are exceeding maxSellAmount"
                );
            } else if (automatedMarketMakerPairs[from])
                require(
                    amount <= maxBuyAmount,
                    "You are exceeding maxBuyAmount"
                );
            if (!_isExcludedFromMaxWallet[to]) {
                require(
                    amount + balanceOf(to) <= maxWallet,
                    "Unable to exceed Max Wallet"
                );
            }
        }

        if (amount == 0) {
            super._transfer(from, to, 0);
            return;
        }

        uint256 contractTokenBalance = balanceOf(address(this));
        bool canSwap = contractTokenBalance >= swapTokensAtAmount;

        if (
            canSwap &&
            !swapping &&
            swapEnabled &&
            automatedMarketMakerPairs[to] &&
            !_isExcludedFromFees[from] &&
            !_isExcludedFromFees[to]
        ) {
            swapping = true;

            if (totalSellTax > 0) {
                swapAndLiquify(swapTokensAtAmount);
            }

            swapping = false;
        }

        bool takeFee = !swapping;

        // if any account belongs to _isExcludedFromFee account then remove the fee
        if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
            takeFee = false;
        }

        if (!automatedMarketMakerPairs[to] && !automatedMarketMakerPairs[from])
            takeFee = false;

        if (takeFee) {
            uint256 feeAmt;
            if (automatedMarketMakerPairs[to])
                feeAmt = (amount * totalSellTax) / 100;
            else if (automatedMarketMakerPairs[from])
                feeAmt = (amount * totalBuyTax) / 100;

            amount = amount - feeAmt;
            super._transfer(from, address(this), feeAmt);
        }
        super._transfer(from, to, amount);

        try dividendTracker.setBalance(from, balanceOf(from)) {} catch {}
        try dividendTracker.setBalance(to, balanceOf(to)) {} catch {}
    }

    function swapAndLiquify(uint256 tokens) private {
        uint256 toSwapForLiq = ((tokens * sellTaxes.liquidity) / totalSellTax) / 2;
        uint256 tokensToAddLiquidityWith = ((tokens * sellTaxes.liquidity) / totalSellTax) / 2;
        uint256 toSwapForDev = (tokens * sellTaxes.dev) / totalSellTax;

        swapTokensForETH(toSwapForLiq);

        uint256 currentbalance = address(this).balance;

        if (currentbalance > 0) {
            // Add liquidity to uni
            addLiquidity(tokensToAddLiquidityWith, currentbalance);
        }

        swapTokensForETH(toSwapForDev);

        uint256 EthTaxBalance = address(this).balance;

        // Send ETH to dev
        uint256 devAmt = EthTaxBalance;

        if (devAmt > 0) {
            (bool success, ) = payable(devWallet).call{value: devAmt}("");
            require(success, "Failed to send ETH to dev wallet");
        }

        uint256 lpBalance = IERC20(pair).balanceOf(address(this));

        //Send LP to dividends
        uint256 dividends = lpBalance;

        if (dividends > 0) {
            bool success = IERC20(pair).transfer(
                address(dividendTracker),
                dividends
            );
            if (success) {
                dividendTracker.distributeLPDividends(dividends);
                emit SendDividends(tokens, dividends);
            }
        }
    }

    // transfers LP from the owners wallet to holders // must approve this contract, on pair contract before calling
    function ManualLiquidityDistribution(uint256 amount) public onlyOwner {
        bool success = IERC20(pair).transferFrom(
            msg.sender,
            address(dividendTracker),
            amount
        );
        if (success) {
            dividendTracker.distributeLPDividends(amount);
        }
    }

    function swapTokensForETH(uint256 tokenAmount) private {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = router.WETH();

        _approve(address(this), address(router), tokenAmount);

        // make the swap
        router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0, // accept any amount of ETH
            path,
            address(this),
            block.timestamp
        );
    }

    function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
        // approve token transfer to cover all possible scenarios
        _approve(address(this), address(router), tokenAmount);

        // add the liquidity
        router.addLiquidityETH{value: ethAmount}(
            address(this),
            tokenAmount,
            0, // slippage is unavoidable
            0, // slippage is unavoidable
            address(this),
            block.timestamp
        );
    }
}

contract EarnatorDividendTracker is Ownable, DividendPayingToken {
    struct AccountInfo {
        address account;
        uint256 withdrawableDividends;
        uint256 totalDividends;
        uint256 lastClaimTime;
    }

    mapping(address => bool) public excludedFromDividends;

    mapping(address => uint256) public lastClaimTimes;

    event ExcludeFromDividends(address indexed account, bool value);
    event Claim(address indexed account, uint256 amount);

    constructor()
        DividendPayingToken("Earnator_Dividend_Tracker", "Earnator_Dividend_Tracker")
    {}

    function trackerRescueETH20Tokens(address recipient, address tokenAddress)
        external
        onlyOwner
    {
        IERC20(tokenAddress).transfer(
            recipient,
            IERC20(tokenAddress).balanceOf(address(this))
        );
    }

    function updateLP_Token(address _lpToken) external onlyOwner {
        LP_Token = _lpToken;
    }

    function _transfer(
        address,
        address,
        uint256
    ) internal pure override {
        require(false, "Linq_Dividend_Tracker: No transfers allowed");
    }

    function excludeFromDividends(address account, bool value)
        external
        onlyOwner
    {
        require(excludedFromDividends[account] != value);
        excludedFromDividends[account] = value;
        if (value == true) {
            _setBalance(account, 0);
        } else {
            _setBalance(account, balanceOf(account));
        }
        emit ExcludeFromDividends(account, value);
    }

    function getAccount(address account)
        public
        view
        returns (
            address,
            uint256,
            uint256,
            uint256,
            uint256
        )
    {
        AccountInfo memory info;
        info.account = account;
        info.withdrawableDividends = withdrawableDividendOf(account);
        info.totalDividends = accumulativeDividendOf(account);
        info.lastClaimTime = lastClaimTimes[account];
        return (
            info.account,
            info.withdrawableDividends,
            info.totalDividends,
            info.lastClaimTime,
            totalDividendsWithdrawn
        );
    }

    function setBalance(address account, uint256 newBalance)
        external
        onlyOwner
    {
        if (excludedFromDividends[account]) {
            return;
        }
        _setBalance(account, newBalance);
    }

    function processAccount(address payable account)
        external
        onlyOwner
        returns (bool)
    {
        uint256 amount = _withdrawDividendOfUser(account);

        if (amount > 0) {
            lastClaimTimes[account] = block.timestamp;
            emit Claim(account, amount);
            return true;
        }
        return false;
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"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"}],"name":"Claim","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"},{"indexed":false,"internalType":"bool","name":"value","type":"bool"}],"name":"ExcludeFromDividends","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"LP_Token","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"accumulativeDividendOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"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":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"distributeLPDividends","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"dividendOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"value","type":"bool"}],"name":"excludeFromDividends","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"excludedFromDividends","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getAccount","outputs":[{"internalType":"address","name":"","type":"address"},{"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":[{"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":"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":"address payable","name":"account","type":"address"}],"name":"processAccount","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"newBalance","type":"uint256"}],"name":"setBalance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalDividendsDistributed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalDividendsWithdrawn","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":"address","name":"tokenAddress","type":"address"}],"name":"trackerRescueETH20Tokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","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":"address","name":"_lpToken","type":"address"}],"name":"updateLP_Token","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawDividend","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"withdrawableDividendOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"withdrawnDividendOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

44055:2896:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45226:421;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;6058:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6988:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;21758:23;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6377:108;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44355:49;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7197:261;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;26424:247;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6276:93;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7466:238;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44928:99;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;44660:260;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;44293:53;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;23910:109;;;:::i;:::-;;6493:127;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1808:103;;;:::i;:::-;;46578:370;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;23176:40;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1167:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;25138:124;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6164:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;23221:38;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7712:436;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;25473:168;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6628:193;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;25854:129;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6829:151;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46341:229;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;23352:389;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2066:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;45655:678;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;:::i;:::-;;;;;;;;45226:421;1053:13;:11;:13::i;:::-;45380:5:::1;45346:39;;:21;:30;45368:7;45346:30;;;;;;;;;;;;;;;;;;;;;;;;;:39;;::::0;45338:48:::1;;;::::0;::::1;;45430:5;45397:21;:30;45419:7;45397:30;;;;;;;;;;;;;;;;:38;;;;;;;;;;;;;;;;;;45459:4;45450:13;;:5;:13;;::::0;45446:142:::1;;45480:23;45492:7;45501:1;45480:11;:23::i;:::-;45446:142;;;45536:40;45548:7;45557:18;45567:7;45557:9;:18::i;:::-;45536:11;:40::i;:::-;45446:142;45624:7;45603:36;;;45633:5;45603:36;;;;;;:::i;:::-;;;;;;;;45226:421:::0;;:::o;6058:100::-;6112:13;6145:5;6138:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6058:100;:::o;6988:201::-;7071:4;7088:13;7104:12;:10;:12::i;:::-;7088:28;;7127:32;7136:5;7143:7;7152:6;7127:8;:32::i;:::-;7177:4;7170:11;;;6988:201;;;;:::o;21758:23::-;;;;;;;;;;;;;:::o;6377:108::-;6438:7;6465:12;;6458:19;;6377:108;:::o;44355:49::-;;;;;;;;;;;;;;;;;:::o;7197:261::-;7294:4;7311:15;7329:12;:10;:12::i;:::-;7311:30;;7352:38;7368:4;7374:7;7383:6;7352:15;:38::i;:::-;7401:27;7411:4;7417:2;7421:6;7401:9;:27::i;:::-;7446:4;7439:11;;;7197:261;;;;;:::o;26424:247::-;26501:7;22082:6;26524:129;:113;26600:28;:36;26629:6;26600:36;;;;;;;;;;;;;;;;26524:63;:48;26554:17;26564:6;26554:9;:17::i;:::-;26524:25;;:29;;:48;;;;:::i;:::-;:61;:63::i;:::-;:75;;:113;;;;:::i;:::-;:127;:129::i;:::-;:141;;;;:::i;:::-;26517:148;;26424:247;;;:::o;6276:93::-;6334:5;6359:2;6352:9;;6276:93;:::o;7466:238::-;7554:4;7571:13;7587:12;:10;:12::i;:::-;7571:28;;7610:64;7619:5;7626:7;7663:10;7635:25;7645:5;7652:7;7635:9;:25::i;:::-;:38;;;;:::i;:::-;7610:8;:64::i;:::-;7692:4;7685:11;;;7466:238;;;;:::o;44928:99::-;1053:13;:11;:13::i;:::-;45011:8:::1;45000;;:19;;;;;;;;;;;;;;;;;;44928:99:::0;:::o;44660:260::-;1053:13;:11;:13::i;:::-;44795:12:::1;44788:29;;;44832:9;44863:12;44856:30;;;44895:4;44856:45;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;44788:124;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;44660:260:::0;;:::o;44293:53::-;;;;;;;;;;;;;;;;;;;;;;:::o;23910:109::-;23969:44;24001:10;23969:23;:44::i;:::-;;23910:109::o;6493:127::-;6567:7;6594:9;:18;6604:7;6594:18;;;;;;;;;;;;;;;;6587:25;;6493:127;;;:::o;1808:103::-;1053:13;:11;:13::i;:::-;1873:30:::1;1900:1;1873:18;:30::i;:::-;1808:103::o:0;46578:370::-;46682:4;1053:13;:11;:13::i;:::-;46704:14:::1;46721:32;46745:7;46721:23;:32::i;:::-;46704:49;;46779:1;46770:6;:10;46766:152;;;46823:15;46797:14;:23;46812:7;46797:23;;;;;;;;;;;;;;;:41;;;;46864:7;46858:22;;;46873:6;46858:22;;;;;;:::i;:::-;;;;;;;;46902:4;46895:11;;;;;46766:152;46935:5;46928:12;;;1077:1;46578:370:::0;;;:::o;23176:40::-;;;;:::o;1167:87::-;1213:7;1240:6;;;;;;;;;;;1233:13;;1167:87;:::o;25138:124::-;25203:7;25226:30;25249:6;25226:22;:30::i;:::-;25219:37;;25138:124;;;:::o;6164:104::-;6220:13;6253:7;6246:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6164:104;:::o;23221:38::-;;;;:::o;7712:436::-;7805:4;7822:13;7838:12;:10;:12::i;:::-;7822:28;;7861:24;7888:25;7898:5;7905:7;7888:9;:25::i;:::-;7861:52;;7952:15;7932:16;:35;;7924:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;8045:60;8054:5;8061:7;8089:15;8070:16;:34;8045:8;:60::i;:::-;8136:4;8129:11;;;;7712:436;;;;:::o;25473:168::-;25550:7;25573:62;25608:18;:26;25627:6;25608:26;;;;;;;;;;;;;;;;25573:30;25596:6;25573:22;:30::i;:::-;:34;;:62;;;;:::i;:::-;25566:69;;25473:168;;;:::o;6628:193::-;6707:4;6724:13;6740:12;:10;:12::i;:::-;6724:28;;6763;6773:5;6780:2;6784:6;6763:9;:28::i;:::-;6809:4;6802:11;;;6628:193;;;;:::o;25854:129::-;25928:7;25951:18;:26;25970:6;25951:26;;;;;;;;;;;;;;;;25944:33;;25854:129;;;:::o;6829:151::-;6918:7;6945:11;:18;6957:5;6945:18;;;;;;;;;;;;;;;:27;6964:7;6945:27;;;;;;;;;;;;;;;;6938:34;;6829:151;;;;:::o;46341:229::-;1053:13;:11;:13::i;:::-;46455:21:::1;:30;46477:7;46455:30;;;;;;;;;;;;;;;;;;;;;;;;;46502:7;46451:69;46530:32;46542:7;46551:10;46530:11;:32::i;:::-;1077:1;46341:229:::0;;:::o;23352:389::-;1053:13;:11;:13::i;:::-;23446:1:::1;23430:13;:11;:13::i;:::-;:17;23422:26;;;::::0;::::1;;23470:1;23461:6;:10;23457:279;;;23510:88;23576:13;:11;:13::i;:::-;23550:23;22082:6;23551;23550:12;;:23;;;;:::i;:::-;:39;;;;:::i;:::-;23510:25;;:29;;:88;;;;:::i;:::-;23482:25;:116;;;;23633:10;23612:40;;;23645:6;23612:40;;;;;;:::i;:::-;;;;;;;;23691:37;23721:6;23691:25;;:29;;:37;;;;:::i;:::-;23663:25;:65;;;;23457:279;23352:389:::0;:::o;2066:201::-;1053:13;:11;:13::i;:::-;2175:1:::1;2155:22;;:8;:22;;::::0;2147:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;2231:28;2250:8;2231:18;:28::i;:::-;2066:201:::0;:::o;45655:678::-;45754:7;45776;45798;45820;45842;45877:23;;:::i;:::-;45926:7;45911:4;:12;;:22;;;;;;;;;;;45973:31;45996:7;45973:22;:31::i;:::-;45944:4;:26;;:60;;;;;46037:31;46060:7;46037:22;:31::i;:::-;46015:4;:19;;:53;;;;;46100:14;:23;46115:7;46100:23;;;;;;;;;;;;;;;;46079:4;:18;;:44;;;;;46156:4;:12;;;46183:4;:26;;;46224:4;:19;;;46258:4;:18;;;46291:23;;46134:191;;;;;;;;;;;45655:678;;;;;;;:::o;1332:132::-;1407:12;:10;:12::i;:::-;1396:23;;:7;:5;:7::i;:::-;:23;;;1388:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1332:132::o;28429:407::-;28503:22;28528:18;28538:7;28528:9;:18::i;:::-;28503:43;;28571:14;28558:10;:27;28555:276;;;28596:18;28617:30;28632:14;28617:10;:14;;:30;;;;:::i;:::-;28596:51;;28656:26;28662:7;28671:10;28656:5;:26::i;:::-;28587:103;28555:276;;;28712:14;28699:10;:27;28696:135;;;28737:18;28758:30;28777:10;28758:14;:18;;:30;;;;:::i;:::-;28737:51;;28797:26;28803:7;28812:10;28797:5;:26::i;:::-;28728:103;28696:135;28555:276;28496:340;28429:407;;:::o;383:98::-;436:7;463:10;456:17;;383:98;:::o;10209:346::-;10328:1;10311:19;;:5;:19;;;10303:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;10409:1;10390:21;;:7;:21;;;10382:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;10493:6;10463:11;:18;10475:5;10463:18;;;;;;;;;;;;;;;:27;10482:7;10463:27;;;;;;;;;;;;;;;:36;;;;10531:7;10515:32;;10524:5;10515:32;;;10540:6;10515:32;;;;;;:::i;:::-;;;;;;;;10209:346;;;:::o;10563:419::-;10664:24;10691:25;10701:5;10708:7;10691:9;:25::i;:::-;10664:52;;10751:17;10731:16;:37;10727:248;;10813:6;10793:16;:26;;10785:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;10897:51;10906:5;10913:7;10941:6;10922:16;:25;10897:8;:51::i;:::-;10727:248;10653:329;10563:419;;;:::o;45035:183::-;45157:5;45149:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;45035:183;;;:::o;12803:471::-;12861:7;13111:1;13106;:6;13102:47;;13136:1;13129:8;;;;13102:47;13161:9;13177:1;13173;:5;;;;:::i;:::-;13161:17;;13206:1;13201;13197;:5;;;;:::i;:::-;:10;13189:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;13265:1;13258:8;;;12803:471;;;;;:::o;17726:134::-;17782:6;17797:8;17815:1;17797:20;;17837:1;17832;:6;;17824:15;;;;;;17853:1;17846:8;;;17726:134;;;:::o;17161:176::-;17217:6;17236:8;17251:1;17247;:5;;;;:::i;:::-;17236:16;;17277:1;17272;:6;;:16;;;;;17287:1;17282;:6;;17272:16;17271:38;;;;17298:1;17294;:5;:14;;;;;17307:1;17303;:5;17294:14;17271:38;17263:47;;;;;;17328:1;17321:8;;;17161:176;;;;:::o;17566:127::-;17622:7;17655:1;17650;:6;;17642:15;;;;;;17683:1;17668:17;;17566:127;;;:::o;24187:738::-;24260:7;24276:29;24308:28;24331:4;24308:22;:28::i;:::-;24276:60;;24371:1;24347:21;:25;24343:560;;;24410:51;24439:21;24410:18;:24;24429:4;24410:24;;;;;;;;;;;;;;;;:28;;:51;;;;:::i;:::-;24383:18;:24;24402:4;24383:24;;;;;;;;;;;;;;;:78;;;;24497:21;24470:23;;:48;;;;;;;:::i;:::-;;;;;;;;24550:4;24532:46;;;24556:21;24532:46;;;;;;:::i;:::-;;;;;;;;24587:12;24609:8;;;;;;;;;;;24602:25;;;24628:4;24634:21;24602:54;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;24587:69;;24671:7;24667:190;;24718:51;24747:21;24718:18;:24;24737:4;24718:24;;;;;;;;;;;;;;;;:28;;:51;;;;:::i;:::-;24691:18;:24;24710:4;24691:24;;;;;;;;;;;;;;;:78;;;;24807:21;24780:23;;:48;;;;;;;:::i;:::-;;;;;;;;24846:1;24839:8;;;;;;24667:190;24874:21;24867:28;;;;;;24343:560;24918:1;24911:8;;;24187:738;;;;:::o;2427:191::-;2501:16;2520:6;;;;;;;;;;;2501:25;;2546:8;2537:6;;:17;;;;;;;;;;;;;;;;;;2601:8;2570:40;;2591:8;2570:40;;;;;;;;;;;;2490:128;2427:191;:::o;11913:136::-;11971:7;11998:43;12002:1;12005;11998:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;11991:50;;11913:136;;;;:::o;11449:181::-;11507:7;11527:9;11543:1;11539;:5;;;;:::i;:::-;11527:17;;11568:1;11563;:6;;11555:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;11621:1;11614:8;;;11449:181;;;;:::o;27628:260::-;27700:27;27712:7;27721:5;27700:11;:27::i;:::-;27776:106;27827:53;27828:36;27858:5;27828:25;;:29;;:36;;;;:::i;:::-;27827:51;:53::i;:::-;27776:28;:37;27805:7;27776:37;;;;;;;;;;;;;;;;:49;;:106;;;;:::i;:::-;27736:28;:37;27765:7;27736:37;;;;;;;;;;;;;;;:146;;;;27628:260;;:::o;28163:::-;28235:27;28247:7;28256:5;28235:11;:27::i;:::-;28311:106;28362:53;28363:36;28393:5;28363:25;;:29;;:36;;;;:::i;:::-;28362:51;:53::i;:::-;28311:28;:37;28340:7;28311:37;;;;;;;;;;;;;;;;:49;;:106;;;;:::i;:::-;28271:28;:37;28300:7;28271:37;;;;;;;;;;;;;;;:146;;;;28163:260;;:::o;12352:192::-;12438:7;12471:1;12466;:6;;12474:12;12458:29;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;12498:9;12514:1;12510;:5;;;;:::i;:::-;12498:17;;12535:1;12528:8;;;12352:192;;;;;:::o;8970:548::-;9073:1;9054:21;;:7;:21;;;9046:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;9124:49;9153:1;9157:7;9166:6;9124:20;:49::i;:::-;9202:6;9186:12;;:22;;;;;;;:::i;:::-;;;;;;;;9379:6;9357:9;:18;9367:7;9357:18;;;;;;;;;;;;;;;;:28;;;;;;;;;;;9433:7;9412:37;;9429:1;9412:37;;;9442:6;9412:37;;;;;;:::i;:::-;;;;;;;;9462:48;9490:1;9494:7;9503:6;9462:19;:48::i;:::-;8970:548;;:::o;16897:176::-;16953:6;16972:8;16987:1;16983;:5;;;;:::i;:::-;16972:16;;17013:1;17008;:6;;:16;;;;;17023:1;17018;:6;;17008:16;17007:38;;;;17034:1;17030;:5;:14;;;;;17043:1;17039;:5;17030:14;17007:38;16999:47;;;;;;17064:1;17057:8;;;16897:176;;;;:::o;9526:675::-;9629:1;9610:21;;:7;:21;;;9602:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;9682:49;9703:7;9720:1;9724:6;9682:20;:49::i;:::-;9744:22;9769:9;:18;9779:7;9769:18;;;;;;;;;;;;;;;;9744:43;;9824:6;9806:14;:24;;9798:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;9943:6;9926:14;:23;9905:9;:18;9915:7;9905:18;;;;;;;;;;;;;;;:44;;;;10060:6;10044:12;;:22;;;;;;;;;;;10121:1;10095:37;;10104:7;10095:37;;;10125:6;10095:37;;;;;;:::i;:::-;;;;;;;;10145:48;10165:7;10182:1;10186:6;10145:19;:48::i;:::-;9591:610;9526:675;;:::o;10990:91::-;;;;:::o;11089:90::-;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;88:117:1:-;197:1;194;187:12;334:126;371:7;411:42;404:5;400:54;389:65;;334:126;;;:::o;466:96::-;503:7;532:24;550:5;532:24;:::i;:::-;521:35;;466:96;;;:::o;568:122::-;641:24;659:5;641:24;:::i;:::-;634:5;631:35;621:63;;680:1;677;670:12;621:63;568:122;:::o;696:139::-;742:5;780:6;767:20;758:29;;796:33;823:5;796:33;:::i;:::-;696:139;;;;:::o;841:90::-;875:7;918:5;911:13;904:21;893:32;;841:90;;;:::o;937:116::-;1007:21;1022:5;1007:21;:::i;:::-;1000:5;997:32;987:60;;1043:1;1040;1033:12;987:60;937:116;:::o;1059:133::-;1102:5;1140:6;1127:20;1118:29;;1156:30;1180:5;1156:30;:::i;:::-;1059:133;;;;:::o;1198:468::-;1263:6;1271;1320:2;1308:9;1299:7;1295:23;1291:32;1288:119;;;1326:79;;:::i;:::-;1288:119;1446:1;1471:53;1516:7;1507:6;1496:9;1492:22;1471:53;:::i;:::-;1461:63;;1417:117;1573:2;1599:50;1641:7;1632:6;1621:9;1617:22;1599:50;:::i;:::-;1589:60;;1544:115;1198:468;;;;;:::o;1672:99::-;1724:6;1758:5;1752:12;1742:22;;1672:99;;;:::o;1777:169::-;1861:11;1895:6;1890:3;1883:19;1935:4;1930:3;1926:14;1911:29;;1777:169;;;;:::o;1952:246::-;2033:1;2043:113;2057:6;2054:1;2051:13;2043:113;;;2142:1;2137:3;2133:11;2127:18;2123:1;2118:3;2114:11;2107:39;2079:2;2076:1;2072:10;2067:15;;2043:113;;;2190:1;2181:6;2176:3;2172:16;2165:27;2014:184;1952:246;;;:::o;2204:102::-;2245:6;2296:2;2292:7;2287:2;2280:5;2276:14;2272:28;2262:38;;2204:102;;;:::o;2312:377::-;2400:3;2428:39;2461:5;2428:39;:::i;:::-;2483:71;2547:6;2542:3;2483:71;:::i;:::-;2476:78;;2563:65;2621:6;2616:3;2609:4;2602:5;2598:16;2563:65;:::i;:::-;2653:29;2675:6;2653:29;:::i;:::-;2648:3;2644:39;2637:46;;2404:285;2312:377;;;;:::o;2695:313::-;2808:4;2846:2;2835:9;2831:18;2823:26;;2895:9;2889:4;2885:20;2881:1;2870:9;2866:17;2859:47;2923:78;2996:4;2987:6;2923:78;:::i;:::-;2915:86;;2695:313;;;;:::o;3014:77::-;3051:7;3080:5;3069:16;;3014:77;;;:::o;3097:122::-;3170:24;3188:5;3170:24;:::i;:::-;3163:5;3160:35;3150:63;;3209:1;3206;3199:12;3150:63;3097:122;:::o;3225:139::-;3271:5;3309:6;3296:20;3287:29;;3325:33;3352:5;3325:33;:::i;:::-;3225:139;;;;:::o;3370:474::-;3438:6;3446;3495:2;3483:9;3474:7;3470:23;3466:32;3463:119;;;3501:79;;:::i;:::-;3463:119;3621:1;3646:53;3691:7;3682:6;3671:9;3667:22;3646:53;:::i;:::-;3636:63;;3592:117;3748:2;3774:53;3819:7;3810:6;3799:9;3795:22;3774:53;:::i;:::-;3764:63;;3719:118;3370:474;;;;;:::o;3850:109::-;3931:21;3946:5;3931:21;:::i;:::-;3926:3;3919:34;3850:109;;:::o;3965:210::-;4052:4;4090:2;4079:9;4075:18;4067:26;;4103:65;4165:1;4154:9;4150:17;4141:6;4103:65;:::i;:::-;3965:210;;;;:::o;4181:118::-;4268:24;4286:5;4268:24;:::i;:::-;4263:3;4256:37;4181:118;;:::o;4305:222::-;4398:4;4436:2;4425:9;4421:18;4413:26;;4449:71;4517:1;4506:9;4502:17;4493:6;4449:71;:::i;:::-;4305:222;;;;:::o;4533:118::-;4620:24;4638:5;4620:24;:::i;:::-;4615:3;4608:37;4533:118;;:::o;4657:222::-;4750:4;4788:2;4777:9;4773:18;4765:26;;4801:71;4869:1;4858:9;4854:17;4845:6;4801:71;:::i;:::-;4657:222;;;;:::o;4885:329::-;4944:6;4993:2;4981:9;4972:7;4968:23;4964:32;4961:119;;;4999:79;;:::i;:::-;4961:119;5119:1;5144:53;5189:7;5180:6;5169:9;5165:22;5144:53;:::i;:::-;5134:63;;5090:117;4885:329;;;;:::o;5220:619::-;5297:6;5305;5313;5362:2;5350:9;5341:7;5337:23;5333:32;5330:119;;;5368:79;;:::i;:::-;5330:119;5488:1;5513:53;5558:7;5549:6;5538:9;5534:22;5513:53;:::i;:::-;5503:63;;5459:117;5615:2;5641:53;5686:7;5677:6;5666:9;5662:22;5641:53;:::i;:::-;5631:63;;5586:118;5743:2;5769:53;5814:7;5805:6;5794:9;5790:22;5769:53;:::i;:::-;5759:63;;5714:118;5220:619;;;;;:::o;5845:86::-;5880:7;5920:4;5913:5;5909:16;5898:27;;5845:86;;;:::o;5937:112::-;6020:22;6036:5;6020:22;:::i;:::-;6015:3;6008:35;5937:112;;:::o;6055:214::-;6144:4;6182:2;6171:9;6167:18;6159:26;;6195:67;6259:1;6248:9;6244:17;6235:6;6195:67;:::i;:::-;6055:214;;;;:::o;6275:474::-;6343:6;6351;6400:2;6388:9;6379:7;6375:23;6371:32;6368:119;;;6406:79;;:::i;:::-;6368:119;6526:1;6551:53;6596:7;6587:6;6576:9;6572:22;6551:53;:::i;:::-;6541:63;;6497:117;6653:2;6679:53;6724:7;6715:6;6704:9;6700:22;6679:53;:::i;:::-;6669:63;;6624:118;6275:474;;;;;:::o;6755:104::-;6800:7;6829:24;6847:5;6829:24;:::i;:::-;6818:35;;6755:104;;;:::o;6865:138::-;6946:32;6972:5;6946:32;:::i;:::-;6939:5;6936:43;6926:71;;6993:1;6990;6983:12;6926:71;6865:138;:::o;7009:155::-;7063:5;7101:6;7088:20;7079:29;;7117:41;7152:5;7117:41;:::i;:::-;7009:155;;;;:::o;7170:345::-;7237:6;7286:2;7274:9;7265:7;7261:23;7257:32;7254:119;;;7292:79;;:::i;:::-;7254:119;7412:1;7437:61;7490:7;7481:6;7470:9;7466:22;7437:61;:::i;:::-;7427:71;;7383:125;7170:345;;;;:::o;7521:329::-;7580:6;7629:2;7617:9;7608:7;7604:23;7600:32;7597:119;;;7635:79;;:::i;:::-;7597:119;7755:1;7780:53;7825:7;7816:6;7805:9;7801:22;7780:53;:::i;:::-;7770:63;;7726:117;7521:329;;;;:::o;7856:664::-;8061:4;8099:3;8088:9;8084:19;8076:27;;8113:71;8181:1;8170:9;8166:17;8157:6;8113:71;:::i;:::-;8194:72;8262:2;8251:9;8247:18;8238:6;8194:72;:::i;:::-;8276;8344:2;8333:9;8329:18;8320:6;8276:72;:::i;:::-;8358;8426:2;8415:9;8411:18;8402:6;8358:72;:::i;:::-;8440:73;8508:3;8497:9;8493:19;8484:6;8440:73;:::i;:::-;7856:664;;;;;;;;:::o;8526:180::-;8574:77;8571:1;8564:88;8671:4;8668:1;8661:15;8695:4;8692:1;8685:15;8712:320;8756:6;8793:1;8787:4;8783:12;8773:22;;8840:1;8834:4;8830:12;8861:18;8851:81;;8917:4;8909:6;8905:17;8895:27;;8851:81;8979:2;8971:6;8968:14;8948:18;8945:38;8942:84;;8998:18;;:::i;:::-;8942:84;8763:269;8712:320;;;:::o;9038:180::-;9086:77;9083:1;9076:88;9183:4;9180:1;9173:15;9207:4;9204:1;9197:15;9224:180;9272:77;9269:1;9262:88;9369:4;9366:1;9359:15;9393:4;9390:1;9383:15;9410:185;9450:1;9467:20;9485:1;9467:20;:::i;:::-;9462:25;;9501:20;9519:1;9501:20;:::i;:::-;9496:25;;9540:1;9530:35;;9545:18;;:::i;:::-;9530:35;9587:1;9584;9580:9;9575:14;;9410:185;;;;:::o;9601:191::-;9641:3;9660:20;9678:1;9660:20;:::i;:::-;9655:25;;9694:20;9712:1;9694:20;:::i;:::-;9689:25;;9737:1;9734;9730:9;9723:16;;9758:3;9755:1;9752:10;9749:36;;;9765:18;;:::i;:::-;9749:36;9601:191;;;;:::o;9798:143::-;9855:5;9886:6;9880:13;9871:22;;9902:33;9929:5;9902:33;:::i;:::-;9798:143;;;;:::o;9947:351::-;10017:6;10066:2;10054:9;10045:7;10041:23;10037:32;10034:119;;;10072:79;;:::i;:::-;10034:119;10192:1;10217:64;10273:7;10264:6;10253:9;10249:22;10217:64;:::i;:::-;10207:74;;10163:128;9947:351;;;;:::o;10304:332::-;10425:4;10463:2;10452:9;10448:18;10440:26;;10476:71;10544:1;10533:9;10529:17;10520:6;10476:71;:::i;:::-;10557:72;10625:2;10614:9;10610:18;10601:6;10557:72;:::i;:::-;10304:332;;;;;:::o;10642:137::-;10696:5;10727:6;10721:13;10712:22;;10743:30;10767:5;10743:30;:::i;:::-;10642:137;;;;:::o;10785:345::-;10852:6;10901:2;10889:9;10880:7;10876:23;10872:32;10869:119;;;10907:79;;:::i;:::-;10869:119;11027:1;11052:61;11105:7;11096:6;11085:9;11081:22;11052:61;:::i;:::-;11042:71;;10998:125;10785:345;;;;:::o;11136:224::-;11276:34;11272:1;11264:6;11260:14;11253:58;11345:7;11340:2;11332:6;11328:15;11321:32;11136:224;:::o;11366:366::-;11508:3;11529:67;11593:2;11588:3;11529:67;:::i;:::-;11522:74;;11605:93;11694:3;11605:93;:::i;:::-;11723:2;11718:3;11714:12;11707:19;;11366:366;;;:::o;11738:419::-;11904:4;11942:2;11931:9;11927:18;11919:26;;11991:9;11985:4;11981:20;11977:1;11966:9;11962:17;11955:47;12019:131;12145:4;12019:131;:::i;:::-;12011:139;;11738:419;;;:::o;12163:225::-;12303:34;12299:1;12291:6;12287:14;12280:58;12372:8;12367:2;12359:6;12355:15;12348:33;12163:225;:::o;12394:366::-;12536:3;12557:67;12621:2;12616:3;12557:67;:::i;:::-;12550:74;;12633:93;12722:3;12633:93;:::i;:::-;12751:2;12746:3;12742:12;12735:19;;12394:366;;;:::o;12766:419::-;12932:4;12970:2;12959:9;12955:18;12947:26;;13019:9;13013:4;13009:20;13005:1;12994:9;12990:17;12983:47;13047:131;13173:4;13047:131;:::i;:::-;13039:139;;12766:419;;;:::o;13191:182::-;13331:34;13327:1;13319:6;13315:14;13308:58;13191:182;:::o;13379:366::-;13521:3;13542:67;13606:2;13601:3;13542:67;:::i;:::-;13535:74;;13618:93;13707:3;13618:93;:::i;:::-;13736:2;13731:3;13727:12;13720:19;;13379:366;;;:::o;13751:419::-;13917:4;13955:2;13944:9;13940:18;13932:26;;14004:9;13998:4;13994:20;13990:1;13979:9;13975:17;13968:47;14032:131;14158:4;14032:131;:::i;:::-;14024:139;;13751:419;;;:::o;14176:223::-;14316:34;14312:1;14304:6;14300:14;14293:58;14385:6;14380:2;14372:6;14368:15;14361:31;14176:223;:::o;14405:366::-;14547:3;14568:67;14632:2;14627:3;14568:67;:::i;:::-;14561:74;;14644:93;14733:3;14644:93;:::i;:::-;14762:2;14757:3;14753:12;14746:19;;14405:366;;;:::o;14777:419::-;14943:4;14981:2;14970:9;14966:18;14958:26;;15030:9;15024:4;15020:20;15016:1;15005:9;15001:17;14994:47;15058:131;15184:4;15058:131;:::i;:::-;15050:139;;14777:419;;;:::o;15202:221::-;15342:34;15338:1;15330:6;15326:14;15319:58;15411:4;15406:2;15398:6;15394:15;15387:29;15202:221;:::o;15429:366::-;15571:3;15592:67;15656:2;15651:3;15592:67;:::i;:::-;15585:74;;15668:93;15757:3;15668:93;:::i;:::-;15786:2;15781:3;15777:12;15770:19;;15429:366;;;:::o;15801:419::-;15967:4;16005:2;15994:9;15990:18;15982:26;;16054:9;16048:4;16044:20;16040:1;16029:9;16025:17;16018:47;16082:131;16208:4;16082:131;:::i;:::-;16074:139;;15801:419;;;:::o;16226:179::-;16366:31;16362:1;16354:6;16350:14;16343:55;16226:179;:::o;16411:366::-;16553:3;16574:67;16638:2;16633:3;16574:67;:::i;:::-;16567:74;;16650:93;16739:3;16650:93;:::i;:::-;16768:2;16763:3;16759:12;16752:19;;16411:366;;;:::o;16783:419::-;16949:4;16987:2;16976:9;16972:18;16964:26;;17036:9;17030:4;17026:20;17022:1;17011:9;17007:17;17000:47;17064:131;17190:4;17064:131;:::i;:::-;17056:139;;16783:419;;;:::o;17208:230::-;17348:34;17344:1;17336:6;17332:14;17325:58;17417:13;17412:2;17404:6;17400:15;17393:38;17208:230;:::o;17444:366::-;17586:3;17607:67;17671:2;17666:3;17607:67;:::i;:::-;17600:74;;17683:93;17772:3;17683:93;:::i;:::-;17801:2;17796:3;17792:12;17785:19;;17444:366;;;:::o;17816:419::-;17982:4;18020:2;18009:9;18005:18;17997:26;;18069:9;18063:4;18059:20;18055:1;18044:9;18040:17;18033:47;18097:131;18223:4;18097:131;:::i;:::-;18089:139;;17816:419;;;:::o;18241:410::-;18281:7;18304:20;18322:1;18304:20;:::i;:::-;18299:25;;18338:20;18356:1;18338:20;:::i;:::-;18333:25;;18393:1;18390;18386:9;18415:30;18433:11;18415:30;:::i;:::-;18404:41;;18594:1;18585:7;18581:15;18578:1;18575:22;18555:1;18548:9;18528:83;18505:139;;18624:18;;:::i;:::-;18505:139;18289:362;18241:410;;;;:::o;18657:220::-;18797:34;18793:1;18785:6;18781:14;18774:58;18866:3;18861:2;18853:6;18849:15;18842:28;18657:220;:::o;18883:366::-;19025:3;19046:67;19110:2;19105:3;19046:67;:::i;:::-;19039:74;;19122:93;19211:3;19122:93;:::i;:::-;19240:2;19235:3;19231:12;19224:19;;18883:366;;;:::o;19255:419::-;19421:4;19459:2;19448:9;19444:18;19436:26;;19508:9;19502:4;19498:20;19494:1;19483:9;19479:17;19472:47;19536:131;19662:4;19536:131;:::i;:::-;19528:139;;19255:419;;;:::o;19680:76::-;19716:7;19745:5;19734:16;;19680:76;;;:::o;19762:375::-;19801:3;19820:19;19837:1;19820:19;:::i;:::-;19815:24;;19853:19;19870:1;19853:19;:::i;:::-;19848:24;;19895:1;19892;19888:9;19881:16;;20093:1;20088:3;20084:11;20077:19;20073:1;20070;20066:9;20062:35;20045:1;20040:3;20036:11;20031:1;20028;20024:9;20017:17;20013:35;19997:110;19994:136;;;20110:18;;:::i;:::-;19994:136;19762:375;;;;:::o;20143:60::-;20171:3;20192:5;20185:12;;20143:60;;;:::o;20209:142::-;20259:9;20292:53;20310:34;20319:24;20337:5;20319:24;:::i;:::-;20310:34;:::i;:::-;20292:53;:::i;:::-;20279:66;;20209:142;;;:::o;20357:126::-;20407:9;20440:37;20471:5;20440:37;:::i;:::-;20427:50;;20357:126;;;:::o;20489:134::-;20547:9;20580:37;20611:5;20580:37;:::i;:::-;20567:50;;20489:134;;;:::o;20629:147::-;20724:45;20763:5;20724:45;:::i;:::-;20719:3;20712:58;20629:147;;:::o;20782:348::-;20911:4;20949:2;20938:9;20934:18;20926:26;;20962:79;21038:1;21027:9;21023:17;21014:6;20962:79;:::i;:::-;21051:72;21119:2;21108:9;21104:18;21095:6;21051:72;:::i;:::-;20782:348;;;;;:::o;21136:194::-;21176:4;21196:20;21214:1;21196:20;:::i;:::-;21191:25;;21230:20;21248:1;21230:20;:::i;:::-;21225:25;;21274:1;21271;21267:9;21259:17;;21298:1;21292:4;21289:11;21286:37;;;21303:18;;:::i;:::-;21286:37;21136:194;;;;:::o;21336:177::-;21476:29;21472:1;21464:6;21460:14;21453:53;21336:177;:::o;21519:366::-;21661:3;21682:67;21746:2;21741:3;21682:67;:::i;:::-;21675:74;;21758:93;21847:3;21758:93;:::i;:::-;21876:2;21871:3;21867:12;21860:19;;21519:366;;;:::o;21891:419::-;22057:4;22095:2;22084:9;22080:18;22072:26;;22144:9;22138:4;22134:20;22130:1;22119:9;22115:17;22108:47;22172:131;22298:4;22172:131;:::i;:::-;22164:139;;21891:419;;;:::o;22316:181::-;22456:33;22452:1;22444:6;22440:14;22433:57;22316:181;:::o;22503:366::-;22645:3;22666:67;22730:2;22725:3;22666:67;:::i;:::-;22659:74;;22742:93;22831:3;22742:93;:::i;:::-;22860:2;22855:3;22851:12;22844:19;;22503:366;;;:::o;22875:419::-;23041:4;23079:2;23068:9;23064:18;23056:26;;23128:9;23122:4;23118:20;23114:1;23103:9;23099:17;23092:47;23156:131;23282:4;23156:131;:::i;:::-;23148:139;;22875:419;;;:::o;23300:372::-;23339:4;23359:19;23376:1;23359:19;:::i;:::-;23354:24;;23392:19;23409:1;23392:19;:::i;:::-;23387:24;;23435:1;23432;23428:9;23420:17;;23629:1;23623:4;23619:12;23615:1;23612;23608:9;23604:28;23587:1;23581:4;23577:12;23572:1;23569;23565:9;23558:17;23554:36;23538:104;23535:130;;;23645:18;;:::i;:::-;23535:130;23300:372;;;;:::o;23678:220::-;23818:34;23814:1;23806:6;23802:14;23795:58;23887:3;23882:2;23874:6;23870:15;23863:28;23678:220;:::o;23904:366::-;24046:3;24067:67;24131:2;24126:3;24067:67;:::i;:::-;24060:74;;24143:93;24232:3;24143:93;:::i;:::-;24261:2;24256:3;24252:12;24245:19;;23904:366;;;:::o;24276:419::-;24442:4;24480:2;24469:9;24465:18;24457:26;;24529:9;24523:4;24519:20;24515:1;24504:9;24500:17;24493:47;24557:131;24683:4;24557:131;:::i;:::-;24549:139;;24276:419;;;:::o;24701:221::-;24841:34;24837:1;24829:6;24825:14;24818:58;24910:4;24905:2;24897:6;24893:15;24886:29;24701:221;:::o;24928:366::-;25070:3;25091:67;25155:2;25150:3;25091:67;:::i;:::-;25084:74;;25167:93;25256:3;25167:93;:::i;:::-;25285:2;25280:3;25276:12;25269:19;;24928:366;;;:::o;25300:419::-;25466:4;25504:2;25493:9;25489:18;25481:26;;25553:9;25547:4;25543:20;25539:1;25528:9;25524:17;25517:47;25581:131;25707:4;25581:131;:::i;:::-;25573:139;;25300:419;;;:::o

Swarm Source

ipfs://92df312b129c6afba495c8bb3c41118e6fda8768654b3c126f6a05a8df88a635

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.

Tools & Services