Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-07-10
*/

//SPDX-License-Identifier: MIT

pragma solidity ^0.7.4;



/** Website:  https://hydra.finance 
 *  Telegram: https://t.me/hydra_f


/**
 * Standard SafeMath, stripped down to just add/sub/mul/div
 */
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) {
        // Solidity only automatically asserts when dividing by 0
        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;
    }
}

/**
 * ERC20 standard interface.
 */
interface IERC20 {
    function totalSupply() external view returns (uint256);

    function decimals() external view returns (uint8);

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

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

    function getOwner() external view returns (address);

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

/**
 * Allows for contract ownership along with multi-address authorization
 */
abstract contract Auth {
    address internal owner;
    mapping(address => bool) internal authorizations;

    constructor(address _owner) {
        owner = _owner;
        authorizations[_owner] = true;
    }

    /**
     * Function modifier to require caller to be contract owner
     */
    modifier onlyOwner() {
        require(isOwner(msg.sender), "!OWNER");
        _;
    }

    /**
     * Function modifier to require caller to be authorized
     */
    modifier authorized() {
        require(isAuthorized(msg.sender), "!AUTHORIZED");
        _;
    }

    /**
     * Authorize address. Owner only
     */
    function authorize(address adr) public onlyOwner {
        authorizations[adr] = true;
    }

    /**
     * Remove address' authorization. Owner only
     */
    function unauthorize(address adr) public onlyOwner {
        authorizations[adr] = false;
    }

    /**
     * Check if address is owner
     */
    function isOwner(address account) public view returns (bool) {
        return account == owner;
    }

    /**
     * Return address' authorization status
     */
    function isAuthorized(address adr) public view returns (bool) {
        return authorizations[adr];
    }

    /**
     * Transfer ownership to new address. Caller must be owner. Leaves old owner authorized
     */
    function transferOwnership(address payable adr) public onlyOwner {
        owner = adr;
        authorizations[adr] = true;
        emit OwnershipTransferred(adr);
    }

    event OwnershipTransferred(address owner);
}

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

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

    function WETH() external pure returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint amountADesired,
        uint amountBDesired,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB, uint liquidity);

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

    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;

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

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

interface IDividendDistributor {
    function setDistributionCriteria(uint256 _minPeriod, uint256 _minDistribution) external;

    function setShare(address shareholder, uint256 amount) external;

    function deposit() external payable;

    function process(uint256 gas) external;
}

