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 2022-07-30
*/

// SPDX-License-Identifier: MIT

/***                   
    Earn LSVR Rewards while holding $RETNIRP. 
    The marketing tax "LSVR LP" will be used to add LSVR LP.

    Telegram: t.me/retnirp
    Website: retnirp.io/
***/

pragma solidity ^0.8.0;

/**
 * SAFEMATH LIBRARY
 */
library SafeMath {
    function tryAdd(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    function trySub(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    function tryMul(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    function tryDiv(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    function tryMod(uint256 a, uint256 b)
        internal
        pure
        returns (bool, uint256)
    {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

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

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

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

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

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 IFactory {
    function createPair(address tokenA, address tokenB)
        external
        returns (address pair);
}

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

    function WETH() external pure returns (address);

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

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

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

    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 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; // excluded dividend
        uint256 totalRealised;
    }

    IERC20 LSVR = IERC20(0x79A06aCb8bdd138BEEECcE0f1605971f3AC7c09B);
    address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
    IRouter router;

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

    mapping(address => Share) public shares;

    uint256 public totalShares;
    uint256 public totalDividends;
    uint256 public totalDistributed; // to be shown in UI
    uint256 public dividendsPerShare;
    uint256 public dividendsPerShareAccuracyFactor = 10**36;

    uint256 public minPeriod = 1 hours;
    uint256 public minDistribution = 10 * (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)
            ? IRouter(_router)
            : IRouter(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 = LSVR.balanceOf(address(this));

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

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

        uint256 amount = LSVR.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);
            LSVR.transfer(shareholder, amount);
            shareholderClaims[shareholder] = block.timestamp;
            shares[shareholder].totalRealised = shares[shareholder]
                .totalRealised
                .add(amount);
            shares[shareholder].totalExcluded = getCumulativeDividends(
                shares[shareholder].amount
            );
        }
    }

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

    /*
        returns the  unpaid earnings
    */
    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 RETNIRP is IERC20, Auth {
    using SafeMath for uint256;

    address LSVR = 0x79A06aCb8bdd138BEEECcE0f1605971f3AC7c09B;
    address public WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
    address DEAD = 0x000000000000000000000000000000000000dEaD;
    address ZERO = 0x0000000000000000000000000000000000000000;

    string constant _name = "RETNIRP";
    string constant _symbol = "TNRP";
    uint8 constant _decimals = 6;

    uint256 _totalSupply = 1_000_000_000_000_000 * (10**_decimals);
    uint256 public _maxTxAmount = _totalSupply.div(40); // 2,5%
    uint256 public _maxWallet = _totalSupply.div(40); // 2,5%

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

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

    uint256 liquidityFee = 100;
    uint256 reflectionFee = 200;
    uint256 marketingFee = 300;
    uint256 totalFee = 1700;
    uint256 feeDenominator = 10000;

    address public autoLiquidityReceiver =
        0x2551Fd55DDb806bDDe08d6Cf2FBEdF164d9BF1a3;
    address public marketingFeeReceiver =
        0x2551Fd55DDb806bDDe08d6Cf2FBEdF164d9BF1a3;

    uint256 targetLiquidity = 10;
    uint256 targetLiquidityDenominator = 100;

    IRouter public router;
    address public pair;

    uint256 public launchedAt;
    uint256 public launchedAtTimestamp;

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

    DividendDistributor distributor;
    address public distributorAddress;

    uint256 distributorGas = 500000;

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

    constructor() Auth(msg.sender) {
        address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
        router = IRouter(_router);
        pair = IFactory(router.factory()).createPair(WETH, address(this));
        _allowances[address(this)][address(router)] = _totalSupply;
        WETH = router.WETH();
        distributor = new DividendDistributor(_router);
        distributorAddress = address(distributor);

        isFeeExempt[msg.sender] = true;
        isTxLimitExempt[msg.sender] = true;
        isDividendExempt[pair] = true;
        isDividendExempt[address(this)] = true;
        isDividendExempt[DEAD] = true;

        autoLiquidityReceiver = msg.sender;

        approve(_router, _totalSupply);
        approve(address(pair), _totalSupply);
        _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, _totalSupply);
    }

    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] != _totalSupply) {
            _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);
        }

        // Max TX Check
        address routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
        bool isSell = recipient == pair || recipient == routerAddress;
        checkTxLimit(sender, amount);

        // Max wallet check excluding pair and router
        if (!isSell && !_isFree[recipient]) {
            require(
                (_balances[recipient] + amount) < _maxWallet,
                "Max wallet has been triggered"
            );
        }

        // No swapping on buy and tx
        if (isSell) {
            if (shouldSwapBack()) {
                swapBack();
            }
            if (shouldAutoBuyback()) {
                triggerAutoBuyback();
            }
        }

        _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);
        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) {
        return totalFee;
    }

    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).transfer(amountETHMarketing);

        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 && // After N blocks from last buyback
            address(this).balance >= autoBuybackAmount;
    }

    function triggerZeusBuyback(uint256 amount, bool triggerBuybackMultiplier)
        external
        authorized
    {
        buyTokens(amount, DEAD);
        if (triggerBuybackMultiplier) {}
    }

    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 Sweep() external onlyOwner {
        uint256 balance = address(this).balance;
        payable(msg.sender).transfer(balance);
    }

    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 launched() internal view returns (bool) {
        return launchedAt != 0;
    }

    function launch() public authorized {
        require(launchedAt == 0, "Already launched boi");
        launchedAt = block.number;
        launchedAtTimestamp = block.timestamp;
    }

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

    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 setFree(address holder) public onlyOwner {
        _isFree[holder] = true;
    }

    function unSetFree(address holder) public onlyOwner {
        _isFree[holder] = false;
    }

    function checkFree(address holder) public view returns (bool) {
        return _isFree[holder];
    }

    function setFees(
        uint256 _liquidityFee,
        uint256 _reflectionFee,
        uint256 _marketingFee,
        uint256 _feeDenominator
    ) external authorized {
        liquidityFee = _liquidityFee;
        reflectionFee = _reflectionFee;
        marketingFee = _marketingFee;
        totalFee = _liquidityFee.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 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":"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":"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

7774:6247:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8540:55;;;;;;;;;;;;;;;;;;;3097:25:1;;;3085:2;3070:18;8540:55:0;;;;;;;;9397:707;;;;;;;;;;-1:-1:-1;9397:707:0;;;;;:::i;:::-;;:::i;:::-;;12689:583;;;;;;;;;;-1:-1:-1;12689:583:0;;;;;:::i;:::-;;:::i;9171:218::-;;;;;;;;;;-1:-1:-1;9171:218:0;;;;;:::i;:::-;;:::i;8373:26::-;;;;;;;;;;;;;;;;8645:46;;;;;;;;;;;;;;;;8406:29;;;;;;;;;;;;;;;;8325:39;;;;;;;;;;-1:-1:-1;8325:39:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3335:25:1;;;3391:2;3376:18;;3369:34;;;;3419:18;;;3412:34;3323:2;3308:18;8325:39:0;3133:319:1;10112:664:0;;;:::i;8501:32::-;;;;;;;;;;;;;;;;8442:31;;;;;;;;;;;;;;;;12544:83;;;;;;;;;;;;;:::i;10784:781::-;;;;;;;;;;-1:-1:-1;10784:781:0;;;;;:::i;:::-;;:::i;8604:34::-;;;;;;;;;;;;;;;;9397:707;8921:6;;-1:-1:-1;;;;;8921:6:0;8907:10;:20;8899:29;;;;;;-1:-1:-1;;;;;9527:19:0;::::1;9556:1;9527:19:::0;;;:6:::1;:19;::::0;;;;:26;:30;9523:94:::1;;9574:31;9593:11;9574:18;:31::i;:::-;9642:1;9633:6;:10;:45;;;;-1:-1:-1::0;;;;;;9647:19:0;::::1;;::::0;;;:6:::1;:19;::::0;;;;:26;:31;9633:45:::1;9629:219;;;13602:12:::0;:19;;-1:-1:-1;;;;;13568:31:0;;;;;;:18;:31;;;;;:53;;;-1:-1:-1;13632:30:0;;;;;;;;;;;;-1:-1:-1;;;;;;13632:30:0;;;;;;9629:219:::1;;;9744:11:::0;;:45;::::1;;;-1:-1:-1::0;;;;;;9759:19:0;::::1;9788:1;9759:19:::0;;;:6:::1;:19;::::0;;;;:26;:30;;9744:45:::1;9740:108;;;9806:30;9824:11;9806:17;:30::i;:::-;-1:-1:-1::0;;;;;9890:19:0;::::1;;::::0;;;:6:::1;:19;::::0;;;;:26;9874:11:::1;::::0;:55:::1;::::0;9922:6;;9874:43:::1;::::0;:15:::1;:43::i;:::-;:47:::0;::::1;:55::i;:::-;9860:11;:69:::0;-1:-1:-1;;;;;9940:19:0;::::1;;::::0;;;:6:::1;:19;::::0;;;;:35;;;10022:74:::1;9940:35:::0;10022:22:::1;:74::i;:::-;-1:-1:-1::0;;;;;9986:19:0;;;::::1;;::::0;;;:6:::1;:19;::::0;;;;-1:-1:-1;9986:33:0::1;:110:::0;;;;-1:-1:-1;9397:707:0:o;12689:583::-;-1:-1:-1;;;;;12814:19:0;;12785:7;12814:19;;;:6;:19;;;;;:26;12810:72;;-1:-1:-1;12869:1:0;;12689:583;-1:-1:-1;12689:583:0:o;12810:72::-;-1:-1:-1;;;;;12967:19:0;;12894:33;12967:19;;;:6;:19;;;;;:26;12930:74;;:22;:74::i;:::-;-1:-1:-1;;;;;13050:19:0;;13015:32;13050:19;;;:6;:19;;;;;-1:-1:-1;13050:33:0;;12894:110;;-1:-1:-1;13100:53:0;;;13096:94;;-1:-1:-1;13177:1:0;;12689:583;-1:-1:-1;;;12689:583:0:o;13096:94::-;13209:55;:25;13239:24;13209:29;:55::i;:::-;13202:62;12689:583;-1:-1:-1;;;;12689:583:0:o;9171:218::-;8921:6;;-1:-1:-1;;;;;8921:6:0;8907:10;:20;8899:29;;;;;;9314:9:::1;:22:::0;;;;9347:15:::1;:34:::0;9171:218::o;10112:664::-;8921:6;;-1:-1:-1;;;;;8921:6:0;8907:10;:20;8899:29;;;;;;10202:4:::1;::::0;:29:::1;::::0;-1:-1:-1;;;10202:29:0;;10225:4:::1;10202:29;::::0;::::1;1697:51:1::0;10178:21:0::1;::::0;-1:-1:-1;;;;;10202:4:0::1;::::0;:14:::1;::::0;1670:18:1;;10202:29:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;10268:16;::::0;;10282:1:::1;10268:16:::0;;;;;::::1;::::0;;10178:53;;-1:-1:-1;10244:21:0::1;::::0;10268:16;;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;-1:-1:-1::0;;10305:4:0::1;::::0;10295:7;;;;-1:-1:-1;;;;;;10305:4:0::1;::::0;10295:7;;-1:-1:-1;10305:4:0::1;::::0;10295:7:::1;;;;:::i;:::-;-1:-1:-1::0;;;;;10295:14:0;;::::1;:7;::::0;;::::1;::::0;;;;;:14;-1:-1:-1;10338:4:0;;10320:7;;10338:4;::::1;::::0;10320:7;;-1:-1:-1;10320:7:0;::::1;;;;;:::i;:::-;-1:-1:-1::0;;;;;10320:23:0;;::::1;:7;::::0;;::::1;::::0;;;;;:23;10356:6:::1;::::0;:140:::1;::::0;-1:-1:-1;;;10356:140:0;;:6;::::1;::::0;-1:-1:-1;;10435:9:0::1;::::0;10356:140:::1;::::0;:6:::1;::::0;10459:4;;10473::::1;::::0;10480:15:::1;::::0;10356:140:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;;10526:4:0::1;::::0;:29:::1;::::0;-1:-1:-1;;;10526:29:0;;10549:4:::1;10526:29;::::0;::::1;1697:51:1::0;10509:14:0::1;::::0;-1:-1:-1;10526:48:0::1;::::0;-1:-1:-1;10560:13:0;;-1:-1:-1;;;;;;10526:4:0;;::::1;::::0;:14:::1;::::0;1670:18:1;;10526:29:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:33:::0;::::1;:48::i;:::-;10604:14;::::0;10509:65;;-1:-1:-1;10604:26:0::1;::::0;10509:65;10604:18:::1;:26::i;:::-;10587:14;:43:::0;10745:11:::1;::::0;10697:31:::1;::::0;10661:107:::1;::::0;10697:60:::1;::::0;:43:::1;::::0;10733:6;10697:35:::1;:43::i;:::-;:47:::0;::::1;:60::i;:::-;10661:17;::::0;;:21:::1;:107::i;:::-;10641:17;:127:::0;-1:-1:-1;;;10112:664:0:o;12544:83::-;12589:30;12608:10;12589:18;:30::i;:::-;12544:83::o;10784:781::-;8921:6;;-1:-1:-1;;;;;8921:6:0;8907:10;:20;8899:29;;;;;;10880:12:::1;:19:::0;10916:21;10912:60:::1;;10954:7;10784:781:::0;:::o;10912:60::-:1;10984:15;11014::::0;11032:9:::1;11014:27;;11054:18;11089:469;11106:3;11096:7;:13;:46;;;;;11126:16;11113:10;:29;11096:46;11089:469;;;11179:16;11163:12;;:32;11159:89;;11231:1;11216:12;:16:::0;11159:89:::1;11268:44;11285:12;11298;;11285:26;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;-1:-1:-1;;;;;11285:26:0::1;11268:16;:44::i;:::-;11264:131;;;11333:46;11352:12;11365;;11352:26;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;-1:-1:-1;;;;;11352:26:0::1;11333:18;:46::i;:::-;11421:35;11433:22;11445:9;11433:7:::0;;:11:::1;:22::i;:::-;11421:7:::0;;:11:::1;:35::i;:::-;11411:45;;11481:9;11505:12;:14:::0;;11471:19;;-1:-1:-1;11505:12:0::1;:14;::::0;::::1;:::i;:::-;;;;;;11534:12;;;;;:::i;:::-;;;;11089:469;;;10842:723;;;;10784:781:::0;:::o;11853:683::-;-1:-1:-1;;;;;11926:19:0;;;;;;:6;:19;;;;;:26;11922:70;;11853:683;:::o;11922:70::-;12004:14;12021:30;12039:11;12021:17;:30::i;:::-;12004:47;-1:-1:-1;12066:10:0;;12062:467;;12112:16;;:28;;12133:6;12112:20;:28::i;:::-;12093:16;:47;12155:4;;:34;;-1:-1:-1;;;12155:34:0;;-1:-1:-1;;;;;1951:32:1;;;12155:34:0;;;1933:51:1;2000:18;;;1993:34;;;12155:4:0;;;;:13;;1906:18:1;;12155:34:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;;12204:30:0;;;;;;:17;:30;;;;;;;;12237:15;12204:48;;12303:6;:19;;;;;:51;;;:81;;12377:6;12303:73;:81::i;:::-;-1:-1:-1;;;;;12267:19:0;;;;;;:6;:19;;;;;:33;;;:117;;;;12476:26;12435:82;;:22;:82::i;12062:467::-;11911:625;11853:683;:::o;13678:340::-;13794:12;13821:19;;:23;;13843:1;;13821:23;:::i;:::-;13794:61;;;;;;;;:::i;:::-;;;;;;;;;;;;;;-1:-1:-1;;;;;13759:31:0;;;;;:18;:31;;;;;;;;13746:12;:45;;13794:61;;;;;13746:12;:45;;;;;;:::i;:::-;;;;;;;;;;;;;:109;;-1:-1:-1;;;;;;13746:109:0;-1:-1:-1;;;;;13746:109:0;;;;;;13950:31;;;;;:18;:31;;;;;;;;13899:12;13912:19;;13950:31;;:18;13746:45;13912:23;;-1:-1:-1;;13912:23:0;:::i;:::-;13899:37;;;;;;;;:::i;:::-;;;;;;;;;;;;;;-1:-1:-1;;;;;13899:37:0;13866:81;;;;;;;;;;;;:115;13992:12;:18;;;;;;;:::i;:::-;;;;;;;;-1:-1:-1;;13992:18:0;;;;;;;-1:-1:-1;;;;;;13992:18:0;;;;;;-1:-1:-1;13678:340:0:o;1931:98::-;1989:7;2016:5;2020:1;2016;:5;:::i;:::-;2009:12;1931:98;-1:-1:-1;;;1931:98:0:o;1825:::-;1883:7;1910:5;1914:1;1910;:5;:::i;13280:215::-;13377:7;13422:65;13455:31;;13422:28;13432:17;;13422:5;:9;;:28;;;;:::i;:65::-;13402:85;13280:215;-1:-1:-1;;13280:215:0:o;2037:98::-;2095:7;2122:5;2126:1;2122;:5;:::i;2143:98::-;2201:7;2228:5;2232:1;2228;:5;:::i;11573:272::-;11745:9;;-1:-1:-1;;;;;11712:30:0;;11670:4;11712:30;;;:17;:30;;;;;;11670:4;;11757:15;;11712:42;;11745:9;11712:42;:::i;:::-;:60;:125;;;;;11822:15;;11789:30;11807:11;11789:17;:30::i;:::-;:48;11692:145;11573:272;-1:-1:-1;;11573:272:0:o;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:186::-;251:6;304:2;292:9;283:7;279:23;275:32;272:52;;;320:1;317;310:12;272:52;343:29;362:9;343:29;:::i;383:254::-;451:6;459;512:2;500:9;491:7;487:23;483:32;480:52;;;528:1;525;518:12;480:52;551:29;570:9;551:29;:::i;:::-;541:39;627:2;612:18;;;;599:32;;-1:-1:-1;;;383:254:1:o;642:277::-;709:6;762:2;750:9;741:7;737:23;733:32;730:52;;;778:1;775;768:12;730:52;810:9;804:16;863:5;856:13;849:21;842:5;839:32;829:60;;885:1;882;875:12;924:180;983:6;1036:2;1024:9;1015:7;1011:23;1007:32;1004:52;;;1052:1;1049;1042:12;1004:52;-1:-1:-1;1075:23:1;;924:180;-1:-1:-1;924:180:1:o;1109:184::-;1179:6;1232:2;1220:9;1211:7;1207:23;1203:32;1200:52;;;1248:1;1245;1238:12;1200:52;-1:-1:-1;1271:16:1;;1109:184;-1:-1:-1;1109:184:1:o;1298:248::-;1366:6;1374;1427:2;1415:9;1406:7;1402:23;1398:32;1395:52;;;1443:1;1440;1433:12;1395:52;-1:-1:-1;;1466:23:1;;;1536:2;1521:18;;;1508:32;;-1:-1:-1;1298:248:1:o;2038:908::-;2272:4;2320:3;2309:9;2305:19;2351:6;2340:9;2333:25;2377:2;2415:3;2410:2;2399:9;2395:18;2388:31;2439:6;2474;2468:13;2505:6;2497;2490:22;2543:3;2532:9;2528:19;2521:26;;2582:2;2574:6;2570:15;2556:29;;2603:1;2613:195;2627:6;2624:1;2621:13;2613:195;;;2692:13;;-1:-1:-1;;;;;2688:39:1;2676:52;;2783:15;;;;2748:12;;;;-1:-1:-1;2642:9:1;2613:195;;;-1:-1:-1;;;;;;;2864:32:1;;;;2859:2;2844:18;;2837:60;-1:-1:-1;;;2928:2:1;2913:18;2906:34;2864:32;2825:3;-1:-1:-1;;2038:908:1:o;3457:128::-;3497:3;3528:1;3524:6;3521:1;3518:13;3515:39;;;3534:18;;:::i;:::-;-1:-1:-1;3570:9:1;;3457:128::o;3590:217::-;3630:1;3656;3646:132;;3700:10;3695:3;3691:20;3688:1;3681:31;3735:4;3732:1;3725:15;3763:4;3760:1;3753:15;3646:132;-1:-1:-1;3792:9:1;;3590:217::o;3812:168::-;3852:7;3918:1;3914;3910:6;3906:14;3903:1;3900:21;3895:1;3888:9;3881:17;3877:45;3874:71;;;3925:18;;:::i;:::-;-1:-1:-1;3965:9:1;;3812:168::o;3985:125::-;4025:4;4053:1;4050;4047:8;4044:34;;;4058:18;;:::i;:::-;-1:-1:-1;4095:9:1;;3985:125::o;4115:135::-;4154:3;-1:-1:-1;;4175:17:1;;4172:43;;;4195:18;;:::i;:::-;-1:-1:-1;4242:1:1;4231:13;;4115:135::o;4255:127::-;4316:10;4311:3;4307:20;4304:1;4297:31;4347:4;4344:1;4337:15;4371:4;4368:1;4361:15;4387:127;4448:10;4443:3;4439:20;4436:1;4429:31;4479:4;4476:1;4469:15;4503:4;4500:1;4493:15;4519:127;4580:10;4575:3;4571:20;4568:1;4561:31;4611:4;4608:1;4601:15;4635:4;4632:1;4625:15

ipfs://f61ccd2448c4ac8154e94044d9ba3e93b04c08938f9ba9278f8f42d6184b1cf0