PulseChain Explorer - BlockScout

Contract Address

Is Yul contract

No

Yes

Contract Name

Include nightly builds

No

Yes

Compiler

EVM Version

Optimization

No

Yes

Optimization runs

Enter the Solidity Contract Code

// SPDX-License-Identifier: MIT

pragma solidity 0.8.19;

/* 
/*

████████╗██╗███╗   ██╗     ███████╗ ██████╗ ██╗██ 
╚══██╔══╝██║████╗  ██║     ██╔════╝██╔═══██╗██║██
   ██║   ██║██╔██╗ ██║     █████╗  ██║   ██║██║██║  
   ██║   ██║██║╚██╗██║     ██╔══╝  ██║   ██║██║██║   
   ██║   ██║██║ ╚████║     ██║     ╚██████╔╝██ ██████
   ╚═╝   ╚═╝╚═╝  ╚═══╝     ╚═╝      ╚═════╝ ╚═╝ ╚═════╝

█████   █████    █████    ██    ██████  ███████   ██  ██  
 ██      ██   ██  ██        ██    ██        ██      ██  ██   
 █████   ██   ██  ██        ██    █████     ██        ██    
      ██ ██   ██  ██        ██    ██        ██        ██    
 █████    █████    █████   ████   ██████    ██        ██

CONSPIRACY THEORY

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

/**
 * Minimal ERC20 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
    );
}

/* 
==========================================================
=====================   Auth Contract   ==================
==========================================================
*/
abstract contract Auth {
    address internal owner;
    mapping (address => bool) internal authorizations;

constructor(address _owner) {
        owner = _owner;
        authorizations[_owner] = true;
    }
    modifier onlyOwner() {
        require(isOwner(msg.sender), "!OWNER"); 
        _;
    }
    modifier authorized() {
        require(isAuthorized(msg.sender), "!AUTHORIZED"); 
        _;
    }

/* 
==========================================================
======= DEX Factory / Router Interfaces (PulseChain) =====
==========================================================
*/
interface IDEXFactory {
    function createPair(address tokenA, address tokenB) 
        external 
        returns (address pair);
}

interface IDEXRouter {
    function factory() external pure returns (address);
    function WPLS() 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 amountPLSMin,
        address to,
        uint deadline
    ) external payable 
      returns (uint amountToken, uint amountPLS, 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;
}

/* 
==========================================================
============= Dividend Distributor (SKOL Reflection) =====
==========================================================

SKOL REFLECTIONS
*/
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;

// SKOL token address
    IERC20 SKOL = IERC20(0x791367770E068208104fc1B5C1E15F3F5f4d143d);
    address WPLS = 0xA1077a294dDE1B09bB078844df40758a5D0f9a27;
    IDEXRouter router;

struct Share {
        uint256 amount;
        uint256 totalExcluded;
        uint256 totalRealised;
    }
    mapping (address => Share) public shares;

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

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

uint256 public minPeriod = 1 * 60;          // 1 minute
    uint256 public minDistribution = 1 * 10**5; // 0.00001 SKOL ?

uint256 currentIndex;
    bool initialized;
    modifier initialization() {
        require(!initialized, "Already initialized");
        _;
        initialized = true;
    }
    modifier onlyToken() {
        require(msg.sender == _token, "Unauthorized"); 
        _;
    }

constructor (address _router) {
        // default to your main router, 
        // or fallback if address(0) is given
        router = _router != address(0)
            ? IDEXRouter(_router)
            : IDEXRouter(0x165C3410fC91EF562C50559f7d2289fEbed552d9);
        _token = msg.sender;
    }

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

// The contract calls deposit{value: amountPLSReflection}()
    // and we swap PLS -> SKOL here
    function deposit() external payable override onlyToken {
        uint256 balanceBefore = SKOL.balanceOf(address(this));

address[] memory path = new address[](2);
        path[0] = WPLS;
        path[1] = address(SKOL);

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

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

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

// Distribute dividends to some holders
    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++;
        }
    }

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

