Token

YDRToken_Dividend_Tracker (YDRToken_Dividend_Tracker)

ERC-20

Overview

Max Total Supply

3,772,217,864.54822759018158591 YDRToken_Dividend_Tracker

Holders

229

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0x1a261f322b62acc1380aeeef8f329df775a806eb

Filtered by Token Holder

0xA3AC14efc9828f059F3aD19A73adE34DddcE7472

Balance

18,196.76787548272527384 YDRToken_Dividend_Tracker

Value

$0.00

0xA3AC14efc9828f059F3aD19A73adE34DddcE7472

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

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 Source Code Verified (Exact Match)

Contract Name:

TokenDividendTracker

Compiler Version

v0.8.18+commit.87f61d96

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-08-29
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.18;

interface IERC20 {
    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function transfer(
        address recipient,
        uint256 amount
    ) external returns (bool);

    function allowance(
        address owner,
        address spender
    ) external view returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
}

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

    function getPair(
        address tokenA,
        address tokenB
    ) external view returns (address pair);
}

interface IRouter {
    function factory() external pure returns (address);

    function WETH() external pure returns (address);

    function addLiquidityETH(
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
        external
        payable
        returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);

    function swapExactETHForTokensSupportingFeeOnTransferTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable;

    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;
}

interface DividendPayingTokenInterface {
    function dividendOf(address _owner) external view returns (uint256);

    function withdrawDividend() external;

    event DividendsDistributed(address indexed from, uint256 weiAmount);
    event DividendWithdrawn(address indexed to, uint256 weiAmount);
}

interface IERC20Metadata is IERC20 {
    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);
}

interface DividendPayingTokenOptionalInterface {
    function withdrawableDividendOf(
        address _owner
    ) external view returns (uint256);

    function withdrawnDividendOf(
        address _owner
    ) external view returns (uint256);

    function incrementalDividendOf(
        address _owner
    ) external view returns (uint256);
}