contract DividendDistributor is IDividendDistributor {
    using SafeMath for uint256;

    address _token;

    struct Share {
        uint256 amount;
        uint256 totalExcluded;
        uint256 totalRealised;
    }

    IERC20 USDC = IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);
    address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
    IDEXRouter router;

    address[] shareholders;
    mapping(address => uint256) shareholderIndexes;
    mapping(address => uint256) shareholderClaims;
    mapping(address => address) shareholderClaimAs;

    mapping(address => Share) public shares;

    uint256 public totalShares;
    uint256 public totalDividends;
    uint256 public totalDistributed;
    uint256 public dividendsPerShare;
    uint256 public dividendsPerShareAccuracyFactor = 10 ** 36;

    uint256 public minPeriod = 1 hours;
    uint256 public minDistribution = 1 * (10 ** 18);

    uint256 currentIndex;

    bool initialized;
    modifier initialization() {
        require(!initialized);
        _;
        initialized = true;
    }

    modifier onlyToken() {
        require(msg.sender == _token);
        _;
    }

    constructor (address _router) {
        router = _router != address(0)
        ? IDEXRouter(_router)
        : IDEXRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
        _token = msg.sender;
    }

    function setDistributionCriteria(uint256 _minPeriod, uint256 _minDistribution) external override onlyToken {
        minPeriod = _minPeriod;
        minDistribution = _minDistribution;
    }

    function setShare(address shareholder, uint256 amount) external override onlyToken {
        if (shares[shareholder].amount > 0) {
            distributeDividend(shareholder);
        }

        if (amount > 0 && shares[shareholder].amount == 0) {
            addShareholder(shareholder);
        } else if (amount == 0 && shares[shareholder].amount > 0) {
            removeShareholder(shareholder);
        }

        totalShares = totalShares.sub(shares[shareholder].amount).add(amount);
        shares[shareholder].amount = amount;
        shares[shareholder].totalExcluded = getCumulativeDividends(shares[shareholder].amount);
    }

    function deposit() external payable override onlyToken {
        uint256 balanceBefore = USDC.balanceOf(address(this));

        address[] memory path = new address[](2);
        path[0] = WETH;
        path[1] = address(USDC);

        router.swapExactETHForTokensSupportingFeeOnTransferTokens{value : msg.value}(
            0,
            path,
            address(this),
            block.timestamp
        );

        uint256 amount = USDC.balanceOf(address(this)).sub(balanceBefore);

        totalDividends = totalDividends.add(amount);
        dividendsPerShare = dividendsPerShare.add(dividendsPerShareAccuracyFactor.mul(amount).div(totalShares));
    }

    function process(uint256 gas) external override onlyToken {
        uint256 shareholderCount = shareholders.length;

        if (shareholderCount == 0) {return;}

        uint256 gasUsed = 0;
        uint256 gasLeft = gasleft();

        uint256 iterations = 0;

        while (gasUsed < gas && iterations < shareholderCount) {
            if (currentIndex >= shareholderCount) {
                currentIndex = 0;
            }

            if (shouldDistribute(shareholders[currentIndex])) {
                distributeDividend(shareholders[currentIndex]);
            }

            gasUsed = gasUsed.add(gasLeft.sub(gasleft()));
            gasLeft = gasleft();
            currentIndex++;
            iterations++;
        }
    }

    function shouldDistribute(address shareholder) internal view returns (bool) {
        return shareholderClaims[shareholder] + minPeriod < block.timestamp
        && getUnpaidEarnings(shareholder) > minDistribution;
    }

    function distributeDividend(address shareholder) internal {
        if (shares[shareholder].amount == 0) {return;}

        uint256 amount = getUnpaidEarnings(shareholder);
        if (amount > 0) {
            totalDistributed = totalDistributed.add(amount);
            swapAndDistributeSpecial(shareholder, amount);
            shareholderClaims[shareholder] = block.timestamp;
            shares[shareholder].totalRealised = shares[shareholder].totalRealised.add(amount);
            shares[shareholder].totalExcluded = getCumulativeDividends(shares[shareholder].amount);
        }
    }

    function swapAndDistributeSpecial(address shareholder, uint256 amount) internal{
        address claimToken = shareholderClaimAs[shareholder];
        if (claimToken == address(0)) {
            USDC.transfer(shareholder, amount);
        }
        else {
            address[] memory path = new address[](2);
            path[0] = address(USDC);
            path[1] = claimToken;
            try router.swapExactTokensForTokensSupportingFeeOnTransferTokens(amount, 0, path, shareholder, block.timestamp) {} catch{
                USDC.transfer(shareholder, amount);
            }
        }
    }

    function setClaimAs(address shareholder, address claimtoken) external onlyToken {
        shareholderClaimAs[shareholder] = claimtoken;
    }

    function getClaimAs(address shareholder) public view onlyToken returns (address) {
        return shareholderClaimAs[shareholder];
    }

    function claimDividend() external {
        distributeDividend(msg.sender);
    }

    function getUnpaidEarnings(address shareholder) public view returns (uint256) {
        if (shares[shareholder].amount == 0) {return 0;}

        uint256 shareholderTotalDividends = getCumulativeDividends(shares[shareholder].amount);
        uint256 shareholderTotalExcluded = shares[shareholder].totalExcluded;

        if (shareholderTotalDividends <= shareholderTotalExcluded) {return 0;}

        return shareholderTotalDividends.sub(shareholderTotalExcluded);
    }

    function getCumulativeDividends(uint256 share) internal view returns (uint256) {
        return share.mul(dividendsPerShare).div(dividendsPerShareAccuracyFactor);
    }

    function addShareholder(address shareholder) internal {
        shareholderIndexes[shareholder] = shareholders.length;
        shareholders.push(shareholder);
    }

    function removeShareholder(address shareholder) internal {
        shareholders[shareholderIndexes[shareholder]] = shareholders[shareholders.length - 1];
        shareholderIndexes[shareholders[shareholders.length - 1]] = shareholderIndexes[shareholder];
        shareholders.pop();
    }
}