// Transfer SKOL
    function distributeDividend(address shareholder) internal {
        if(shares[shareholder].amount == 0){ 
            return; 
        }
        uint256 amount = getUnpaidEarnings(shareholder);
        if(amount > 0){
            totalDistributed = totalDistributed.add(amount);
            SKOL.transfer(shareholder, amount);
            shareholderClaims[shareholder] = block.timestamp;
            shares[shareholder].totalRealised = 
                shares[shareholder].totalRealised.add(amount);
            shares[shareholder].totalExcluded = 
                getCumulativeDividends(shares[shareholder].amount);
        }
    }

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

/*

████████╗██╗███╗   ██╗     ███████╗ ██████╗ ██╗██ 
╚══██╔══╝██║████╗  ██║     ██╔════╝██╔═══██╗██║██
   ██║   ██║██╔██╗ ██║     █████╗  ██║   ██║██║██║  
   ██║   ██║██║╚██╗██║     ██╔══╝  ██║   ██║██║██║   
   ██║   ██║██║ ╚████║     ██║     ╚██████╔╝██ ██████
   ╚═╝   ╚═╝╚═╝  ╚═══╝     ╚═╝      ╚═════╝ ╚═╝ ╚═════╝

█████   █████    █████    ██    ██████  ███████   ██  ██  
 ██      ██   ██  ██        ██    ██        ██      ██  ██   
 █████   ██   ██  ██        ██    █████     ██        ██    
      ██ ██   ██  ██        ██    ██        ██        ██    
 █████    █████    █████   ████   ██████    ██        ██

the conspiracy

*/
contract TinFoilSociety  is IERC20, Auth {
    using SafeMath for uint256;

// Basic info
    string constant _name     = "TinFoilSociety";
    string constant _symbol   = "TIN";
    uint8 constant _decimals = 18;
    uint256 _totalSupply = 1_000_000_000 * (10 ** _decimals);

// Mapped balances/allowances
    mapping (address => uint256) _balances;
    mapping (address => mapping (address => uint256)) _allowances;

// Dex addresses for PulseChain
    address public WPLS  = 0xA1077a294dDE1B09bB078844df40758a5D0f9a27;
    address public DEAD  = 0x000000000000000000000000000000000000dEaD;
    address public ZERO  = 0x0000000000000000000000000000000000000000;

// Exemptions
    mapping (address => bool) isFeeExempt;
    mapping (address => bool) isTxLimitExempt;
    mapping (address => bool) isTimelockExempt;
    mapping (address => bool) isDividendExempt;

// Fees => 1% Liquidity, 2% Reflection, 2% Dev => total 5%
    uint256 public liquidityFee  = 100;  // 1% (out of denominator=10000)
    uint256 public reflectionFee = 200;  // 2%
    uint256 public devFee        = 200;  // 2%
    // We'll keep a large denominator for possible fine-tuning
    uint256 public feeDenominator= 10000;

// We'll compute totalFee on the fly
    function totalFee() public view returns(uint256) {
        return liquidityFee.add(reflectionFee).add(devFee);
    }

// Dev wallet
    address public devWallet = 0x883cA68EfFB407AcF9c2BBcFA80AF1a82100e70f;
    // Liquidity receiver
    address public autoLiquidityReceiver;

// For liquidity
    IDEXRouter public router;
    address public pair;

// Another router/pair if needed
    IDEXRouter public router2;
    address public pair2;

// Dividend system
    DividendDistributor public distributor;
    uint256 distributorGas = 500000;

// Transaction limit
    uint256 public _maxTxAmount = _totalSupply; // can be lowered if desired

// Swap settings
    bool public swapEnabled = true;
    uint256 public swapThreshold = 100_000_000; // 0.1 token (con decimals=9)

// Additional liquidity settings
    uint256 public targetLiquidity = 25;              
    uint256 public targetLiquidityDenominator = 100;

// **Added variable to track trading status**
    bool public tradingOpen = false;

bool inSwap;
    modifier swapping() { inSwap = true; _; inSwap = false; }

constructor() Auth(msg.sender) {
        router = IDEXRouter(0x165C3410fC91EF562C50559f7d2289fEbed552d9);
        pair   = IDEXFactory(router.factory()).createPair(WPLS, address(this));
        _allowances[address(this)][address(router)] = type(uint256).max;

// optional second router if needed
        router2 = IDEXRouter(0x98bf93ebf5c380C0e6Ae8e192A7e2AE08edAcc02);
        pair2   = IDEXFactory(router2.factory()).createPair(WPLS, address(this));
        _allowances[address(this)][address(router2)] = type(uint256).max;

distributor = new DividendDistributor(address(router));

// Exempt the owner
        isFeeExempt[msg.sender] = true;
        isTxLimitExempt[msg.sender] = true;
        // Timelock exempt
        isTimelockExempt[msg.sender] = true;
        isTimelockExempt[DEAD]       = true;
        isTimelockExempt[address(this)] = true;

// Dividend exempt for contract/pair/DEAD
        isDividendExempt[pair]    = true;
        isDividendExempt[address(this)] = true;
        isDividendExempt[DEAD]    = true;

// By default, autoLiquidityReceiver is owner
        autoLiquidityReceiver = msg.sender;

// Mint entire supply to owner
        _balances[msg.sender] = _totalSupply;
        emit Transfer(address(0), msg.sender, _totalSupply);
    }

// **Function to open trading**
    function openTrading() external onlyOwner {
        tradingOpen = true;
    }

// ------------------------------------------------------
    //      STANDARD ERC20-LIKE METHODS (pure to avoid warnings)
    // ------------------------------------------------------
    function name() public pure override returns (string memory) {
        return _name;
    }

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

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

// (Non standard, defined in the interface)
    function getOwner() external view override returns (address) {
        return owner;
    }

// Basic ERC20 mechanics
    function totalSupply() external view override returns (uint256) { 
        return _totalSupply; 
    }

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

// Approve
    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, type(uint256).max);
    }