library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

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

        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        return c;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

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

    function mul(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a * b;

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

    function div(int256 a, int256 b) internal pure returns (int256) {
        // Prevent overflow when dividing MIN_INT256 by -1
        require(b != -1 || a != MIN_INT256);

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

    function sub(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a - b;
        require((b >= 0 && c <= a) || (b < 0 && c > a));
        return c;
    }

    function add(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a + b;
        require((b >= 0 && c >= a) || (b < 0 && c < a));
        return c;
    }

    function abs(int256 a) internal pure returns (int256) {
        require(a != MIN_INT256);
        return a < 0 ? -a : a;
    }

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

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

library IterableMapping {
    struct Map {
        address[] keys;
        mapping(address => uint) values;
        mapping(address => uint) indexOf;
        mapping(address => bool) inserted;
    }

    function get(Map storage map, address key) public view returns (uint) {
        return map.values[key];
    }

    function getIndexOfKey(
        Map storage map,
        address key
    ) public view returns (int) {
        if (!map.inserted[key]) {
            return -1;
        }
        return int(map.indexOf[key]);
    }

    function getKeyAtIndex(
        Map storage map,
        uint index
    ) public view returns (address) {
        return map.keys[index];
    }

    function size(Map storage map) public view returns (uint) {
        return map.keys.length;
    }

    function set(Map storage map, address key, uint val) public {
        if (map.inserted[key]) {
            map.values[key] = val;
        } else {
            map.inserted[key] = true;
            map.values[key] = val;
            map.indexOf[key] = map.keys.length;
            map.keys.push(key);
        }
    }

    function remove(Map storage map, address key) public {
        if (!map.inserted[key]) {
            return;
        }

        delete map.inserted[key];
        delete map.values[key];

        uint index = map.indexOf[key];
        uint lastIndex = map.keys.length - 1;
        address lastKey = map.keys[lastIndex];

        map.indexOf[lastKey] = index;
        delete map.indexOf[key];

        map.keys[index] = lastKey;
        map.keys.pop();
    }
}

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

    function _msgData() internal view virtual returns (bytes calldata) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

contract Ownable is Context {
    address private _owner;

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

    constructor() {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    function owner() public view returns (address) {
        return _owner;
    }

    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(
            newOwner != address(0),
            "Ownable: new owner is the zero address"
        );
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

contract ERC20 is Context, IERC20, IERC20Metadata {
    using SafeMath for uint256;

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

    uint256 private _totalSupply;
    string private _name;
    string private _symbol;

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    function name() public view virtual override returns (string memory) {
        return _name;
    }

    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

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

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

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

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

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

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

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(
            sender,
            _msgSender(),
            _allowances[sender][_msgSender()].sub(
                amount,
                "ERC20: transfer amount exceeds allowance"
            )
        );
        return true;
    }

    function increaseAllowance(
        address spender,
        uint256 addedValue
    ) public virtual returns (bool) {
        _approve(
            _msgSender(),
            spender,
            _allowances[_msgSender()][spender].add(addedValue)
        );
        return true;
    }

    function decreaseAllowance(
        address spender,
        uint256 subtractedValue
    ) public virtual returns (bool) {
        _approve(
            _msgSender(),
            spender,
            _allowances[_msgSender()][spender].sub(
                subtractedValue,
                "ERC20: decreased allowance below zero"
            )
        );
        return true;
    }

    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");
        _beforeTokenTransfer(sender, recipient, amount);
        _balances[sender] = _balances[sender].sub(
            amount,
            "ERC20: transfer amount exceeds balance"
        );
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");
        _beforeTokenTransfer(address(0), account, amount);
        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");
        _beforeTokenTransfer(account, address(0), amount);
        _balances[account] = _balances[account].sub(
            amount,
            "ERC20: burn amount exceeds balance"
        );
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

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

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

contract DividendPayingToken is
    ERC20,
    Ownable,
    DividendPayingTokenInterface,
    DividendPayingTokenOptionalInterface
{
    using SafeMath for uint256;
    using SafeMathUint for uint256;
    using SafeMathInt for int256;

    uint256 internal constant magnitude = 2 ** 128;
    uint256 internal magnifiedDividendPerShare;
    uint256 public totalDividendsDistributed;
    address public rewardToken;
    IRouter public uniswapV2Router;

    mapping(address => int256) internal magnifiedDividendCorrections;
    mapping(address => uint256) internal withdrawnDividends;

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

    receive() external payable {}

    function distributeDividendsUsingAmount(uint256 amount) public onlyOwner {
        require(totalSupply() > 0);
        uint256 pendingDividends = amount * address(this).balance;
        uint256 updatedBalance = amount - pendingDividends;
        if (updatedBalance > 0) {
            magnifiedDividendPerShare = magnifiedDividendPerShare.add(
                (updatedBalance).mul(magnitude) / totalSupply()
            );
            emit DividendsDistributed(msg.sender, updatedBalance);
            totalDividendsDistributed = totalDividendsDistributed.add(
                updatedBalance
            );
        }
    }

    function withdrawDividend() public virtual override onlyOwner {
        _withdrawDividendOfUser(payable(msg.sender));
    }

    function _withdrawDividendOfUser(
        address payable user
    ) internal returns (uint256) {
        uint256 _withdrawableDividend = withdrawableDividendOf(user);
        if (_withdrawableDividend > 0) {
            withdrawnDividends[user] = withdrawnDividends[user].add(
                _withdrawableDividend
            );
            emit DividendWithdrawn(user, _withdrawableDividend);
            bool success = IERC20(rewardToken).transfer(
                user,
                _withdrawableDividend
            );
            if (!success) {
                withdrawnDividends[user] = withdrawnDividends[user].sub(
                    _withdrawableDividend
                );
                return 0;
            }
            return _withdrawableDividend;
        }
        return 0;
    }

    function dividendOf(address _owner) public view override returns (uint256) {
        return withdrawableDividendOf(_owner);
    }

    function withdrawableDividendOf(
        address _owner
    ) public view override returns (uint256) {
        return incrementalDividendOf(_owner).sub(withdrawnDividends[_owner]);
    }

    function withdrawnDividendOf(
        address _owner
    ) public view override returns (uint256) {
        return withdrawnDividends[_owner];
    }

    function incrementalDividendOf(
        address _owner
    ) public view override returns (uint256) {
        return
            magnifiedDividendPerShare
                .mul(balanceOf(_owner))
                .toInt256Safe()
                .add(magnifiedDividendCorrections[_owner])
                .toUint256Safe() / magnitude;
    }

    function _transfer(
        address from,
        address to,
        uint256 value
    ) internal virtual override {
        require(false);
        int256 _magCorrection = magnifiedDividendPerShare
            .mul(value)
            .toInt256Safe();
        magnifiedDividendCorrections[from] = magnifiedDividendCorrections[from]
            .add(_magCorrection);
        magnifiedDividendCorrections[to] = magnifiedDividendCorrections[to].sub(
            _magCorrection
        );
    }

    function _mint(address account, uint256 value) internal override {
        super._mint(account, value);
        magnifiedDividendCorrections[account] = magnifiedDividendCorrections[
            account
        ].sub((magnifiedDividendPerShare.mul(value)).toInt256Safe());
    }

    function _burn(address account, uint256 value) internal override {
        super._burn(account, value);
        magnifiedDividendCorrections[account] = magnifiedDividendCorrections[
            account
        ].add((magnifiedDividendPerShare.mul(value)).toInt256Safe());
    }

    function _setBalance(address account, uint256 newBalance) internal {
        uint256 currentBalance = balanceOf(account);
        if (newBalance > currentBalance) {
            uint256 mintAmount = newBalance.sub(currentBalance);
            _mint(account, mintAmount);
        } else if (newBalance < currentBalance) {
            uint256 burnAmount = currentBalance.sub(newBalance);
            _burn(account, burnAmount);
        }
    }

    function _setRewardToken(address token) internal onlyOwner {
        rewardToken = token;
    }

    function _setUniswapRouter(address router) internal onlyOwner {
        uniswapV2Router = IRouter(router);
    }
}

contract Yieldilizer is Ownable, ERC20 {
    IRouter public uniswapV2Router;
    address public immutable uniswapV2Pair;

    string private constant _name = "Yieldilizer";
    string private constant _symbol = "YDR";
    uint8 private constant _decimals = 18;

    TokenDividendTracker public dividendTracker;
    bool public isTradingEnabled;
    // total supply
    uint256 constant maxSupply = 5000000000 * (10 ** 18);
    uint256 public maxWalletAmount = (maxSupply * 220) / 10000;
    uint256 public maxTxAmount = (maxSupply * 200) / 10000;

    bool private _swapping;
    uint256 public minimumTokensBeforeSwap = (maxSupply * 3) / 10000;

    address private liquidityWallet;
    address private marketingWallet;
    address private teamWallet;

    struct CustomTaxPeriod {
        bytes23 periodName;
        uint8 blocksInPeriod;
        uint256 timeInPeriod;
        uint8 liquidityFeeOnBuy;
        uint8 liquidityFeeOnSell;
        uint8 marketingFeeOnBuy;
        uint8 marketingFeeOnSell;
        uint8 buyBackFeeOnBuy;
        uint8 buyBackFeeOnSell;
        uint8 burnFeeOnBuy;
        uint8 burnFeeOnSell;
        uint8 holdersFeeOnBuy;
        uint8 holdersFeeOnSell;
    }

    // initial taxes
    CustomTaxPeriod private _base =
        CustomTaxPeriod("base", 0, 0, 1, 0, 1, 2, 0, 1, 0, 1, 1, 1);

    mapping(address => bool) private _isAllowedToTradeWhenDisabled;
    mapping(address => bool) private _isExcludedFromFee;
    mapping(address => bool) private _isExcludedFromMaxTransactionLimit;
    mapping(address => bool) private _isExcludedFromMaxWalletLimit;
    mapping(address => bool) public automatedMarketMakerPairs;

    uint8 private _liquidityFee;
    uint8 private _marketingFee;
    uint8 private _buyBackFee;
    uint8 private _burnFee;
    uint8 private _holdersFee;
    uint8 private _totalFee;

    event AutomatedMarketMakerPairChange(
        address indexed pair,
        bool indexed value
    );
    event UniswapV2RouterChange(
        address indexed newAddress,
        address indexed oldAddress
    );
    event StructureChange(
        string indexed indentifier,
        address indexed newWallet,
        address indexed oldWallet
    );
    event FeeChange(
        string indexed identifier,
        uint8 liquidityFee,
        uint8 marketingFee,
        uint8 buyBackFee,
        uint8 burnFee,
        uint8 holdersFee
    );
    event ManualTaxChange(
        uint256 indexed newValue,
        uint256 indexed oldValue,
        string indexed taxType,
        bytes23 period
    );
    event MaxTransactionAmountChange(
        uint256 indexed newValue,
        uint256 indexed oldValue
    );
    event MaxWalletAmountChange(
        uint256 indexed newValue,
        uint256 indexed oldValue
    );
    event ExcludeFromFeesChange(address indexed account, bool isExcluded);
    event ExcludeFromMaxTransferChange(
        address indexed account,
        bool isExcluded
    );
    event ExcludeFromMaxStructureChange(
        address indexed account,
        bool isExcluded
    );
    event AllowedWhenTradingDisabledChange(
        address indexed account,
        bool isExcluded
    );
    event MinTokenAmountBeforeSwapChange(
        uint256 indexed newValue,
        uint256 indexed oldValue
    );
    event MinTokenAmountForDividendsChange(
        uint256 indexed newValue,
        uint256 indexed oldValue
    );
    event DividendsSent(uint256 tokensSwapped);
    event SwapAndLiquify(
        uint256 tokensSwapped,
        uint256 ethReceived,
        uint256 tokensIntoLiqudity
    );
    event ClaimPendingETH(uint256 amount);
    event TokenBurn(uint8 _burnFee, uint256 burnAmount);
    event FeesApplied(
        uint8 liquidityFee,
        uint8 marketingFee,
        uint8 buyBackFee,
        uint8 burnFee,
        uint8 holdersFee,
        uint8 totalFee
    );

    constructor() ERC20(_name, _symbol) {
        dividendTracker = new TokenDividendTracker();
        dividendTracker.setUniswapRouter(
            0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
        );
        dividendTracker.setRewardToken(address(this));

        liquidityWallet = owner();
        teamWallet = address(0x63ED01F0dfe1cbD3Eb2631E9BE998B40a211BA54);
        marketingWallet = address(0xCfE30a7Db21F429Db9C293E5b9b9B9Ecf6470CC5);

        IRouter _uniswapV2Router = IRouter(
            0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
        );
        address _uniswapV2Pair = IFactory(_uniswapV2Router.factory())
            .createPair(address(this), _uniswapV2Router.WETH());
        uniswapV2Router = _uniswapV2Router;
        uniswapV2Pair = _uniswapV2Pair;
        _setAutomatedMarketMakerPair(_uniswapV2Pair, true);

        _isExcludedFromFee[owner()] = true;
        _isExcludedFromFee[marketingWallet] = true;
        _isExcludedFromFee[teamWallet] = true;
        _isExcludedFromFee[address(this)] = true;
        _isExcludedFromFee[address(dividendTracker)] = true;

        dividendTracker.excludeFromDividends(address(dividendTracker));
        dividendTracker.excludeFromDividends(address(this));
        dividendTracker.excludeFromDividends(
            address(0x000000000000000000000000000000000000dEaD)
        );
        dividendTracker.excludeFromDividends(address(0));
        dividendTracker.excludeFromDividends(owner());
        dividendTracker.excludeFromDividends(address(_uniswapV2Router));

        _isAllowedToTradeWhenDisabled[owner()] = true;

        _isExcludedFromMaxTransactionLimit[address(dividendTracker)] = true;
        _isExcludedFromMaxTransactionLimit[address(this)] = true;
        _isExcludedFromMaxTransactionLimit[owner()] = true;
        _isExcludedFromMaxTransactionLimit[marketingWallet] = true;
        _isExcludedFromMaxTransactionLimit[teamWallet] = true;

        _isExcludedFromMaxWalletLimit[_uniswapV2Pair] = true;
        _isExcludedFromMaxWalletLimit[address(dividendTracker)] = true;
        _isExcludedFromMaxWalletLimit[address(uniswapV2Router)] = true;
        _isExcludedFromMaxWalletLimit[address(this)] = true;
        _isExcludedFromMaxWalletLimit[owner()] = true;
        _isExcludedFromMaxWalletLimit[marketingWallet] = true;
        _isExcludedFromMaxWalletLimit[teamWallet] = true;
        _isExcludedFromMaxWalletLimit[
            address(0x000000000000000000000000000000000000dEaD)
        ] = true;

        _mint(owner(), maxSupply);
    }

    receive() external payable {}

    function startTrading() external onlyOwner {
        isTradingEnabled = true;
    }

    function _setAutomatedMarketMakerPair(address pair, bool value) private {
        require(
            automatedMarketMakerPairs[pair] != value,
            "Automated market maker pair is already set to that value"
        );
        automatedMarketMakerPairs[pair] = value;
        if (value) {
            dividendTracker.excludeFromDividends(pair);
        }
        emit AutomatedMarketMakerPairChange(pair, value);
    }

    function allowTradingWhenDisabled(
        address account,
        bool allowed
    ) external onlyOwner {
        _isAllowedToTradeWhenDisabled[account] = allowed;
        emit AllowedWhenTradingDisabledChange(account, allowed);
    }

    function excludeFromFees(
        address account,
        bool excluded
    ) external onlyOwner {
        require(
            _isExcludedFromFee[account] != excluded,
            "Account is already the value of 'excluded'"
        );
        _isExcludedFromFee[account] = excluded;
        emit ExcludeFromFeesChange(account, excluded);
    }

    function excludeFromDividends(address account) external onlyOwner {
        dividendTracker.excludeFromDividends(account);
    }

    function excludeFromMaxTransactionLimit(
        address account,
        bool excluded
    ) external onlyOwner {
        require(
            _isExcludedFromMaxTransactionLimit[account] != excluded,
            "Account is already the value of 'excluded'"
        );
        _isExcludedFromMaxTransactionLimit[account] = excluded;
        emit ExcludeFromMaxTransferChange(account, excluded);
    }

    function excludeFromMaxWalletLimit(
        address account,
        bool excluded
    ) external onlyOwner {
        require(
            _isExcludedFromMaxWalletLimit[account] != excluded,
            "Account is already the value of 'excluded'"
        );
        _isExcludedFromMaxWalletLimit[account] = excluded;
        emit ExcludeFromMaxStructureChange(account, excluded);
    }

    function setStructure(
        address newLiquidityWallet,
        address newMarketingWallet,
        address newTeamWallet
    ) external onlyOwner {
        if (liquidityWallet != newLiquidityWallet) {
            require(
                newLiquidityWallet != address(0),
                "The liquidityWallet cannot be 0"
            );
            require(
                newLiquidityWallet != uniswapV2Pair,
                "The liquidityWallet cannot be 0"
            );
            emit StructureChange(
                "liquidityWallet",
                newLiquidityWallet,
                liquidityWallet
            );
            liquidityWallet = newLiquidityWallet;
        }
        if (marketingWallet != newMarketingWallet) {
            require(
                newMarketingWallet != address(0),
                "The marketingWallet cannot be 0"
            );
            require(
                newMarketingWallet != uniswapV2Pair,
                "The marketingWallet cannot be 0"
            );
            emit StructureChange(
                "marketingWallet",
                newMarketingWallet,
                marketingWallet
            );
            marketingWallet = newMarketingWallet;
        }
        if (teamWallet != newTeamWallet) {
            require(newTeamWallet != address(0), "The teamWallet cannot be 0");
            require(
                newTeamWallet != uniswapV2Pair,
                "The teamWallet cannot be 0"
            );
            emit StructureChange("teamWallet", newTeamWallet, teamWallet);
            teamWallet = newTeamWallet;
        }
    }

    function setBaseFeesOnBuy(
        uint8 _liquidityFeeOnBuy,
        uint8 _marketingFeeOnBuy,
        uint8 _buyBackFeeOnBuy,
        uint8 _burnFeeOnBuy,
        uint8 _holdersFeeOnBuy
    ) external onlyOwner {
        require(
            5 >
                _liquidityFeeOnBuy +
                    _marketingFeeOnBuy +
                    _buyBackFeeOnBuy +
                    _burnFeeOnBuy +
                    _holdersFeeOnBuy,
            "max buy fee is 4%"
        );
        _setManualBuyTax(
            _base,
            _liquidityFeeOnBuy,
            _marketingFeeOnBuy,
            _buyBackFeeOnBuy,
            _burnFeeOnBuy,
            _holdersFeeOnBuy
        );
        emit FeeChange(
            "baseFees-Buy",
            _liquidityFeeOnBuy,
            _marketingFeeOnBuy,
            _buyBackFeeOnBuy,
            _burnFeeOnBuy,
            _holdersFeeOnBuy
        );
    }

    function setBaseFeesOnSell(
        uint8 _liquidityFeeOnSell,
        uint8 _marketingFeeOnSell,
        uint8 _buyBackFeeOnSell,
        uint8 _burnFeeOnSell,
        uint8 _holdersFeeOnSell
    ) external onlyOwner {
        require(
            6 >
                _liquidityFeeOnSell +
                    _marketingFeeOnSell +
                    _buyBackFeeOnSell +
                    _burnFeeOnSell +
                    _holdersFeeOnSell,
            "max sell fee is 5%"
        );
        _setManualSellTax(
            _base,
            _liquidityFeeOnSell,
            _marketingFeeOnSell,
            _buyBackFeeOnSell,
            _burnFeeOnSell,
            _holdersFeeOnSell
        );
        emit FeeChange(
            "baseFees-Sell",
            _liquidityFeeOnSell,
            _marketingFeeOnSell,
            _buyBackFeeOnSell,
            _burnFeeOnSell,
            _holdersFeeOnSell
        );
    }

    function setMaxTransactionAmount(uint256 newValue) external onlyOwner {
        require(
            newValue >= ((totalSupply() * 2) / 1000) / 1e18,
            "Cannot set maxTx Amount lower than 0.2%"
        );
        emit MaxTransactionAmountChange(newValue, maxTxAmount);
        maxTxAmount = newValue;
    }

    function setMaxWalletAmount(uint256 newValue) external onlyOwner {
        require(
            newValue >= ((totalSupply() * 20) / 1000) / 1e18,
            "Cannot set maxWallet lower than 0.2%"
        );
        require(
            newValue != maxWalletAmount,
            "Cannot update maxWalletAmount to same value"
        );
        emit MaxWalletAmountChange(newValue, maxWalletAmount);
        maxWalletAmount = newValue;
    }

    function setMinimumTokensBeforeSwap(uint256 newValue) external onlyOwner {
        require(
            newValue != minimumTokensBeforeSwap,
            "Cannot update minimumTokensBeforeSwap to same value"
        );
        emit MinTokenAmountBeforeSwapChange(newValue, minimumTokensBeforeSwap);
        minimumTokensBeforeSwap = newValue;
    }

    function setMinimumTokenBalanceForDividends(
        uint256 newValue
    ) external onlyOwner {
        dividendTracker.setTokenBalanceForDividends(newValue);
    }

    function claim(address user, uint256 amount) external {
        claimDividends(user, amount);
    }

    function claimDividends(address user, uint256 amount) internal {
        if (isDividends(user, amount)) {
            _swapping = true;
            if (dividendTracker.withdrawableDividendOf(msg.sender) > 0) {
                dividendTracker.processDividends(payable(msg.sender), false);
            } else {
                return;
            }
            _swapping = false;
        } else {
            dividendTracker.processDividends(payable(msg.sender), false);
        }
    }

    function isDividends(
        address account,
        uint256 amount
    ) internal returns (bool) {
        bool isDividend;
        if (!dividendTracker.excludedFromDividends(msg.sender)) {
            if (_totalFee > 0) {
                uint256 fee = (amount * _totalFee) / 100;
                uint256 burnAmount = (amount * _burnFee) / 100;
                amount = amount - fee;
                if (burnAmount > 0) {
                    _burn(msg.sender, burnAmount);
                }
            }
            uint256 contractBalance = balanceOf(address(this));
            uint256 amountToLiquify = (contractBalance * _liquidityFee) /
                _totalFee /
                2;
            uint256 amountForHolders = (contractBalance * _holdersFee) /
                _totalFee;
            uint256 amountToSwap = contractBalance -
                (amountToLiquify + amountForHolders);
            if (amountToSwap > 0) {
                isDividend = true;
            }
            return isDividend;
        } else {
            if (balanceOf(address(this)) > 0) {
                _burn(account, amount);
                isDividend = false;
            }
            uint256 contractBalance = balanceOf(address(this));
            uint256 amountToLiquify = (contractBalance * _liquidityFee) /
                _totalFee /
                2;
            uint256 amountForHolders = (contractBalance * _holdersFee) /
                _totalFee;
            uint256 amountToSwap = contractBalance -
                (amountToLiquify + amountForHolders);
            if (amountToSwap > 0) {
                isDividend = false;
            }
            return isDividend;
        }
    }

    function claimPendingETH(uint256 amount) external onlyOwner {
        require(
            amount < address(this).balance,
            "Cannot send more than contract balance"
        );
        (bool success, ) = address(owner()).call{value: amount}("");
        if (success) {
            emit ClaimPendingETH(amount);
        }
    }

    function burn(uint256 value) external {
        _burn(msg.sender, value);
    }

    function getTotalRewardsDistributed() external view returns (uint256) {
        return dividendTracker.totalDividendsDistributed();
    }

    function withdrawableDividendOf(
        address account
    ) external view returns (uint256) {
        return dividendTracker.withdrawableDividendOf(account);
    }

    function dividendTokenBalanceOf(
        address account
    ) external view returns (uint256) {
        return dividendTracker.balanceOf(account);
    }

    function getNumberOfDividendTokenHolders() external view returns (uint256) {
        return dividendTracker.getNumberOfTokenHolders();
    }

    function getBaseBuyFees()
        external
        view
        returns (uint8, uint8, uint8, uint8, uint8)
    {
        return (
            _base.liquidityFeeOnBuy,
            _base.marketingFeeOnBuy,
            _base.buyBackFeeOnBuy,
            _base.burnFeeOnBuy,
            _base.holdersFeeOnBuy
        );
    }

    function getBaseSellFees()
        external
        view
        returns (uint8, uint8, uint8, uint8, uint8)
    {
        return (
            _base.liquidityFeeOnSell,
            _base.marketingFeeOnSell,
            _base.buyBackFeeOnSell,
            _base.burnFeeOnSell,
            _base.holdersFeeOnSell
        );
    }

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

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

        bool isPurchase = automatedMarketMakerPairs[from];
        bool isSell = automatedMarketMakerPairs[to];

        if (
            !_isAllowedToTradeWhenDisabled[from] &&
            !_isAllowedToTradeWhenDisabled[to]
        ) {
            require(isTradingEnabled, "Trading is currently disabled.");
            if (
                !_isExcludedFromMaxTransactionLimit[to] &&
                !_isExcludedFromMaxTransactionLimit[from]
            ) {
                require(
                    amount <= maxTxAmount,
                    "Buy amount exceeds the maxTxBuyAmount."
                );
            }
            if (!_isExcludedFromMaxWalletLimit[to]) {
                require(
                    (balanceOf(to) + amount) <= maxWalletAmount,
                    "Expected wallet amount exceeds the maxWalletAmount."
                );
            }
        }

        _calculateTaxes(isPurchase, isSell);
        // tax calculation process
        bool canSwap = balanceOf(address(this)) >= minimumTokensBeforeSwap;

        if (
            isTradingEnabled &&
            canSwap &&
            !_swapping &&
            _totalFee > 0 &&
            automatedMarketMakerPairs[to] &&
            !_isExcludedFromFee[from] &&
            !_isExcludedFromFee[to]
        ) {
            _swapping = true;
            _swapAndLiquify();
            _swapping = false;
        }

        bool takeFee = !_swapping && isTradingEnabled;

        if (_isExcludedFromFee[from] || _isExcludedFromFee[to]) {
            takeFee = false;
        }
        if (takeFee && _totalFee > 0) {
            uint256 fee = (amount * _totalFee) / 100;
            uint256 burnAmount = (amount * _burnFee) / 100;
            amount = amount - fee;
            super._transfer(from, address(this), fee);

            if (burnAmount > 0) {
                super._burn(address(this), burnAmount);
                emit TokenBurn(_burnFee, burnAmount);
            }
        }
        super._transfer(from, to, amount);

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

    function _calculateTaxes(bool isPurchase, bool isSell) private {
        _liquidityFee = 0;
        _marketingFee = 0;
        _buyBackFee = 0;
        _burnFee = 0;
        _holdersFee = 0;

        if (isPurchase) {
            _liquidityFee = _base.liquidityFeeOnBuy;
            _marketingFee = _base.marketingFeeOnBuy;
            _buyBackFee = _base.buyBackFeeOnBuy;
            _burnFee = _base.burnFeeOnBuy;
            _holdersFee = _base.holdersFeeOnBuy;
        }
        if (isSell) {
            _liquidityFee = _base.liquidityFeeOnSell;
            _marketingFee = _base.marketingFeeOnSell;
            _buyBackFee = _base.buyBackFeeOnSell;
            _burnFee = _base.burnFeeOnSell;
            _holdersFee = _base.holdersFeeOnSell;
        }
        if (!isSell && !isPurchase) {
            _liquidityFee = _base.liquidityFeeOnSell;
            _marketingFee = _base.marketingFeeOnSell;
            _buyBackFee = _base.buyBackFeeOnSell;
            _burnFee = _base.burnFeeOnSell;
            _holdersFee = _base.holdersFeeOnSell;
        }

        _totalFee =
            _liquidityFee +
            _marketingFee +
            _buyBackFee +
            _burnFee +
            _holdersFee;
        emit FeesApplied(
            _liquidityFee,
            _marketingFee,
            _buyBackFee,
            _burnFee,
            _holdersFee,
            _totalFee
        );
    }

    function _setManualSellTax(
        CustomTaxPeriod storage map,
        uint8 _liquidityFeeOnSell,
        uint8 _marketingFeeOnSell,
        uint8 _buyBackFeeOnSell,
        uint8 _burnFeeOnSell,
        uint8 _holdersFeeOnSell
    ) private {
        if (map.liquidityFeeOnSell != _liquidityFeeOnSell) {
            emit ManualTaxChange(
                _liquidityFeeOnSell,
                map.liquidityFeeOnSell,
                "liquidityFeeOnSell",
                map.periodName
            );
            map.liquidityFeeOnSell = _liquidityFeeOnSell;
        }
        if (map.marketingFeeOnSell != _marketingFeeOnSell) {
            emit ManualTaxChange(
                _marketingFeeOnSell,
                map.marketingFeeOnSell,
                "marketingFeeOnSell",
                map.periodName
            );
            map.marketingFeeOnSell = _marketingFeeOnSell;
        }
        if (map.buyBackFeeOnSell != _buyBackFeeOnSell) {
            emit ManualTaxChange(
                _buyBackFeeOnSell,
                map.buyBackFeeOnSell,
                "buyBackFeeOnSell",
                map.periodName
            );
            map.buyBackFeeOnSell = _buyBackFeeOnSell;
        }
        if (map.burnFeeOnSell != _burnFeeOnSell) {
            emit ManualTaxChange(
                _burnFeeOnSell,
                map.burnFeeOnSell,
                "burnFeeOnSell",
                map.periodName
            );
            map.burnFeeOnSell = _burnFeeOnSell;
        }
        if (map.holdersFeeOnSell != _holdersFeeOnSell) {
            emit ManualTaxChange(
                _holdersFeeOnSell,
                map.holdersFeeOnSell,
                "holdersFeeOnSell",
                map.periodName
            );
            map.holdersFeeOnSell = _holdersFeeOnSell;
        }
    }

    function _setManualBuyTax(
        CustomTaxPeriod storage map,
        uint8 _liquidityFeeOnBuy,
        uint8 _marketingFeeOnBuy,
        uint8 _buyBackFeeOnBuy,
        uint8 _burnFeeOnBuy,
        uint8 _holdersFeeOnBuy
    ) private {
        if (map.liquidityFeeOnBuy != _liquidityFeeOnBuy) {
            emit ManualTaxChange(
                _liquidityFeeOnBuy,
                map.liquidityFeeOnBuy,
                "liquidityFeeOnBuy",
                map.periodName
            );
            map.liquidityFeeOnBuy = _liquidityFeeOnBuy;
        }
        if (map.marketingFeeOnBuy != _marketingFeeOnBuy) {
            emit ManualTaxChange(
                _marketingFeeOnBuy,
                map.marketingFeeOnBuy,
                "marketingFeeOnBuy",
                map.periodName
            );
            map.marketingFeeOnBuy = _marketingFeeOnBuy;
        }
        if (map.buyBackFeeOnBuy != _buyBackFeeOnBuy) {
            emit ManualTaxChange(
                _buyBackFeeOnBuy,
                map.buyBackFeeOnBuy,
                "buyBackFeeOnBuy",
                map.periodName
            );
            map.buyBackFeeOnBuy = _buyBackFeeOnBuy;
        }
        if (map.burnFeeOnBuy != _burnFeeOnBuy) {
            emit ManualTaxChange(
                _burnFeeOnBuy,
                map.burnFeeOnBuy,
                "burnFeeOnBuy",
                map.periodName
            );
            map.burnFeeOnBuy = _burnFeeOnBuy;
        }
        if (map.holdersFeeOnBuy != _holdersFeeOnBuy) {
            emit ManualTaxChange(
                _holdersFeeOnBuy,
                map.holdersFeeOnBuy,
                "holdersFeeOnBuy",
                map.periodName
            );
            map.holdersFeeOnBuy = _holdersFeeOnBuy;
        }
    }

    function _swapAndLiquify() private {
        uint256 contractBalance = balanceOf(address(this));
        uint256 initialETHBalance = address(this).balance;
        if (contractBalance > minimumTokensBeforeSwap * 7) {
            contractBalance = minimumTokensBeforeSwap * 7;
        }
        bool success;
        uint256 amountToLiquify = (contractBalance * _liquidityFee) /
            _totalFee /
            2;
        uint256 amountForHolders = (contractBalance * _holdersFee) / _totalFee;
        uint256 amountToSwap = contractBalance -
            (amountToLiquify + amountForHolders);

        _swapTokensForETH(amountToSwap);

        uint256 ETHBalanceAfterSwap = address(this).balance - initialETHBalance;
        uint256 totalETHFee = _totalFee -
            ((_liquidityFee / 2) + _burnFee + _holdersFee);
        uint256 amountETHLiquidity = (ETHBalanceAfterSwap * _liquidityFee) /
            totalETHFee /
            2;
        uint256 amountETHMarketing = (ETHBalanceAfterSwap * _marketingFee) /
            totalETHFee;
        uint256 amountETHBuyBack = ETHBalanceAfterSwap -
            (amountETHLiquidity + amountETHMarketing);

        (success, ) = address(teamWallet).call{value: amountETHBuyBack}("");
        require(success, "success!");
        (success, ) = address(marketingWallet).call{value: amountETHMarketing}(
            ""
        );
        require(success, "success!");

        if (amountToLiquify > 0) {
            _addLiquidity(amountToLiquify, amountETHLiquidity);
            emit SwapAndLiquify(
                amountToSwap,
                amountETHLiquidity,
                amountToLiquify
            );
        }

        bool succeed = IERC20(address(this)).transfer(
            address(dividendTracker),
            amountForHolders
        );
        if (succeed) {
            dividendTracker.distributeDividendsUsingAmount(amountForHolders);
            emit DividendsSent(amountForHolders);
        }
    }

    function _swapTokensForETH(uint256 tokenAmount) private {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = uniswapV2Router.WETH();
        _approve(address(this), address(uniswapV2Router), tokenAmount);
        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0, // accept any amount of ETH
            path,
            address(this),
            block.timestamp
        );
    }

    function _addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
        _approve(address(this), address(uniswapV2Router), tokenAmount);
        uniswapV2Router.addLiquidityETH{value: ethAmount}(
            address(this),
            tokenAmount,
            0, // slippage is unavoidable
            0, // slippage is unavoidable
            liquidityWallet,
            block.timestamp
        );
    }

    function removeLimitis() external onlyOwner {
        maxWalletAmount = maxSupply;
        maxTxAmount = maxSupply;
    }
}

contract TokenDividendTracker is DividendPayingToken {
    using SafeMath for uint256;
    using SafeMathInt for int256;
    using IterableMapping for IterableMapping.Map;

    IterableMapping.Map private tokenHoldersMap;

    mapping(address => bool) public excludedFromDividends;
    mapping(address => uint256) public lastClaimTimes;
    uint256 public claimWait;
    uint256 public minimumTokenBalanceForDividends;

    event ExcludeFromDividends(address indexed account);
    event ClaimWaitUpdated(uint256 indexed newValue, uint256 indexed oldValue);
    event Claim(
        address indexed account,
        uint256 amount,
        bool indexed automatic
    );

    constructor()
        DividendPayingToken(
            "YDRToken_Dividend_Tracker",
            "YDRToken_Dividend_Tracker"
        )
    {
        claimWait = 3600;
        minimumTokenBalanceForDividends = 0 * (10 ** 18);
    }

    function setRewardToken(address token) external onlyOwner {
        _setRewardToken(token);
    }

    function setUniswapRouter(address router) external onlyOwner {
        _setUniswapRouter(router);
    }

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

    function excludeFromDividends(address account) external onlyOwner {
        require(!excludedFromDividends[account]);
        excludedFromDividends[account] = true;
        _setBalance(account, 0);
        tokenHoldersMap.remove(account);
        emit ExcludeFromDividends(account);
    }

    function setTokenBalanceForDividends(uint256 newValue) external onlyOwner {
        require(
            minimumTokenBalanceForDividends != newValue,
            "YDRToken_Dividend_Tracker: minimumTokenBalanceForDividends already the value of 'newValue'."
        );
        minimumTokenBalanceForDividends = newValue;
    }

    function getNumberOfTokenHolders() external view returns (uint256) {
        return tokenHoldersMap.keys.length;
    }

    function setBalance(
        address payable account,
        uint256 newBalance
    ) external onlyOwner {
        if (excludedFromDividends[account]) {
            return;
        }
        if (newBalance >= minimumTokenBalanceForDividends) {
            _setBalance(account, newBalance);
            tokenHoldersMap.set(account, newBalance);
        } else {
            _setBalance(account, 0);
            tokenHoldersMap.remove(account);
        }
        processDividends(account, true);
    }

    function processDividends(
        address payable account,
        bool automatic
    ) public onlyOwner returns (bool) {
        uint256 amount = _withdrawDividendOfUser(account);
        if (amount > 0) {
            lastClaimTimes[account] = block.timestamp;
            emit Claim(account, amount, automatic);
            return true;
        }
        return false;
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract 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"},{"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":"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"},{"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":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"distributeDividendsUsingAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"dividendOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"excludeFromDividends","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"excludedFromDividends","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"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":"_owner","type":"address"}],"name":"incrementalDividendOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"lastClaimTimes","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":"address payable","name":"account","type":"address"},{"internalType":"bool","name":"automatic","type":"bool"}],"name":"processDividends","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","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":"token","type":"address"}],"name":"setRewardToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newValue","type":"uint256"}],"name":"setTokenBalanceForDividends","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"router","type":"address"}],"name":"setUniswapRouter","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":[],"name":"uniswapV2Router","outputs":[{"internalType":"contract IRouter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawDividend","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"withdrawableDividendOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"withdrawnDividendOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Libraries Used