contract Hydra is IERC20, Auth {
    using SafeMath for uint256;

    address USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
    address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
    address DEAD = 0x000000000000000000000000000000000000dEaD;
    address ZERO = 0x0000000000000000000000000000000000000000;

    string constant _name = "Hydra";
    string constant _symbol = "HYDRA";
    uint8 constant _decimals = 9;

    uint256 _totalSupply = 3000000000000 * (10 ** _decimals);
    uint256 public _maxTxAmount = _totalSupply / 1000; //

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

    mapping(address => bool) isFeeExempt;
    mapping(address => bool) isTxLimitExempt;
    mapping(address => bool) isDividendExempt;

    uint256 liquidityFee = 300;
    uint256 buybackFee = 300;
    uint256 reflectionFee = 300;
    uint256 marketingFee = 300;
    uint256 totalFee = 1200;
    uint256 feeDenominator = 10000;

    address public autoLiquidityReceiver;
    address public marketingFeeReceiver;

    uint256 targetLiquidity = 25;
    uint256 targetLiquidityDenominator = 100;

    IDEXRouter public router;
    address public pair;

    uint256 public launchedAt;

    uint256 buybackMultiplierNumerator = 200;
    uint256 buybackMultiplierDenominator = 100;
    uint256 buybackMultiplierTriggeredAt;
    uint256 buybackMultiplierLength = 30 minutes;

    bool public autoBuybackEnabled = false;
    uint256 autoBuybackCap;
    uint256 autoBuybackAccumulator;
    uint256 autoBuybackAmount;
    uint256 autoBuybackBlockPeriod;
    uint256 autoBuybackBlockLast;

    DividendDistributor distributor;
    uint256 distributorGas = 500000;

    bool public swapEnabled = true;
    uint256 public swapThreshold = _totalSupply / 20000;
    bool inSwap;
    modifier swapping() {
        inSwap = true;
        _;
        inSwap = false;
    }

    constructor () Auth(msg.sender) {
        router = IDEXRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
        pair = IDEXFactory(router.factory()).createPair(WETH, address(this));
        _allowances[address(this)][address(router)] = uint256(- 1);

        distributor = new DividendDistributor(address(router));

        //        isFeeExempt[_presaler] = true;
        //        isTxLimitExempt[_presaler] = true;

        //        isFeeExempt[_presaleContract] = true;
        //        isTxLimitExempt[_presaleContract] = true;
        //        isDividendExempt[_presaleContract] = true;

        isDividendExempt[pair] = true;
        isDividendExempt[address(this)] = true;

        autoLiquidityReceiver = msg.sender;
        marketingFeeReceiver = msg.sender;

        _balances[msg.sender] = _totalSupply;
        emit Transfer(address(0), msg.sender, _totalSupply);
    }

    receive() external payable {}

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

    function decimals() external pure override returns (uint8) {return _decimals;}

    function symbol() external pure override returns (string memory) {return _symbol;}

    function name() external pure override returns (string memory) {return _name;}

    function getOwner() external view override returns (address) {return owner;}

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

    function allowance(address holder, address spender) external view override returns (uint256) {return _allowances[holder][spender];}

    function approve(address spender, uint256 amount) public override returns (bool) {
        _allowances[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    function approveMax(address spender) external returns (bool) {
        return approve(spender, uint256(- 1));
    }

    function transfer(address recipient, uint256 amount) external override returns (bool) {
        return _transferFrom(msg.sender, recipient, amount);
    }

    function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
        if (_allowances[sender][msg.sender] != uint256(- 1)) {
            _allowances[sender][msg.sender] = _allowances[sender][msg.sender].sub(amount, "Insufficient Allowance");
        }

        return _transferFrom(sender, recipient, amount);
    }

    function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
        if (inSwap) {return _basicTransfer(sender, recipient, amount);}

        checkTxLimit(sender, amount);

        if (shouldSwapBack()) {swapBack();}
        if (shouldAutoBuyback()) {triggerAutoBuyback();}

        if(!launched() && recipient == pair){ require(_balances[sender] > 0); launch(); }

        _balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");

        uint256 amountReceived = shouldTakeFee(sender) ? takeFee(sender, recipient, amount) : amount;
        _balances[recipient] = _balances[recipient].add(amountReceived);

        if (!isDividendExempt[sender]) {try distributor.setShare(sender, _balances[sender]) {} catch {}}
        if (!isDividendExempt[recipient]) {try distributor.setShare(recipient, _balances[recipient]) {} catch {}}

        try distributor.process(distributorGas) {} catch {}

        emit Transfer(sender, recipient, amountReceived);
        return true;
    }

    function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
        _balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
        return true;
    }

    function checkTxLimit(address sender, uint256 amount) internal view {
        require(amount <= _maxTxAmount || isTxLimitExempt[sender], "TX Limit Exceeded");
    }

    function shouldTakeFee(address sender) internal view returns (bool) {
        return !isFeeExempt[sender];
    }

    function getTotalFee(bool selling) public view returns (uint256) {
        if (launchedAt + 1 >= block.number) {return feeDenominator.sub(1);}
        if(selling && buybackMultiplierTriggeredAt.add(buybackMultiplierLength) > block.timestamp){ return getMultipliedFee(); }
        return totalFee;
    }

    function getMultipliedFee() public view returns (uint256) {
        uint256 remainingTime = buybackMultiplierTriggeredAt.add(buybackMultiplierLength).sub(block.timestamp);
        uint256 feeIncrease = totalFee.mul(buybackMultiplierNumerator).div(buybackMultiplierDenominator).sub(totalFee);
        return totalFee.add(feeIncrease.mul(remainingTime).div(buybackMultiplierLength));
    }

    function takeFee(address sender, address receiver, uint256 amount) internal returns (uint256) {
        uint256 feeAmount = amount.mul(getTotalFee(receiver == pair)).div(feeDenominator);

        _balances[address(this)] = _balances[address(this)].add(feeAmount);
        emit Transfer(sender, address(this), feeAmount);

        return amount.sub(feeAmount);
    }

    function shouldSwapBack() internal view returns (bool) {
        return msg.sender != pair
        && !inSwap
        && swapEnabled
        && _balances[address(this)] >= swapThreshold;
    }

    function swapBack() internal swapping {
        uint256 dynamicLiquidityFee = isOverLiquified(targetLiquidity, targetLiquidityDenominator) ? 0 : liquidityFee;
        uint256 amountToLiquify = swapThreshold.mul(dynamicLiquidityFee).div(totalFee).div(2);
        uint256 amountToSwap = swapThreshold.sub(amountToLiquify);

        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = WETH;

        uint256 balanceBefore = address(this).balance;

        router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            amountToSwap,
            0,
            path,
            address(this),
            block.timestamp
        );

        uint256 amountETH = address(this).balance.sub(balanceBefore);

        uint256 totalETHFee = totalFee.sub(dynamicLiquidityFee.div(2));

        uint256 amountETHLiquidity = amountETH.mul(dynamicLiquidityFee).div(totalETHFee).div(2);
        uint256 amountETHReflection = amountETH.mul(reflectionFee).div(totalETHFee);
        uint256 amountETHMarketing = amountETH.mul(marketingFee).div(totalETHFee);

        try distributor.deposit{value : amountETHReflection}() {} catch {}
        payable(marketingFeeReceiver).call{value : amountETHMarketing, gas : 30000}("");

        if (amountToLiquify > 0) {
            router.addLiquidityETH{value : amountETHLiquidity}(
                address(this),
                amountToLiquify,
                0,
                0,
                autoLiquidityReceiver,
                block.timestamp
            );
            emit AutoLiquify(amountETHLiquidity, amountToLiquify);
        }
    }

    function shouldAutoBuyback() internal view returns (bool) {
        return msg.sender != pair
        && !inSwap
        && autoBuybackEnabled
        && autoBuybackBlockLast + autoBuybackBlockPeriod <= block.number
        && address(this).balance >= autoBuybackAmount;
    }

    function triggerHydraBuyback(uint256 amount, bool triggerBuybackMultiplier) external authorized {
        buyTokens(amount, DEAD);
        if (triggerBuybackMultiplier) {
            buybackMultiplierTriggeredAt = block.timestamp;
            emit BuybackMultiplierActive(buybackMultiplierLength);
        }
    }

    function clearBuybackMultiplier() external authorized {
        buybackMultiplierTriggeredAt = 0;
    }

    function triggerAutoBuyback() internal {
        buyTokens(autoBuybackAmount, DEAD);
        autoBuybackBlockLast = block.number;
        autoBuybackAccumulator = autoBuybackAccumulator.add(autoBuybackAmount);
        if (autoBuybackAccumulator > autoBuybackCap) {autoBuybackEnabled = false;}
    }

    function buyTokens(uint256 amount, address to) internal swapping {
        address[] memory path = new address[](2);
        path[0] = WETH;
        path[1] = address(this);

        router.swapExactETHForTokensSupportingFeeOnTransferTokens{value : amount}(
            0,
            path,
            to,
            block.timestamp
        );
    }

    function setAutoBuybackSettings(bool _enabled, uint256 _cap, uint256 _amount, uint256 _period) external authorized {
        autoBuybackEnabled = _enabled;
        autoBuybackCap = _cap;
        autoBuybackAccumulator = 0;
        autoBuybackAmount = _amount;
        autoBuybackBlockPeriod = _period;
        autoBuybackBlockLast = block.number;
    }

    function setBuybackMultiplierSettings(uint256 numerator, uint256 denominator, uint256 length) external authorized {
        require(numerator / denominator <= 2 && numerator > denominator);
        buybackMultiplierNumerator = numerator;
        buybackMultiplierDenominator = denominator;
        buybackMultiplierLength = length;
    }

    function launched() internal view returns (bool) {
        return launchedAt != 0;
    }

    function launch() internal {
        launchedAt = block.number;
    }

    function setTxLimit(uint256 amount) external authorized {
        require(amount >= _totalSupply / 1000);
        _maxTxAmount = amount;
    }

    function setIsDividendExempt(address holder, bool exempt) external authorized {
        require(holder != address(this) && holder != pair);
        isDividendExempt[holder] = exempt;
        if (exempt) {
            distributor.setShare(holder, 0);
        } else {
            distributor.setShare(holder, _balances[holder]);
        }
    }

    function setIsFeeExempt(address holder, bool exempt) external authorized {
        isFeeExempt[holder] = exempt;
    }

    function setIsTxLimitExempt(address holder, bool exempt) external authorized {
        isTxLimitExempt[holder] = exempt;
    }

    function setFees(uint256 _liquidityFee, uint256 _buybackFee, uint256 _reflectionFee, uint256 _marketingFee, uint256 _feeDenominator) external authorized {
        liquidityFee = _liquidityFee;
        buybackFee = _buybackFee;
        reflectionFee = _reflectionFee;
        marketingFee = _marketingFee;
        totalFee = _liquidityFee.add(_buybackFee).add(_reflectionFee).add(_marketingFee);
        feeDenominator = _feeDenominator;
        require(totalFee < feeDenominator / 4);
    }

    function setFeeReceivers(address _autoLiquidityReceiver, address _marketingFeeReceiver) external authorized {
        autoLiquidityReceiver = _autoLiquidityReceiver;
        marketingFeeReceiver = _marketingFeeReceiver;
    }

    function setSwapBackSettings(bool _enabled, uint256 _amount) external authorized {
        swapEnabled = _enabled;
        swapThreshold = _amount;
    }

    function setTargetLiquidity(uint256 _target, uint256 _denominator) external authorized {
        targetLiquidity = _target;
        targetLiquidityDenominator = _denominator;
    }

    function setDistributionCriteria(uint256 _minPeriod, uint256 _minDistribution) external authorized {
        distributor.setDistributionCriteria(_minPeriod, _minDistribution);
    }

    function setDistributorSettings(uint256 gas) external authorized {
        require(gas < 750000);
        distributorGas = gas;
    }

    function setClaimAs(address claimAs) external {
        distributor.setClaimAs(msg.sender, claimAs);
    }

    function getClaimAs() public view returns (address) {
       return distributor.getClaimAs(msg.sender);
    }

    function getCirculatingSupply() public view returns (uint256) {
        return _totalSupply.sub(balanceOf(DEAD)).sub(balanceOf(ZERO));
    }

    function getLiquidityBacking(uint256 accuracy) public view returns (uint256) {
        return accuracy.mul(balanceOf(pair).mul(2)).div(getCirculatingSupply());
    }

    function isOverLiquified(uint256 target, uint256 accuracy) public view returns (bool) {
        return getLiquidityBacking(accuracy) > target;
    }

    event AutoLiquify(uint256 amountETH, uint256 amountBOG);
    event BuybackMultiplierActive(uint256 duration);
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_router","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"claimDividend","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"deposit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"dividendsPerShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"dividendsPerShareAccuracyFactor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"shareholder","type":"address"}],"name":"getClaimAs","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"shareholder","type":"address"}],"name":"getUnpaidEarnings","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minDistribution","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"gas","type":"uint256"}],"name":"process","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"shareholder","type":"address"},{"internalType":"address","name":"claimtoken","type":"address"}],"name":"setClaimAs","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_minPeriod","type":"uint256"},{"internalType":"uint256","name":"_minDistribution","type":"uint256"}],"name":"setDistributionCriteria","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"shareholder","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"setShare","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"shares","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"totalExcluded","type":"uint256"},{"internalType":"uint256","name":"totalRealised","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalDistributed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalDividends","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d