// Transfer
    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] != type(uint256).max){
            _allowances[sender][msg.sender] = 
                _allowances[sender][msg.sender].sub(
                    amount, 
                    "Insufficient Allowance"
                );
        }
        return _transferFrom(sender, recipient, amount);
    }

// **Helper function to check if an address is a pair**
    function isInPair(address addr) internal view returns (bool) {
        return addr == pair || addr == pair2;
    }

// Core transfer logic
    function _transferFrom(
        address sender, 
        address recipient, 
        uint256 amount
    ) internal returns (bool) {
        // **Trading check**
        if (!tradingOpen) {
            require(
                 sender == owner || recipient == address(router) || sender == address(router),
                 "Trading is not enabled yet"
    );
}

if(inSwap) { 
            return _basicTransfer(sender, recipient, amount); 
        }
        // Check TX limit
        checkTxLimit(sender, amount);

bool isPairTx = isInPair(sender) || isInPair(recipient) ||
                        sender == address(router) ||
                        recipient == address(router) ||
                        sender == address(router2) ||
                        recipient == address(router2);

uint256 amountReceived;
        if(isPairTx) {
            // If pair or router, handle fees & possible swap
            if(shouldSwapBack()) { 
                swapBack(); 
            }
            _balances[sender] = _balances[sender].sub(
                amount, 
                "Insufficient Balance"
            );
            amountReceived = shouldTakeFee(sender) 
                ? takeFee(sender, amount) 
                : amount;
            _balances[recipient] = _balances[recipient].add(amountReceived);
        } 
        else {
            // Normal wallet <-> wallet transfer
            _balances[sender] = _balances[sender].sub(
                amount, 
                "Insufficient Balance"
            );
            amountReceived = amount;
            _balances[recipient] = _balances[recipient].add(amountReceived);
        }

// Update shares for reflection
        if(!isDividendExempt[sender]) {
            try distributor.setShare(sender, _balances[sender]) {} catch {}
        }
        if(!isDividendExempt[recipient]) {
            try distributor.setShare(recipient, _balances[recipient]) {} catch {}
        }
        // Reflection processing
        try distributor.process(distributorGas) {} catch {}

emit Transfer(sender, recipient, amountReceived);
        return true;
    }
    
    // Basic transfer without fees
    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;
    }

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

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