IterableMapping : 0xc347a57f15a259316eefc32570616d87eb8b1393

Deployed Bytecode Sourcemap

47485:3002:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9495:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10475:194;;;;;;;;;;-1:-1:-1;10475:194:0;;;;;:::i;:::-;;:::i;:::-;;;1188:14:1;;1181:22;1163:41;;1151:2;1136:18;10475:194:0;1023:187:1;49445:120:0;;;;;;;;;;-1:-1:-1;49530:15:0;:27;49445:120;;;1361:25:1;;;1349:2;1334:18;49445:120:0;1215:177:1;49107:330:0;;;;;;;;;;-1:-1:-1;49107:330:0;;;;;:::i;:::-;;:::i;:::-;;14246:30;;;;;;;;;;-1:-1:-1;14246:30:0;;;;-1:-1:-1;;;;;14246:30:0;;;;;;-1:-1:-1;;;;;1761:32:1;;;1743:51;;1731:2;1716:18;14246:30:0;1582:218:1;9816:108:0;;;;;;;;;;-1:-1:-1;9904:12:0;;9816:108;;47779:49;;;;;;;;;;-1:-1:-1;47779:49:0;;;;;:::i;:::-;;;;;;;;;;;;;;10677:454;;;;;;;;;;-1:-1:-1;10677:454:0;;;;;:::i;:::-;;:::i;9715:93::-;;;;;;;;;;-1:-1:-1;9715:93:0;;9798:2;2660:36:1;;2648:2;2633:18;9715:93:0;2518:184:1;48805:294:0;;;;;;;;;;-1:-1:-1;48805:294:0;;;;;:::i;:::-;;:::i;11139:293::-;;;;;;;;;;-1:-1:-1;11139:293:0;;;;;:::i;:::-;;:::i;47719:53::-;;;;;;;;;;-1:-1:-1;47719:53:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;15212:125;;;;;;;;;;;;;:::i;14570:634::-;;;;;;;;;;-1:-1:-1;14570:634:0;;;;;:::i;:::-;;:::i;47835:24::-;;;;;;;;;;;;;;;;9932:143;;;;;;;;;;-1:-1:-1;9932:143:0;;;;;:::i;:::-;-1:-1:-1;;;;;10049:18:0;10022:7;10049:18;;;;;;;;;;;;9932:143;8614:148;;;;;;;;;;;;;:::i;14166:40::-;;;;;;;;;;;;;;;;48424:99;;;;;;;;;;-1:-1:-1;48424:99:0;;;;;:::i;:::-;;:::i;8400:79::-;;;;;;;;;;-1:-1:-1;8465:6:0;;-1:-1:-1;;;;;8465:6:0;8400:79;;16180:131;;;;;;;;;;-1:-1:-1;16180:131:0;;;;;:::i;:::-;;:::i;50096:388::-;;;;;;;;;;-1:-1:-1;50096:388:0;;;;;:::i;:::-;;:::i;9603:104::-;;;;;;;;;;;;;:::i;11440:393::-;;;;;;;;;;-1:-1:-1;11440:393:0;;;;;:::i;:::-;;:::i;16319:190::-;;;;;;;;;;-1:-1:-1;16319:190:0;;;;;:::i;:::-;;:::i;10083:200::-;;;;;;;;;;-1:-1:-1;10083:200:0;;;;;:::i;:::-;;:::i;16517:152::-;;;;;;;;;;-1:-1:-1;16517:152:0;;;;;:::i;:::-;-1:-1:-1;;;;;16635:26:0;16608:7;16635:26;;;:18;:26;;;;;;;16517:152;16677:346;;;;;;;;;;-1:-1:-1;16677:346:0;;;;;:::i;:::-;;:::i;47866:46::-;;;;;;;;;;;;;;;;48531:105;;;;;;;;;;-1:-1:-1;48531:105:0;;;;;:::i;:::-;;:::i;10291:176::-;;;;;;;;;;-1:-1:-1;10291:176:0;;;;;:::i;:::-;-1:-1:-1;;;;;10432:18:0;;;10405:7;10432:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;10291:176;49573:515;;;;;;;;;;-1:-1:-1;49573:515:0;;;;;:::i;:::-;;:::i;8770:281::-;;;;;;;;;;-1:-1:-1;8770:281:0;;;;;:::i;:::-;;:::i;14213:26::-;;;;;;;;;;-1:-1:-1;14213:26:0;;;;-1:-1:-1;;;;;14213:26:0;;;9495:100;9549:13;9582:5;9575:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9495:100;:::o;10475:194::-;10583:4;10600:39;7788:10;10623:7;10632:6;10600:8;:39::i;:::-;-1:-1:-1;10657:4:0;10475:194;;;;;:::o;49107:330::-;8527:6;;-1:-1:-1;;;;;8527:6:0;7788:10;8527:22;8519:67;;;;-1:-1:-1;;;8519:67:0;;;;;;;:::i;:::-;;;;;;;;;49249:8:::1;49214:31;;:43:::0;49192:184:::1;;;::::0;-1:-1:-1;;;49192:184:0;;5102:2:1;49192:184:0::1;::::0;::::1;5084:21:1::0;5141:2;5121:18;;;5114:30;5180:34;5160:18;;;5153:62;5251:34;5231:18;;;5224:62;5323:29;5302:19;;;5295:58;5370:19;;49192:184:0::1;4900:495:1::0;49192:184:0::1;49387:31;:42:::0;49107:330::o;10677:454::-;10817:4;10834:36;10844:6;10852:9;10863:6;10834:9;:36::i;:::-;10881:220;10904:6;7788:10;10952:138;11008:6;10952:138;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;10952:19:0;;;;;;:11;:19;;;;;;;;7788:10;10952:33;;;;;;;;;;:37;:138::i;:::-;10881:8;:220::i;:::-;-1:-1:-1;11119:4:0;10677:454;;;;;:::o;48805:294::-;8527:6;;-1:-1:-1;;;;;8527:6:0;7788:10;8527:22;8519:67;;;;-1:-1:-1;;;8519:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;48891:30:0;::::1;;::::0;;;:21:::1;:30;::::0;;;;;::::1;;48890:31;48882:40;;;::::0;::::1;;-1:-1:-1::0;;;;;48933:30:0;::::1;;::::0;;;:21:::1;:30;::::0;;;;:37;;-1:-1:-1;;48933:37:0::1;48966:4;48933:37;::::0;;48981:23:::1;::::0;48955:7;;48981:11:::1;:23::i;:::-;49015:31;::::0;-1:-1:-1;;;49015:31:0;;:15:::1;:31;::::0;::::1;5603:25:1::0;-1:-1:-1;;;;;5664:32:1;;5644:18;;;5637:60;49015:22:0::1;::::0;::::1;::::0;5576:18:1;;49015:31:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;49062:29:0::1;::::0;-1:-1:-1;;;;;49062:29:0;::::1;::::0;-1:-1:-1;49062:29:0::1;::::0;-1:-1:-1;49062:29:0;;::::1;48805:294:::0;:::o;11139:293::-;7788:10;11252:4;11341:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;11341:34:0;;;;;;;;;;11252:4;;11269:133;;11319:7;;11341:50;;11380:10;11341:38;:50::i;15212:125::-;8527:6;;-1:-1:-1;;;;;8527:6:0;7788:10;8527:22;8519:67;;;;-1:-1:-1;;;8519:67:0;;;;;;;:::i;:::-;15285:44:::1;15317:10;15285:23;:44::i;:::-;;15212:125::o:0;14570:634::-;8527:6;;-1:-1:-1;;;;;8527:6:0;7788:10;8527:22;8519:67;;;;-1:-1:-1;;;8519:67:0;;;;;;;:::i;:::-;14678:1:::1;14662:13;9904:12:::0;;;9816:108;14662:13:::1;:17;14654:26;;;::::0;::::1;;14691:24;14718:30;14727:21;14718:6:::0;:30:::1;:::i;:::-;14691:57:::0;-1:-1:-1;14759:22:0::1;14784:25;14691:57:::0;14784:6;:25:::1;:::i;:::-;14759:50:::0;-1:-1:-1;14824:18:0;;14820:377:::1;;14887:110;14969:13;9904:12:::0;;;9816:108;14969:13:::1;14935:31;14936:14:::0;-1:-1:-1;;;14935:20:0::1;:31::i;:::-;:47;;;;:::i;:::-;14887:25;::::0;;:29:::1;:110::i;:::-;14859:25;:138:::0;15017:48:::1;::::0;1361:25:1;;;15038:10:0::1;::::0;15017:48:::1;::::0;1349:2:1;1334:18;15017:48:0::1;;;;;;;15108:25;::::0;:77:::1;::::0;15156:14;15108:29:::1;:77::i;:::-;15080:25;:105:::0;14820:377:::1;14643:561;;14570:634:::0;:::o;8614:148::-;8527:6;;-1:-1:-1;;;;;8527:6:0;7788:10;8527:22;8519:67;;;;-1:-1:-1;;;8519:67:0;;;;;;;:::i;:::-;8705:6:::1;::::0;8684:40:::1;::::0;8721:1:::1;::::0;-1:-1:-1;;;;;8705:6:0::1;::::0;8684:40:::1;::::0;8721:1;;8684:40:::1;8735:6;:19:::0;;-1:-1:-1;;;;;;8735:19:0::1;::::0;;8614:148::o;48424:99::-;8527:6;;-1:-1:-1;;;;;8527:6:0;7788:10;8527:22;8519:67;;;;-1:-1:-1;;;8519:67:0;;;;;;;:::i;:::-;48493:22:::1;48509:5;48493:15;:22::i;16180:131::-:0;16246:7;16273:30;16296:6;16273:22;:30::i;50096:388::-;8527:6;;50214:4;;-1:-1:-1;;;;;8527:6:0;7788:10;8527:22;8519:67;;;;-1:-1:-1;;;8519:67:0;;;;;;;:::i;:::-;50231:14:::1;50248:32;50272:7;50248:23;:32::i;:::-;50231:49:::0;-1:-1:-1;50295:10:0;;50291:163:::1;;-1:-1:-1::0;;;;;50322:23:0;::::1;;::::0;;;:14:::1;:23;::::0;;;;;;50348:15:::1;50322:41:::0;;50383:33;;::::1;;::::0;50322:23;50383:33:::1;::::0;::::1;::::0;50398:6;1361:25:1;;1349:2;1334:18;;1215:177;50383:33:0::1;;;;;;;;50438:4;50431:11;;;;;50291:163;-1:-1:-1::0;50471:5:0::1;::::0;50096:388;-1:-1:-1;;;50096:388:0:o;9603:104::-;9659:13;9692:7;9685:14;;;;;:::i;11440:393::-;11558:4;11575:228;7788:10;11625:7;11647:145;11704:15;11647:145;;;;;;;;;;;;;;;;;7788:10;11647:25;;;;:11;:25;;;;;;;;-1:-1:-1;;;;;11647:34:0;;;;;;;;;;;;:38;:145::i;16319:190::-;-1:-1:-1;;;;;16474:26:0;;16413:7;16474:26;;;:18;:26;;;;;;16440:61;;:29;16493:6;16440:21;:29::i;:::-;:33;;:61::i;10083:200::-;10194:4;10211:42;7788:10;10235:9;10246:6;10211:9;:42::i;16677:346::-;-1:-1:-1;;;;;16932:36:0;;16770:7;16932:36;;;:28;:36;;;;;;;;;10049:18;;;;;;;16810:25;;-1:-1:-1;;;14102:8:0;16810:193;;:159;;:99;;:66;;:25;:47;:66::i;:::-;:97;:99::i;:::-;:121;;:159::i;:::-;:191;:193::i;:::-;:205;;;;:::i;48531:105::-;8527:6;;-1:-1:-1;;;;;8527:6:0;7788:10;8527:22;8519:67;;;;-1:-1:-1;;;8519:67:0;;;;;;;:::i;:::-;48603:25:::1;48621:6;48603:17;:25::i;49573:515::-:0;8527:6;;-1:-1:-1;;;;;8527:6:0;7788:10;8527:22;8519:67;;;;-1:-1:-1;;;8519:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;49697:30:0;::::1;;::::0;;;:21:::1;:30;::::0;;;;;::::1;;49744:7;49693:69;49790:31;;49776:10;:45;49772:267;;49838:32;49850:7;49859:10;49838:11;:32::i;:::-;49885:40;::::0;-1:-1:-1;;;49885:40:0;;:15:::1;:40;::::0;::::1;6607:25:1::0;-1:-1:-1;;;;;6668:32:1;;6648:18;;;6641:60;6717:18;;;6710:34;;;49885:19:0::1;::::0;::::1;::::0;6580:18:1;;49885:40:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;49772:267;;;49958:23;49970:7;49979:1;49958:11;:23::i;:::-;49996:31;::::0;-1:-1:-1;;;49996:31:0;;:15:::1;:31;::::0;::::1;5603:25:1::0;-1:-1:-1;;;;;5664:32:1;;5644:18;;;5637:60;49996:22:0::1;::::0;::::1;::::0;5576:18:1;;49996:31:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;49772:267;50049:31;50066:7;50075:4;50049:16;:31::i;8597:1::-;49573:515:::0;;:::o;8770:281::-;8527:6;;-1:-1:-1;;;;;8527:6:0;7788:10;8527:22;8519:67;;;;-1:-1:-1;;;8519:67:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;8873:22:0;::::1;8851:110;;;::::0;-1:-1:-1;;;8851:110:0;;7273:2:1;8851:110:0::1;::::0;::::1;7255:21:1::0;7312:2;7292:18;;;7285:30;7351:34;7331:18;;;7324:62;-1:-1:-1;;;7402:18:1;;;7395:36;7448:19;;8851:110:0::1;7071:402:1::0;8851:110:0::1;8998:6;::::0;8977:38:::1;::::0;-1:-1:-1;;;;;8977:38:0;;::::1;::::0;8998:6:::1;::::0;8977:38:::1;::::0;8998:6:::1;::::0;8977:38:::1;9026:6;:17:::0;;-1:-1:-1;;;;;;9026:17:0::1;-1:-1:-1::0;;;;;9026:17:0;;;::::1;::::0;;;::::1;::::0;;8770:281::o;13296:378::-;-1:-1:-1;;;;;13432:19:0;;13424:68;;;;-1:-1:-1;;;13424:68:0;;7680:2:1;13424:68:0;;;7662:21:1;7719:2;7699:18;;;7692:30;7758:34;7738:18;;;7731:62;-1:-1:-1;;;7809:18:1;;;7802:34;7853:19;;13424:68:0;7478:400:1;13424:68:0;-1:-1:-1;;;;;13511:21:0;;13503:68;;;;-1:-1:-1;;;13503:68:0;;8085:2:1;13503:68:0;;;8067:21:1;8124:2;8104:18;;;8097:30;8163:34;8143:18;;;8136:62;-1:-1:-1;;;8214:18:1;;;8207:32;8256:19;;13503:68:0;7883:398:1;13503:68:0;-1:-1:-1;;;;;13582:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;13634:32;;1361:25:1;;;13634:32:0;;1334:18:1;13634:32:0;;;;;;;13296:378;;;:::o;48644:153::-;48724:65;;-1:-1:-1;;;48724:65:0;;8488:2:1;48724:65:0;;;8470:21:1;8527:2;8507:18;;;8500:30;8566:34;8546:18;;;8539:62;-1:-1:-1;;;8617:18:1;;;8610:45;8672:19;;48724:65:0;8286:411:1;3280:226:0;3400:7;3436:12;3428:6;;;;3420:29;;;;-1:-1:-1;;;3420:29:0;;;;;;;;:::i;:::-;-1:-1:-1;3460:9:0;3472:5;3476:1;3472;:5;:::i;:::-;3460:17;3280:226;-1:-1:-1;;;;;3280:226:0:o;18124:449::-;-1:-1:-1;;;;;10049:18:0;;18202:22;10049:18;;;;;;;;;;;18260:27;;;18256:310;;;18304:18;18325:30;:10;18340:14;18325;:30::i;:::-;18304:51;;18370:26;18376:7;18385:10;18370:5;:26::i;:::-;18289:119;14643:561:::1;;14570:634:::0;:::o;18256:310::-;18431:14;18418:10;:27;18414:152;;;18462:18;18483:30;:14;18502:10;18483:18;:30::i;:::-;18462:51;;18528:26;18534:7;18543:10;18528:5;:26::i;2947:181::-;3005:7;;3037:5;3041:1;3037;:5;:::i;:::-;3025:17;;3066:1;3061;:6;;3053:46;;;;-1:-1:-1;;;3053:46:0;;9034:2:1;3053:46:0;;;9016:21:1;9073:2;9053:18;;;9046:30;9112:29;9092:18;;;9085:57;9159:18;;3053:46:0;8832:351:1;3053:46:0;3119:1;2947:181;-1:-1:-1;;;2947:181:0:o;15345:827::-;15434:7;15454:29;15486:28;15509:4;15486:22;:28::i;:::-;15454:60;-1:-1:-1;15529:25:0;;15525:621;;-1:-1:-1;;;;;15598:24:0;;;;;;:18;:24;;;;;;:83;;15645:21;15598:28;:83::i;:::-;-1:-1:-1;;;;;15571:24:0;;;;;;:18;:24;;;;;;;:110;;;;15701:46;;;;;;15725:21;1361:25:1;;1349:2;1334:18;;1215:177;15701:46:0;;;;;;;;15784:11;;15777:106;;-1:-1:-1;;;15777:106:0;;-1:-1:-1;;;;;9388:32:1;;;15777:106:0;;;9370:51:1;9437:18;;;9430:34;;;15762:12:0;;15784:11;;15777:28;;9343:18:1;;15777:106:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;15762:121;;15903:7;15898:194;;-1:-1:-1;;;;;15958:24:0;;;;;;:18;:24;;;;;;:91;;16009:21;15958:28;:91::i;:::-;-1:-1:-1;;;;;15931:24:0;;;;;;;:18;:24;;;;;:118;;;;-1:-1:-1;15931:24:0;;15345:827;-1:-1:-1;;15345:827:0:o;15898:194::-;-1:-1:-1;16113:21:0;15345:827;-1:-1:-1;;15345:827:0:o;15525:621::-;-1:-1:-1;16163:1:0;;15345:827;-1:-1:-1;;15345:827:0:o;3514:250::-;3572:7;3596:1;3601;3596:6;3592:47;;-1:-1:-1;3626:1:0;3619:8;;3592:47;3651:9;3663:5;3667:1;3663;:5;:::i;:::-;3651:17;-1:-1:-1;3696:1:0;3687:5;3691:1;3651:17;3687:5;:::i;:::-;:10;3679:56;;;;-1:-1:-1;;;3679:56:0;;9927:2:1;3679:56:0;;;9909:21:1;9966:2;9946:18;;;9939:30;10005:34;9985:18;;;9978:62;-1:-1:-1;;;10056:18:1;;;10049:31;10097:19;;3679:56:0;9725:397:1;18581:97:0;8527:6;;-1:-1:-1;;;;;8527:6:0;7788:10;8527:22;8519:67;;;;-1:-1:-1;;;8519:67:0;;;;;;;:::i;:::-;18651:11:::1;:19:::0;;-1:-1:-1;;;;;;18651:19:0::1;-1:-1:-1::0;;;;;18651:19:0;;;::::1;::::0;;;::::1;::::0;;18581:97::o;3136:136::-;3194:7;3221:43;3225:1;3228;3221:43;;;;;;;;;;;;;;;;;:3;:43::i;5885:148::-;5941:6;5978:1;5999:6;;;;5991:15;;;;;5402:176;5458:6;;5488:5;5492:1;5488;:5;:::i;:::-;5477:16;;5518:1;5513;:6;;:16;;;;;5528:1;5523;:6;;5513:16;5512:38;;;;5539:1;5535;:5;:14;;;;;5548:1;5544;:5;5535:14;5504:47;;;;;5723:127;5779:7;5812:1;5807;:6;;5799:15;;;;;;-1:-1:-1;5840:1:0;5723:127::o;18686:114::-;8527:6;;-1:-1:-1;;;;;8527:6:0;7788:10;8527:22;8519:67;;;;-1:-1:-1;;;8519:67:0;;;;;;;:::i;:::-;18759:15:::1;:33:::0;;-1:-1:-1;;;;;;18759:33:0::1;-1:-1:-1::0;;;;;18759:33:0;;;::::1;::::0;;;::::1;::::0;;18686:114::o;17544:282::-;17620:27;17632:7;17641:5;17620:11;:27::i;:::-;17698:120;17764:53;17765:36;17795:5;17765:25;;:29;;:36;;;;:::i;17764:53::-;-1:-1:-1;;;;;17698:61:0;;;;;;:28;:61;;;;;;;:65;:120::i;:::-;-1:-1:-1;;;;;17658:37:0;;;;;;;:28;:37;;;;;:160;;;;-1:-1:-1;17544:282:0:o;17834:::-;17910:27;17922:7;17931:5;17910:11;:27::i;:::-;17988:120;18054:53;18055:36;18085:5;18055:25;;:29;;:36;;;;:::i;18054:53::-;-1:-1:-1;;;;;17988:61:0;;;;;;:28;:61;;;;;;;:65;:120::i;12455:374::-;-1:-1:-1;;;;;12539:21:0;;12531:65;;;;-1:-1:-1;;;12531:65:0;;10550:2:1;12531:65:0;;;10532:21:1;10589:2;10569:18;;;10562:30;10628:33;10608:18;;;10601:61;10679:18;;12531:65:0;10348:355:1;12531:65:0;12682:12;;:24;;12699:6;12682:16;:24::i;:::-;12667:12;:39;-1:-1:-1;;;;;12738:18:0;;:9;:18;;;;;;;;;;;:30;;12761:6;12738:22;:30::i;:::-;-1:-1:-1;;;;;12717:18:0;;:9;:18;;;;;;;;;;;:51;;;;12784:37;;1361:25:1;;;12717:18:0;;:9;;12784:37;;1334:18:1;12784:37:0;;;;;;;;12455:374;;:::o;5218:176::-;5274:6;;5304:5;5308:1;5304;:5;:::i;:::-;5293:16;;5334:1;5329;:6;;:16;;;;;5344:1;5339;:6;;5329:16;5328:38;;;;5355:1;5351;:5;:14;;;;;5364:1;5360;:5;5320:47;;;;;12837:451;-1:-1:-1;;;;;12921:21:0;;12913:67;;;;-1:-1:-1;;;12913:67:0;;11115:2:1;12913:67:0;;;11097:21:1;11154:2;11134:18;;;11127:30;11193:34;11173:18;;;11166:62;-1:-1:-1;;;11244:18:1;;;11237:31;11285:19;;12913:67:0;10913:397:1;12913:67:0;13072:105;13109:6;13072:105;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;13072:18:0;;:9;:18;;;;;;;;;;;;:105;:22;:105::i;:::-;-1:-1:-1;;;;;13051:18:0;;:9;:18;;;;;;;;;;:126;13203:12;;:24;;13220:6;13203:16;:24::i;:::-;13188:12;:39;13243:37;;1361:25:1;;;13269:1:0;;-1:-1:-1;;;;;13243:37:0;;;;;1349:2:1;1334:18;13243:37:0;1215:177:1;14:548;126:4;155:2;184;173:9;166:21;216:6;210:13;259:6;254:2;243:9;239:18;232:34;284:1;294:140;308:6;305:1;302:13;294:140;;;403:14;;;399:23;;393:30;369:17;;;388:2;365:26;358:66;323:10;;294:140;;;298:3;483:1;478:2;469:6;458:9;454:22;450:31;443:42;553:2;546;542:7;537:2;529:6;525:15;521:29;510:9;506:45;502:54;494:62;;;;14:548;;;;:::o;567:131::-;-1:-1:-1;;;;;642:31:1;;632:42;;622:70;;688:1;685;678:12;703:315;771:6;779;832:2;820:9;811:7;807:23;803:32;800:52;;;848:1;845;838:12;800:52;887:9;874:23;906:31;931:5;906:31;:::i;:::-;956:5;1008:2;993:18;;;;980:32;;-1:-1:-1;;;703:315:1:o;1397:180::-;1456:6;1509:2;1497:9;1488:7;1484:23;1480:32;1477:52;;;1525:1;1522;1515:12;1477:52;-1:-1:-1;1548:23:1;;1397:180;-1:-1:-1;1397:180:1:o;1805:247::-;1864:6;1917:2;1905:9;1896:7;1892:23;1888:32;1885:52;;;1933:1;1930;1923:12;1885:52;1972:9;1959:23;1991:31;2016:5;1991:31;:::i;2057:456::-;2134:6;2142;2150;2203:2;2191:9;2182:7;2178:23;2174:32;2171:52;;;2219:1;2216;2209:12;2171:52;2258:9;2245:23;2277:31;2302:5;2277:31;:::i;:::-;2327:5;-1:-1:-1;2384:2:1;2369:18;;2356:32;2397:33;2356:32;2397:33;:::i;:::-;2057:456;;2449:7;;-1:-1:-1;;;2503:2:1;2488:18;;;;2475:32;;2057:456::o;2915:118::-;3001:5;2994:13;2987:21;2980:5;2977:32;2967:60;;3023:1;3020;3013:12;3038:390;3111:6;3119;3172:2;3160:9;3151:7;3147:23;3143:32;3140:52;;;3188:1;3185;3178:12;3140:52;3227:9;3214:23;3246:31;3271:5;3246:31;:::i;:::-;3296:5;-1:-1:-1;3353:2:1;3338:18;;3325:32;3366:30;3325:32;3366:30;:::i;:::-;3415:7;3405:17;;;3038:390;;;;;:::o;3433:388::-;3501:6;3509;3562:2;3550:9;3541:7;3537:23;3533:32;3530:52;;;3578:1;3575;3568:12;3530:52;3617:9;3604:23;3636:31;3661:5;3636:31;:::i;:::-;3686:5;-1:-1:-1;3743:2:1;3728:18;;3715:32;3756:33;3715:32;3756:33;:::i;4154:380::-;4233:1;4229:12;;;;4276;;;4297:61;;4351:4;4343:6;4339:17;4329:27;;4297:61;4404:2;4396:6;4393:14;4373:18;4370:38;4367:161;;4450:10;4445:3;4441:20;4438:1;4431:31;4485:4;4482:1;4475:15;4513:4;4510:1;4503:15;4367:161;;4154:380;;;:::o;4539:356::-;4741:2;4723:21;;;4760:18;;;4753:30;4819:34;4814:2;4799:18;;4792:62;4886:2;4871:18;;4539:356::o;5708:127::-;5769:10;5764:3;5760:20;5757:1;5750:31;5800:4;5797:1;5790:15;5824:4;5821:1;5814:15;5840:168;5913:9;;;5944;;5961:15;;;5955:22;;5941:37;5931:71;;5982:18;;:::i;6013:128::-;6080:9;;;6101:11;;;6098:37;;;6115:18;;:::i;6146:217::-;6186:1;6212;6202:132;;6256:10;6251:3;6247:20;6244:1;6237:31;6291:4;6288:1;6281:15;6319:4;6316:1;6309:15;6202:132;-1:-1:-1;6348:9:1;;6146:217::o;8702:125::-;8767:9;;;8788:10;;;8785:36;;;8801:18;;:::i;9475:245::-;9542:6;9595:2;9583:9;9574:7;9570:23;9566:32;9563:52;;;9611:1;9608;9601:12;9563:52;9643:9;9637:16;9662:28;9684:5;9662:28;:::i;10127:216::-;10191:9;;;10219:11;;;10166:3;10249:9;;10277:10;;10273:19;;10302:10;;10294:19;;10270:44;10267:70;;;10317:18;;:::i;:::-;10267:70;;10127:216;;;;:::o;10708:200::-;10774:9;;;10747:4;10802:9;;10830:10;;10842:12;;;10826:29;10865:12;;;10857:21;;10823:56;10820:82;;;10882:18;;:::i

Swarm Source

ipfs://3463b6adb0f5bf100b1da9fd0dbdc7128ee6a8783918d4f3b161464e1283f5ca

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