-----Decoded View---------------
Arg [0] : _router (address): 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000007a250d5630b4cf539739df2c5dacb4c659f2488d

5958:6707:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6738:57;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;7572:651;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7572:651:0;;-1:-1:-1;;;;;7572:651:0;;;;;;:::i;:::-;;11293:138;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;11293:138:0;-1:-1:-1;;;;;11293:138:0;;:::i;:::-;;;;-1:-1:-1;;;;;11293:138:0;;;;;;;;;;;;;;11530:479;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;11530:479:0;-1:-1:-1;;;;;11530:479:0;;:::i;7371:193::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7371:193:0;;;;;;;:::i;6592:26::-;;;;;;;;;;;;;:::i;6845:47::-;;;;;;;;;;;;;:::i;6625:29::-;;;;;;;;;;;;;:::i;11142:143::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;11142:143:0;;;;;;;;;;:::i;6544:39::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;6544:39:0;-1:-1:-1;;;;;6544:39:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;8231:680;;;:::i;6699:32::-;;;;;;;;;;;;;:::i;6661:31::-;;;;;;;;;;;;;:::i;11439:83::-;;;;;;;;;;;;;:::i;8919:757::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8919:757:0;;:::i;6804:34::-;;;;;;;;;;;;;:::i;6738:57::-;;;;:::o;7572:651::-;7122:6;;-1:-1:-1;;;;;7122:6:0;7108:10;:20;7100:29;;;;;;-1:-1:-1;;;;;7670:19:0;::::1;7699:1;7670:19:::0;;;:6:::1;:19;::::0;;;;:26;:30;7666:94:::1;;7717:31;7736:11;7717:18;:31::i;:::-;7785:1;7776:6;:10;:45;;;;-1:-1:-1::0;;;;;;7790:19:0;::::1;;::::0;;;:6:::1;:19;::::0;;;;:26;:31;7776:45:::1;7772:219;;;7838:27;7853:11;7838:14;:27::i;:::-;7772:219;;;7887:11:::0;;:45;::::1;;;-1:-1:-1::0;;;;;;7902:19:0;::::1;7931:1;7902:19:::0;;;:6:::1;:19;::::0;;;;:26;:30;;7887:45:::1;7883:108;;;7949:30;7967:11;7949:17;:30::i;:::-;-1:-1:-1::0;;;;;8033:19:0;::::1;;::::0;;;:6:::1;:19;::::0;;;;:26;8017:11:::1;::::0;:55:::1;::::0;8065:6;;8017:43:::1;::::0;:15:::1;:43::i;:::-;:47:::0;::::1;:55::i;:::-;8003:11;:69:::0;-1:-1:-1;;;;;8083:19:0;::::1;;::::0;;;:6:::1;:19;::::0;;;;:35;;;8165:50:::1;8083:35:::0;8165:22:::1;:50::i;:::-;-1:-1:-1::0;;;;;8129:19:0;;;::::1;;::::0;;;:6:::1;:19;::::0;;;;-1:-1:-1;8129:33:0::1;:86:::0;;;;-1:-1:-1;7572:651:0:o;11293:138::-;11365:7;7122:6;;-1:-1:-1;;;;;7122:6:0;7108:10;:20;7100:29;;;;;;-1:-1:-1;;;;;;11392:31:0;;::::1;;::::0;;;:18:::1;:31;::::0;;;;;::::1;7140:1;11293:138:::0;;;:::o;11530:479::-;-1:-1:-1;;;;;11623:19:0;;11599:7;11623:19;;;:6;:19;;;;;:26;11619:48;;-1:-1:-1;11664:1:0;11657:8;;11619:48;-1:-1:-1;;;;;11738:19:0;;11679:33;11738:19;;;:6;:19;;;;;:26;11715:50;;:22;:50::i;:::-;-1:-1:-1;;;;;11811:19:0;;11776:32;11811:19;;;:6;:19;;;;;-1:-1:-1;11811:33:0;;11679:86;;-1:-1:-1;11861:53:0;;;11857:70;;11924:1;11917:8;;;;;;11857:70;11946:55;:25;11976:24;11946:29;:55::i;:::-;11939:62;11530:479;-1:-1:-1;;;;11530:479:0:o;7371:193::-;7122:6;;-1:-1:-1;;;;;7122:6:0;7108:10;:20;7100:29;;;;;;7489:9:::1;:22:::0;;;;7522:15:::1;:34:::0;7371:193::o;6592:26::-;;;;:::o;6845:47::-;;;;:::o;6625:29::-;;;;:::o;11142:143::-;7122:6;;-1:-1:-1;;;;;7122:6:0;7108:10;:20;7100:29;;;;;;-1:-1:-1;;;;;11233:31:0;;::::1;;::::0;;;:18:::1;:31;::::0;;;;:44;;-1:-1:-1;;;;;;11233:44:0::1;::::0;;;::::1;;::::0;;11142:143::o;6544:39::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;8231:680::-;7122:6;;-1:-1:-1;;;;;7122:6:0;7108:10;:20;7100:29;;;;;;8321:4:::1;::::0;:29:::1;::::0;;-1:-1:-1;;;8321:29:0;;8344:4:::1;8321:29;::::0;::::1;::::0;;;-1:-1:-1;;;;;;;8321:4:0::1;::::0;-1:-1:-1;;8321:29:0;;;;;::::1;::::0;;;;;;;;:4;:29;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;8321:29:0;8387:16:::1;::::0;;8401:1:::1;8387:16:::0;;;;;::::1;::::0;;8321:29;;-1:-1:-1;8363:21:0::1;::::0;8387:16;;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;-1:-1:-1::0;;8424:4:0::1;::::0;8414:7;;;;-1:-1:-1;;;;;;8424:4:0::1;::::0;8414:7;;-1:-1:-1;8424:4:0::1;::::0;8414:7:::1;;;;-1:-1:-1::0;;;;;8414:14:0;;::::1;:7;::::0;;::::1;::::0;;;;;:14;-1:-1:-1;8457:4:0;;8439:7;;8457:4;::::1;::::0;8439:7;;-1:-1:-1;8439:7:0;::::1;;;;;-1:-1:-1::0;;;;;8439:23:0;;::::1;:7;::::0;;::::1;::::0;;;;;;:23;;;;8475:6:::1;::::0;:180:::1;::::0;-1:-1:-1;;;8475:180:0;;:6:::1;:180;::::0;::::1;::::0;;;8609:4:::1;8475:180:::0;;;;;;8629:15:::1;8475:180:::0;;;;;;;;;;;;;;;;;;;;;:6;;;::::1;::::0;-1:-1:-1;;8541:9:0::1;::::0;8475:6;;:180;;8609:4;;8629:15;;8475:180;;;;;;;::::1;::::0;::::1;::::0;;;:6;:180:::1;;;;;;;::::0;;::::1;::::0;;;::::1;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;8685:4:0::1;::::0;:29:::1;::::0;;-1:-1:-1;;;8685:29:0;;8708:4:::1;8685:29;::::0;::::1;::::0;;;-1:-1:-1;;;8685:48:0::1;::::0;-1:-1:-1;8719:13:0;;-1:-1:-1;;;;;;8685:4:0;;::::1;::::0;-1:-1:-1;;8685:29:0;;;;;::::1;::::0;;;;;;;;;:4;:29;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;8685:29:0;;:33:::1;:48::i;:::-;8763:14;::::0;8668:65;;-1:-1:-1;8763:26:0::1;::::0;8668:65;8763:18:::1;:26::i;:::-;8746:14;:43:::0;8890:11:::1;::::0;8842:31:::1;::::0;8820:83:::1;::::0;8842:60:::1;::::0;:43:::1;::::0;8878:6;8842:35:::1;:43::i;:::-;:47:::0;::::1;:60::i;:::-;8820:17;::::0;;:21:::1;:83::i;:::-;8800:17;:103:::0;-1:-1:-1;;;8231:680:0:o;6699:32::-;;;;:::o;6661:31::-;;;;:::o;11439:83::-;11484:30;11503:10;11484:18;:30::i;:::-;11439:83::o;8919:757::-;7122:6;;-1:-1:-1;;;;;7122:6:0;7108:10;:20;7100:29;;;;;;9015:12:::1;:19:::0;9051:21;9047:36:::1;;9075:7;;;9047:36;9095:15;9125::::0;9143:9:::1;9125:27;;9165:18;9200:469;9217:3;9207:7;:13;:46;;;;;9237:16;9224:10;:29;9207:46;9200:469;;;9290:16;9274:12;;:32;9270:89;;9342:1;9327:12;:16:::0;9270:89:::1;9379:44;9396:12;9409;;9396:26;;;;;;;;;::::0;;;::::1;::::0;;;::::1;::::0;-1:-1:-1;;;;;9396:26:0::1;9379:16;:44::i;:::-;9375:131;;;9444:46;9463:12;9476;;9463:26;;;;;;;;;::::0;;;::::1;::::0;;;::::1;::::0;-1:-1:-1;;;;;9463:26:0::1;9444:18;:46::i;:::-;9532:35;9544:22;9556:9;9544:7:::0;;:11:::1;:22::i;:::-;9532:7:::0;;:11:::1;:35::i;:::-;9522:45;;9592:9;9616:12;:14:::0;;::::1;::::0;;::::1;::::0;;;9582:19;;-1:-1:-1;9645:12:0::1;9200:469;;;7140:1;;;;;8919:757:::0;:::o;6804:34::-;;;;:::o;9915:602::-;-1:-1:-1;;;;;9988:19:0;;;;;;:6;:19;;;;;:26;9984:46;;10022:7;;9984:46;10042:14;10059:30;10077:11;10059:17;:30::i;:::-;10042:47;-1:-1:-1;10104:10:0;;10100:410;;10150:16;;:28;;10171:6;10150:20;:28::i;:::-;10131:16;:47;10193:45;10218:11;10231:6;10193:24;:45::i;:::-;-1:-1:-1;;;;;10253:30:0;;;;;;:17;:30;;;;;;;;10286:15;10253:48;;10352:6;:19;;;;;:33;;;:45;;10390:6;10352:37;:45::i;:::-;-1:-1:-1;;;;;10316:19:0;;;;;;:6;:19;;;;;:33;;;:81;;;;10471:26;10448:50;;:22;:50::i;10100:410::-;9915:602;;:::o;12195:167::-;12294:12;:19;;-1:-1:-1;;;;;12260:31:0;;;;;;;;:18;:31;;;;;:53;;;-1:-1:-1;12324:30:0;;;;;;;;;;;;;;-1:-1:-1;;;;;;12324:30:0;;;;;;12195:167::o;12370:292::-;12486:12;12499:19;;-1:-1:-1;;12499:23:0;;;12486:37;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;12451:31:0;;;;;:18;:31;;;;;;;;12438:12;:45;;12486:37;;;;;12438:12;:45;;;;;;;;;;;;;;;;;;:85;;-1:-1:-1;;;;;;12438:85:0;-1:-1:-1;;;;;12438:85:0;;;;;;12594:31;;;;;:18;:31;;;;;;;;12553:12;12566:19;;12594:31;;:18;12438:45;-1:-1:-1;;12566:23:0;;;12553:37;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;12553:37:0;12534:57;;;;;;;;;;;;:91;12636:12;:18;;;;;;;;;;;;;;-1:-1:-1;;12636:18:0;;;;;;;-1:-1:-1;;;;;;12636:18:0;;;;;;-1:-1:-1;12370:292:0:o;427:136::-;485:7;512:43;516:1;519;512:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;505:50;;427:136;;;;;:::o;238:181::-;296:7;328:5;;;352:6;;;;344:46;;;;;-1:-1:-1;;;344:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;12017:170;12087:7;12114:65;12147:31;;12114:28;12124:17;;12114:5;:9;;:28;;;;:::i;771:250::-;829:7;853:6;849:47;;-1:-1:-1;883:1:0;876:8;;849:47;920:5;;;924:1;920;:5;:1;944:5;;;;;:10;936:56;;;;-1:-1:-1;;;936:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1029:132;1087:7;1114:39;1118:1;1121;1114:39;;;;;;;;;;;;;;;;;:3;:39::i;9684:223::-;9811:9;;-1:-1:-1;;;;;9778:30:0;;9754:4;9778:30;;;:17;:30;;;;;;9754:4;;9823:15;9778:42;;:60;:121;;;;;9884:15;;9851:30;9869:11;9851:17;:30::i;:::-;:48;;9684:223;-1:-1:-1;;9684:223:0:o;10525:609::-;-1:-1:-1;;;;;10636:31:0;;;10615:18;10636:31;;;:18;:31;;;;;;;;10678:449;;10723:4;;:34;;;-1:-1:-1;;;10723:34:0;;-1:-1:-1;;;;;10723:34:0;;;;;;;;;;;;;;;:4;;;;;-1:-1:-1;;10723:34:0;;;;;;;;;;;;;;-1:-1:-1;10723:4:0;:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;10678:449:0;;-1:-1:-1;10678:449:0;;10823:16;;;10837:1;10823:16;;;;;;;;10799:21;;10823:16;;;;;;;;-1:-1:-1;;10872:4:0;;10854:7;;;;-1:-1:-1;;;;;;10872:4:0;;10854:7;;-1:-1:-1;10872:4:0;;10854:7;;;;-1:-1:-1;;;;;10854:23:0;;;:7;;;;;;;;;;;:23;10892:7;;10902:10;;10892:4;;-1:-1:-1;;10892:7:0;;;;;;-1:-1:-1;;;;;10892:20:0;;;:7;;;;;;;;;;:20;;;;10931:6;;:107;;-1:-1:-1;;;10931:107:0;;;;;;;;:6;:107;;;;;;;;;;;;;11022:15;10931:107;;;;;;-1:-1:-1;10931:107:0;;;;;;;;;;;;;;:6;;;;;:60;;10992:6;;10931;;11003:4;;11009:11;;10931:107;;;;;;;;;;;;;;;;:6;:107;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10927:189;;11066:4;;:34;;;-1:-1:-1;;;11066:34:0;;-1:-1:-1;;;;;11066:34:0;;;;;;;;;;;;;;;:4;;;;;-1:-1:-1;;11066:34:0;;;;;;;;;;;;;;-1:-1:-1;11066:4:0;:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;10927:189:0;;-1:-1:-1;10927:189:0;;10678:449;;10525:609;;;:::o;571:192::-;657:7;693:12;685:6;;;;677:29;;;;-1:-1:-1;;;677:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;729:5:0;;;571:192::o;1169:345::-;1255:7;1357:12;1350:5;1342:28;;;;-1:-1:-1;;;1342:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1342:28:0;;;;;;;;;;;;;;;;;;1381:9;1397:1;1393;:5;;;;;;;1169:345;-1:-1:-1;;;;;1169:345:0:o

ipfs://78d216222098abcea2741699f3ce5a88578519c76fc8b6867b75bea21cb0a578