// Take fee => 1% liquidity + 2% reflection + 2% dev 
    function takeFee(address sender, uint256 amount) internal returns (uint256) {
        uint256 feeAmount = amount.mul(totalFee()).div(feeDenominator);

// Dev portion from that fee
        uint256 devPortion = feeAmount.mul(devFee).div(totalFee());
        _balances[devWallet] = _balances[devWallet].add(devPortion);
        emit Transfer(sender, devWallet, devPortion);

// The rest of fees => contract (for liquidity + reflection)
        uint256 remainFees = feeAmount.sub(devPortion);
        _balances[address(this)] = _balances[address(this)].add(remainFees);
        emit Transfer(sender, address(this), remainFees);

return amount.sub(feeAmount);
    }

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

function swapBack() internal swapping {
        uint256 liqFee = liquidityFee;
        // If over liquified, set liqFee=0
        if(isOverLiquified(targetLiquidity, targetLiquidityDenominator)){
            liqFee = 0;
        }

uint256 dynamicLiqFee  = liqFee;
        uint256 contractAmount = swapThreshold;

uint256 amountToLiquify = contractAmount
            .mul(dynamicLiqFee)
            .div(totalFee())
            .div(2);

uint256 amountToSwap = contractAmount.sub(amountToLiquify);

// path: contract tokens -> WPLS
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = WPLS;

uint256 balanceBefore = address(this).balance;
        router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            amountToSwap,
            0,
            path,
            address(this),
            block.timestamp
        );
        uint256 amtPLS = address(this).balance.sub(balanceBefore);

uint256 totFee = totalFee().sub(dynamicLiqFee.div(2));
        uint256 amtPLS_Liq = amtPLS.mul(dynamicLiqFee).div(totFee).div(2);
        uint256 amtPLS_Refl= amtPLS.mul(reflectionFee).div(totFee);
        // Dev portion is already taken in `takeFee()`

// deposit reflection portion => calls deposit() in distributor 
        if(amtPLS_Refl > 0){
            try distributor.deposit{value: amtPLS_Refl}() {} catch {}
        }

// Add liquidity if needed
        if(amountToLiquify > 0){
            router.addLiquidityETH{value: amtPLS_Liq}(
                address(this),
                amountToLiquify,
                0,
                0,
                autoLiquidityReceiver,
                block.timestamp
            );
            emit AutoLiquify(amtPLS_Liq, amountToLiquify);
        }
    }

/* 
       ============= Owner / Authorized Functions =============
    */
    function setIsDividendExempt(address holder, bool exempt) 
        external 
        authorized 
    {
        require(holder != address(this) && holder != pair, "Invalid holder");
        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 setIsTimelockExempt(address holder, bool exempt) 
        external 
        authorized 
    {
        isTimelockExempt[holder] = exempt;
    }

// Adjust fees
    function setFees(
        uint256 _liquidityFee, 
        uint256 _reflectionFee, 
        uint256 _devFee
    ) external authorized {
        liquidityFee  = _liquidityFee;
        reflectionFee = _reflectionFee;
        devFee        = _devFee;
        // Hardcap: total fees <= 10%
        require(
            liquidityFee.add(reflectionFee).add(devFee) <= 1000, 
            "Total fees cannot exceed 10%"
        );
    }

// Set dev wallet
    function setDevWallet(address _dev) external authorized {
        devWallet = _dev;
    }

// Set fee receivers (for liquidity, etc.)
    function setFeeReceivers(address _autoLiquidityReceiver) 
        external 
        authorized 
    {
        autoLiquidityReceiver = _autoLiquidityReceiver;
    }

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

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

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

// Distributor gas
    function setDistributorSettings(uint256 gas) external authorized {
        require(gas < 750000, "Gas too high");
        distributorGas = gas;
    }

// Tx limit
    function setTxLimit(uint256 amount) external authorized {
        _maxTxAmount = amount;
    }

// Clear stuck PLS from contract
    function clearStuckBalance(uint256 amountPercentage) external authorized {
        uint256 amtPLS = address(this).balance;
        payable(devWallet).transfer(
            amtPLS.mul(amountPercentage).div(100)
        );
    }

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

// Liquidity checks
    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;
    }

// Fallback to receive PLS
    receive() external payable {}

event AutoLiquify(uint256 amountPLS, uint256 amountToken);
}

Try to fetch constructor arguments automatically

No

Yes

ABI-encoded Constructor Arguments (if required by the contract)

New Solidity Smart Contract Verification

Contract Libraries