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 2024-03-18
*/

/**
 *Submitted for verification at Etherscan.io on 2023-10-20
*/

/**
TG: https://t.me/DollarSqueeze
Website: https://dollarsqueeze.io
Author: @bLock_doctor
 */
// SPDX-License-Identifier: Unlicensed
pragma solidity ^0.8.12;
 
library Address {
    function isContract(address account) internal view returns (bool) {
        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");
        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }
    function _verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) private pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            if (returndata.length > 0) {
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}
interface IUniRouterV1
{
    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 removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    function removeLiquidityWithPermit(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniRouterV2 is IUniRouterV1
{
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);
    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 IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IDEXFactory {
    function createPair(address tokenA, address tokenB) external returns (address pair);
}
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 {
            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 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;
    }
    IUniRouterV2 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;
    uint256 public dividendsPerShare;
    uint256 public dividendsPerShareAccuracyFactor = 10 ** 36;
    uint256 public minPeriod = 1 hours;
    uint256 public minDistribution = 1;
    uint256 currentIndex;
    bool initialized;
    modifier initialization() {
        require(!initialized);
        _;
        initialized = true;
    }
    modifier onlyToken() {
        require(msg.sender == _token); _;
    }
    constructor (IUniRouterV2 _router) {
        router = _router;
        _token = msg.sender;
    }
    function setDistributionCriteria(uint256 newMinPeriod, uint256 newMinDistribution) external override onlyToken {
        minPeriod = newMinPeriod;
        minDistribution = newMinDistribution;
    }
    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
    {
        totalDividends = totalDividends.add(msg.value);
        dividendsPerShare = dividendsPerShare.add(dividendsPerShareAccuracyFactor.mul(msg.value).div(totalShares));
    }
    function process(uint256 gas) external override onlyToken {
        uint256 shareholderCount = shareholders.length;
        if(shareholderCount == 0) { return; }
        uint256 iterations = 0;
        uint256 gasUsed = 0;
        uint256 gasLeft = gasleft();
        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);
            (bool success, ) = payable(shareholder).call{value: amount, gas: 30000}("");
            success = false;
            shareholderClaims[shareholder] = block.timestamp;
            shares[shareholder].totalRealised = shares[shareholder].totalRealised.add(amount);
            shares[shareholder].totalExcluded = getCumulativeDividends(shares[shareholder].amount);
        }
    }
    function claimDividend() external {
        require(shouldDistribute(msg.sender), "Too soon. Need to wait!");
        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 Ownable {
    address private _owner;
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    constructor () {
        _owner = msg.sender;
        emit OwnershipTransferred(address(0), _owner);
    }
    function owner() public view returns (address) {
        return _owner;
    }
    modifier onlyOwner() {
        require(msg.sender==owner(), "Ownable: caller is not the owner");
        _;
    }
    function renounceOwnership() public virtual onlyOwner {
        _owner = address(0);
        emit OwnershipTransferred(_owner, address(0));
    }
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _owner = newOwner;
        emit OwnershipTransferred(_owner, newOwner);
    }
}
contract DollarSqueeze is IERC20, Ownable {
    string private _tokenName="DollarSqueeze";
    string private _tokenSymbol="DSQ";
    uint8 private _decimals=18;
    uint256 private _totalSupply=100000000*10**_decimals; // 100m
    // Transaction Tax
    uint8 private _buyTax=6;
    uint8 private _sellTax=20;
    uint8 private _burnTax=1;
    uint8 private _transferTax=0;
    // Trading
    bool private _airdropDone=false;
    bool private _tradingEnabled=false;
    uint256 private _maxTx=1000000*10**_decimals; // 1m
    // Wallets
    address public backupOwner=0xAe7c6C4D33667185db125842d31e3D79d614986d;
    address public marketingWallet=0xa62909d663e79Eaa49c86F429EE1538be50862aD;
    address public burnWallet=address(0xdead);
    address public zeroAddress=address(0);
    IUniRouterV2 private _router;
    address public _pair;
    // Reward Distributor
    DividendDistributor public dividendDistributor;
    address public dividendDistributorAddress;
    uint256 distributorGas=500000;
    // Mappings
    mapping(address=>uint256) private _balances;
    mapping(address=>mapping (address => uint256)) private _allowances;
    mapping(address=>bool) private _excludedFromFee;
    mapping(address=>bool) private _excludedFromRewards;
    mapping(address=>bool) private _automatedMarketMakers;
    //
    // Swap & Liquify Taxes
    SwapTaxes private _swapTaxes;
    struct SwapTaxes {
        uint8 marketingTax;
        uint8 liquidityTax;
        uint8 rewardsTax;
    }
    //Swap & Liquify
    bool private _inSwap;
    bool private _swapEnabled;
    uint256 private _swapThreshold=100000*10**_decimals;
    modifier lockTheSwap {_inSwap = true;_;_inSwap = false;}
    event SwapAndLiquify(
        uint256 amountTokens,
        uint256 amountETH
    );
 
    constructor() {
        _router = IUniRouterV2(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
        _pair = IDEXFactory(_router.factory()).createPair(_router.WETH(), address(this));
        _allowances[address(this)][address(_router)]=type(uint256).max;
        _automatedMarketMakers[_pair] = true;
        _excludedFromFee[msg.sender]=true;
        _excludedFromFee[address(this)]=true;
        _excludedFromFee[burnWallet]=true;
        _excludedFromFee[zeroAddress]=true;
        _excludedFromRewards[_pair]=true;
        _excludedFromRewards[msg.sender]=true;
        _excludedFromRewards[address(this)]=true;
        _excludedFromRewards[burnWallet]=true;
        _excludedFromRewards[zeroAddress]=true;
        _swapTaxes=SwapTaxes(50,20,30);
        dividendDistributor = new DividendDistributor(_router);
        dividendDistributorAddress=address(dividendDistributor);
        _balances[msg.sender]+=_totalSupply;
        emit Transfer(address(0),msg.sender,_totalSupply);
    }
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) private {
        bool isExcluded=_excludedFromFee[from]||_excludedFromFee[to]||_inSwap;
        bool isBuy=_automatedMarketMakers[from];
        bool isSell=_automatedMarketMakers[to];
        if(isExcluded)_tokenTransfer(from,to,amount,0);
        else {
            require(_tradingEnabled);
            if(isBuy)_buyTokens(from,to,amount);
            else if(isSell) {
                if(!_inSwap&&_swapEnabled)_swapAndLiquify(false);
                _sellTokens(from,to,amount);
            } else {
                _tokenTransfer(from,to,amount,_transferTax*amount/100);
            }
        }
    }
    function _swapAndLiquify(
        bool ignoreLimits
    ) private lockTheSwap {
        uint256 contractTokenBalance=_balances[address(this)];
        uint256 toSwap=_swapThreshold;
        if(contractTokenBalance<toSwap) {
            if(ignoreLimits&&contractTokenBalance>0) {
                toSwap=contractTokenBalance;
            } else return;
        }
        uint256 totalLiquidityTokens=toSwap*_swapTaxes.liquidityTax/100;
        uint256 tokensRemaining=toSwap-totalLiquidityTokens;
        uint256 liquidityTokens=totalLiquidityTokens/2;
        uint256 liquidityETHTokens=totalLiquidityTokens-liquidityTokens;
        toSwap=tokensRemaining+liquidityETHTokens;
        uint256 oldETH=address(this).balance;
        _swapTokensForETH(toSwap);
        uint256 newETH=address(this).balance-oldETH;
        uint256 liquidityETH=(newETH*liquidityETHTokens)/toSwap;
        uint256 remainingETH=newETH-liquidityETH;
        uint256 marketingETH=remainingETH*_swapTaxes.marketingTax/100;
        uint256 rewardsETH=remainingETH-marketingETH;
        if (rewardsETH > 0)
            try dividendDistributor.deposit{value: rewardsETH}() {} catch {}
        (bool transferMarketing,) = payable(marketingWallet).call{value: marketingETH, gas: 30000}("");
        transferMarketing=false;
        _addLiquidity(liquidityTokens,liquidityETH);
        emit SwapAndLiquify(liquidityTokens,liquidityETH);
    }
    function _buyTokens(
        address from,
        address to,
        uint256 amount
    ) private {
        require(amount<=_maxTx,"Amount exceeds maxTx.");
        _tokenTransfer(from,to,amount,amount*_buyTax/100);
    }
    function _sellTokens(
        address from,
        address to,
        uint256 amount
    ) private {
        require(amount<=_maxTx,"Amount exceeds maxTx.");
        _tokenTransfer(from,to,amount,amount*_sellTax/100);
    }
    function _tokenTransfer(
        address from,
        address to,
        uint256 amount,
        uint256 tax
    ) private {
        uint256 tokensToBurn=_burnTax*tax/100;
        _balances[from]-=amount;
        _balances[burnWallet]+=tokensToBurn;
        _balances[address(this)]+=(tax-tokensToBurn);
        _balances[to]+=(amount-tax);
        if(!_excludedFromRewards[from]) try dividendDistributor.setShare(from,_balances[from]) {} catch {}
        if(!_excludedFromRewards[to]) try dividendDistributor.setShare(to,_balances[to]) {} catch {}
        try dividendDistributor.process(distributorGas) {} catch {}
        emit Transfer(from,to,(amount-tax));
    }
    function _swapTokensForETH(
        uint256 tokenAmount
    ) private {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = _router.WETH();
        _approve(address(this), address(_router), tokenAmount);
        _router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0, 
            path,
            address(this),
            block.timestamp
        );
    }
    function _addLiquidity(
        uint256 tokenAmount,
        uint256 ETHAmount
    ) private {
        _approve(address(this), address(_router), tokenAmount);
        _router.addLiquidityETH{value: ETHAmount}(
            address(this),
            tokenAmount,
            0,
            0,
            burnWallet,
            block.timestamp
        );
    }
    //
    function enableTrading() public onlyOwner() {
        require(!_tradingEnabled,"Trading is already enabled.");
        _tradingEnabled=!_tradingEnabled;
    }
    function recoverOwnershipFromBackup() public {
        require(msg.sender==backupOwner);
        transferOwnership(backupOwner);
    }
    function updateBackupOwnerWallet(
        address _backupOwner
    ) public onlyOwner {
        backupOwner=_backupOwner;
    }
    function updateAutomatedMarketMakers(
        address marketMaker,
        bool enabled
    ) public onlyOwner {
        _automatedMarketMakers[marketMaker]=enabled;
        excludeFromReward(marketMaker,true);
    }
    function updateTax(
        uint8 buyTax,
        uint8 sellTax,
        uint8 burnTax,
        uint8 transferTax
    ) public onlyOwner {
        require(_buyTax+sellTax<=30,"Taxes cannot exceed 30%.");
        require(_transferTax<=20,"Transfer tax cannot exceed 20%.");
        _buyTax=buyTax;
        _sellTax=sellTax;
        _burnTax=burnTax;
        _transferTax=transferTax;
    }
    function updateSwapTaxes(
        uint8 marketingTax,
        uint8 rewardsTax,
        uint8 liquidityTax
    ) public onlyOwner {
        require((marketingTax+rewardsTax+liquidityTax)==100,"Swap tax cannot exceed 100.");
        _swapTaxes.marketingTax=marketingTax;
        _swapTaxes.rewardsTax=rewardsTax;
        _swapTaxes.liquidityTax=liquidityTax;
    }
    function updateSwapThreshold(
        uint256 swapThreshold
    ) public onlyOwner {
        require(_swapThreshold>0&&swapThreshold<=(_totalSupply*1/100));
        _swapThreshold=swapThreshold;
    }
    function switchSwapEnabled(
        bool swapEnabled
    ) public onlyOwner {
        _swapEnabled=swapEnabled;
    }
    function triggerSwapAndLiquify(
        bool ignoreLimits
    ) public onlyOwner {
        _swapAndLiquify(ignoreLimits);
    }
    function excludeFromFee(
        address account,
        bool excluded
    ) public onlyOwner {
        _excludedFromFee[account]=excluded;
    }
    function excludeFromReward(
        address account,
        bool excluded
    ) public onlyOwner {
        _excludedFromRewards[account]=excluded;
        try dividendDistributor.setShare(account,excluded?0:_balances[account]) {} catch {}
    }
    function updateMaxTx(
        uint256 maxTx
    ) public onlyOwner {
        require(maxTx>=(_totalSupply*1/100) / 2);
        _maxTx=maxTx*10**_decimals;
    }
    function updateMarketingWallet(
        address _marketingWallet
    ) public onlyOwner {
        require(_marketingWallet!=address(0),"Cannot be zero address!");
        marketingWallet=_marketingWallet;
    }
    function withdrawStrandedToken(
        address strandedToken
    ) public onlyOwner {
        require(strandedToken!=address(this));
        IERC20 token=IERC20(strandedToken);
        token.transfer(owner(),token.balanceOf(address(this)));
    }
    function withdrawStuckETH() public onlyOwner {
        (bool success,)=msg.sender.call{value:(address(this).balance)}("");
        require(success);
    }
    function addRewardsManually() public payable onlyOwner {
        require(msg.value>0);
        try dividendDistributor.deposit{value: msg.value}() {} catch {}
    }
    function updateDistributorSettings(
        uint256 _minPeriod,
        uint256 _minDistribution,
        uint256 gas
    ) public onlyOwner {
        require(gas<=1200000);
        dividendDistributor.setDistributionCriteria(_minPeriod, _minDistribution);
        distributorGas = gas;
    }
    //
    function showMaxTx() public view returns(uint256) {
        return _maxTx;
    }
    function isSwapEnabled() public view returns(bool) {
        return _swapEnabled;
    }
    function showTradeTaxes() public view returns(
        uint8 buyTax, 
        uint8 sellTax,
        uint8 burnTax,
        uint8 transferTax
    ) {
        buyTax=_buyTax;
        sellTax=_sellTax;
        burnTax=_burnTax;
        transferTax=_transferTax;
    }
    function showSwapTaxes() public view returns(
        uint8 marketingTax, 
        uint8 liquidityTax, 
        uint8 rewardsTax
    ) {
        marketingTax=_swapTaxes.marketingTax;
        liquidityTax=_swapTaxes.liquidityTax;
        rewardsTax=_swapTaxes.rewardsTax;
    }
    function showDistributorDetails() public view returns(
        address _distributorAddress, 
        uint256 _distributorGas
    ) {
        _distributorAddress=dividendDistributorAddress;
        _distributorGas=distributorGas;
    }
    function isTradingEnabled() public view returns(bool) {
        return _tradingEnabled;
    }
    //
    function transfer(
        address recipient, 
        uint256 amount
    ) external override returns (bool) {
        _transfer(msg.sender, recipient, amount);
        return true;
    }
    function transferFrom(
        address sender, 
        address recipient, 
        uint256 amount
    ) external override returns (bool) {
        uint256 allowance_ = _allowances[sender][msg.sender];
        _transfer(sender, recipient, amount);
        require(allowance_ >= amount);
        _approve(sender, msg.sender, allowance_ - amount);
        emit Transfer(sender, recipient, amount);
        return true;
    }
    function _approve(
        address owner, 
        address spender, 
        uint256 amount
    ) private {
        require((owner != address(0) && spender != address(0)), "Owner/Spender address cannot be 0.");
        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }
    function approve(
        address spender, 
        uint256 amount
    ) external override returns (bool) {
        _approve(msg.sender, spender, amount);
        return true;
    }
    function allowance(
        address owner_,
        address spender
    ) external view override returns (uint256) {
        return _allowances[owner_][spender];
    }
    function balanceOf(
        address account
    ) external view override returns (uint256) {
        return _balances[account];
    }
    function name() external view returns (string memory) {
        return _tokenName;
    }
    function symbol() external view returns (string memory) {
        return _tokenSymbol;
    }
    function totalSupply() external view override returns (uint256) {
        return _totalSupply;
    }
    function decimals() external view returns (uint8) {
        return _decimals;
    }
    function getOwner() external view returns (address) {
        return owner();
    }
    receive() external payable { }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IUniRouterV2","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":"newMinPeriod","type":"uint256"},{"internalType":"uint256","name":"newMinDistribution","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

12088:5080:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12673:57;;;;;;;;;;;;;;;;;;;160:25:1;;;148:2;133:18;12673:57:0;;;;;;;;13373:640;;;;;;;;;;-1:-1:-1;13373:640:0;;;;;:::i;:::-;;:::i;:::-;;16049:473;;;;;;;;;;-1:-1:-1;16049:473:0;;;;;:::i;:::-;;:::i;13166:201::-;;;;;;;;;;-1:-1:-1;13166:201:0;;;;;:::i;:::-;;:::i;12527:26::-;;;;;;;;;;;;;;;;12778:34;;;;;;;;;;;;;;;;12560:29;;;;;;;;;;;;;;;;12480:40;;;;;;;;;;-1:-1:-1;12480:40:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1279:25:1;;;1335:2;1320:18;;1313:34;;;;1363:18;;;1356:34;1267:2;1252:18;12480:40:0;1077:319:1;14019:242:0;;;:::i;12634:32::-;;;;;;;;;;;;;;;;12596:31;;;;;;;;;;;;;;;;15885:158;;;;;;;;;;;;;:::i;14267:711::-;;;;;;;;;;-1:-1:-1;14267:711:0;;;;;:::i;:::-;;:::i;12737:34::-;;;;;;;;;;;;;;;;13373:640;13036:6;;-1:-1:-1;;;;;13036:6:0;13022:10;:20;13014:29;;;;;;-1:-1:-1;;;;;13470:19:0;::::1;13499:1;13470:19:::0;;;:6:::1;:19;::::0;;;;:26;:30;13467:92:::1;;13516:31;13535:11;13516:18;:31::i;:::-;13581:1;13572:6;:10;:45;;;;-1:-1:-1::0;;;;;;13586:19:0;::::1;;::::0;;;:6:::1;:19;::::0;;;;:26;:31;13572:45:::1;13569:214;;;16803:12:::0;:19;;-1:-1:-1;;;;;16769:31:0;;;;;;:18;:31;;;;;:53;;;16833:30;;;;;;;;;;;;;-1:-1:-1;;;;;;16833:30:0;;;;;;13569:214:::1;;;13680:11:::0;;:45;::::1;;;-1:-1:-1::0;;;;;;13695:19:0;::::1;13724:1;13695:19:::0;;;:6:::1;:19;::::0;;;;:26;:30;;13680:45:::1;13677:106;;;13741:30;13759:11;13741:17;:30::i;:::-;-1:-1:-1::0;;;;;13823:19:0;::::1;;::::0;;;:6:::1;:19;::::0;;;;:26;13807:11:::1;::::0;:55:::1;::::0;13855:6;;13807:43:::1;::::0;:15:::1;:43::i;:::-;:47:::0;::::1;:55::i;:::-;13793:11;:69:::0;-1:-1:-1;;;;;13873:19:0;::::1;;::::0;;;:6:::1;:19;::::0;;;;:35;;;13955:50:::1;13902:6:::0;13955:22:::1;:50::i;:::-;-1:-1:-1::0;;;;;13919:19:0;;::::1;;::::0;;;:6:::1;:19;::::0;;;;:33:::1;;:86:::0;;;;-1:-1:-1;13373:640:0:o;16049:473::-;-1:-1:-1;;;;;16141:19:0;;16118:7;16141:19;;;:6;:19;;;;;:26;16138:48;;-1:-1:-1;16182:1:0;;16049:473;-1:-1:-1;16049:473:0:o;16138:48::-;-1:-1:-1;;;;;16255:19:0;;16196:33;16255:19;;;:6;:19;;;;;:26;16232:50;;:22;:50::i;:::-;-1:-1:-1;;;;;16328:19:0;;16293:32;16328:19;;;:6;:19;;;;;:33;;;16196:86;;-1:-1:-1;16375:53:0;;;16372:70;;-1:-1:-1;16438:1:0;;16049:473;-1:-1:-1;;;16049:473:0:o;16372:70::-;16459:55;:25;16489:24;16459:29;:55::i;:::-;16452:62;16049:473;-1:-1:-1;;;;16049:473:0:o;13166:201::-;13036:6;;-1:-1:-1;;;;;13036:6:0;13022:10;:20;13014:29;;;;;;13288:9:::1;:24:::0;;;;13323:15:::1;:36:::0;13166:201::o;14019:242::-;13036:6;;-1:-1:-1;;;;;13036:6:0;13022:10;:20;13014:29;;;;;;14107:14:::1;::::0;:29:::1;::::0;14126:9:::1;14107:18;:29::i;:::-;14090:14;:46:::0;14240:11:::1;::::0;14189:31:::1;::::0;14167:86:::1;::::0;14189:63:::1;::::0;:46:::1;::::0;14225:9:::1;14189:35;:46::i;:::-;:50:::0;::::1;:63::i;:::-;14167:17;::::0;;:21:::1;:86::i;:::-;14147:17;:106:::0;14019:242::o;15885:158::-;15938:28;15955:10;15938:16;:28::i;:::-;15930:64;;;;-1:-1:-1;;;15930:64:0;;1788:2:1;15930:64:0;;;1770:21:1;1827:2;1807:18;;;1800:30;1866:25;1846:18;;;1839:53;1909:18;;15930:64:0;;;;;;;;16005:30;16024:10;16005:18;:30::i;:::-;15885:158::o;14267:711::-;13036:6;;-1:-1:-1;;;;;13036:6:0;13022:10;:20;13014:29;;;;;;14363:12:::1;:19:::0;14396:21;14393:37:::1;;14421:7;14267:711:::0;:::o;14393:37::-:1;14440:18;14473:15:::0;14503::::1;14521:9;14503:27;;14541:430;14557:3;14547:7;:13;:46;;;;;14577:16;14564:10;:29;14547:46;14541:430;;;14629:16;14613:12;;:32;14610:57;;14663:1;14648:12;:16:::0;14610:57:::1;14684:44;14701:12;14714;;14701:26;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;-1:-1:-1;;;;;14701:26:0::1;14684:16;:44::i;:::-;14681:129;;;14748:46;14767:12;14780;;14767:26;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;-1:-1:-1;;;;;14767:26:0::1;14748:18;:46::i;:::-;14834:35;14846:22;14858:9;14846:7:::0;;:11:::1;:22::i;:::-;14834:7:::0;;:11:::1;:35::i;:::-;14824:45;;14894:9;14918:12;:14:::0;;14884:19;;-1:-1:-1;14918:12:0::1;:14;::::0;::::1;:::i;:::-;;;;;;14947:12;;;;;:::i;:::-;;;;14541:430;;;14325:653;;;;14267:711:::0;:::o;15221:658::-;-1:-1:-1;;;;;15293:19:0;;;;;;:6;:19;;;;;:26;15290:46;;15221:658;:::o;15290:46::-;15346:14;15363:30;15381:11;15363:17;:30::i;:::-;15346:47;-1:-1:-1;15407:10:0;;15404:468;;15452:16;;:28;;15473:6;15452:20;:28::i;:::-;15433:16;:47;15514:56;;15496:12;;-1:-1:-1;;;;;15514:25:0;;;15560:5;;15547:6;;15496:12;15514:56;15496:12;15514:56;15547:6;15514:25;15560:5;15514:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;15615:30:0;;15595:5;15615:30;;;:17;:30;;;;;;;;15648:15;15615:48;;15714:6;:19;;;;;:33;;;:45;;15752:6;15714:37;:45::i;:::-;-1:-1:-1;;;;;15678:19:0;;;;;;:6;:19;;;;;:33;;;:81;;;;15833:26;15810:50;;:22;:50::i;:::-;-1:-1:-1;;;;;15774:19:0;;;;;;:6;:19;;;;;:33;;:86;-1:-1:-1;15404:468:0;15279:600;15221:658;:::o;16877:288::-;16993:12;17006:19;;:21;;17026:1;;17006:21;:::i;:::-;16993:35;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;16958:31:0;;;;;:18;:31;;;;;;;;16945:12;:45;;16993:35;;;;;16945:12;:45;;;;;;:::i;:::-;;;;;;;;;;;;;:83;;-1:-1:-1;;;;;;16945:83:0;-1:-1:-1;;;;;16945:83:0;;;;;;17097:31;;;;;:18;:31;;;;;;;;17058:12;17071:19;;17097:31;;:18;16945:45;17071:21;;-1:-1:-1;;17071:21:0;:::i;:::-;17058:35;;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;17058:35:0;17039:55;;;;;;;;;;;;:89;17139:12;:18;;;;;;;:::i;:::-;;;;;;;;;;-1:-1:-1;;17139:18:0;;;;;-1:-1:-1;;;;;;17139:18:0;;;;;;-1:-1:-1;16877:288:0:o;10649:98::-;10707:7;10734:5;10738:1;10734;:5;:::i;:::-;10727:12;10649:98;-1:-1:-1;;;10649:98:0:o;10545:::-;10603:7;10630:5;10634:1;10630;:5;:::i;16528:170::-;16598:7;16625:65;16658:31;;16625:28;16635:17;;16625:5;:9;;:28;;;;:::i;:65::-;16618:72;16528:170;-1:-1:-1;;16528:170:0:o;10753:98::-;10811:7;10838:5;10842:1;10838;:5;:::i;10857:98::-;10915:7;10942:5;10946:1;10942;:5;:::i;14984:231::-;15111:9;;-1:-1:-1;;;;;15078:30:0;;15054:4;15078:30;;;:17;:30;;;;;;15054:4;;15123:15;;15078:42;;15111:9;15078:42;:::i;:::-;:60;:129;;;;;15192:15;;15159:30;15177:11;15159:17;:30::i;:::-;:48;15071:136;14984:231;-1:-1:-1;;14984:231:0:o;196:173:1:-;264:20;;-1:-1:-1;;;;;313:31:1;;303:42;;293:70;;359:1;356;349:12;293:70;196:173;;;:::o;374:254::-;442:6;450;503:2;491:9;482:7;478:23;474:32;471:52;;;519:1;516;509:12;471:52;542:29;561:9;542:29;:::i;:::-;532:39;618:2;603:18;;;;590:32;;-1:-1:-1;;;374:254:1:o;633:186::-;692:6;745:2;733:9;724:7;720:23;716:32;713:52;;;761:1;758;751:12;713:52;784:29;803:9;784:29;:::i;824:248::-;892:6;900;953:2;941:9;932:7;928:23;924:32;921:52;;;969:1;966;959:12;921:52;-1:-1:-1;;992:23:1;;;1062:2;1047:18;;;1034:32;;-1:-1:-1;824:248:1:o;1401:180::-;1460:6;1513:2;1501:9;1492:7;1488:23;1484:32;1481:52;;;1529:1;1526;1519:12;1481:52;-1:-1:-1;1552:23:1;;1401:180;-1:-1:-1;1401:180:1:o;1938:127::-;1999:10;1994:3;1990:20;1987:1;1980:31;2030:4;2027:1;2020:15;2054:4;2051:1;2044:15;2070:127;2131:10;2126:3;2122:20;2119:1;2112:31;2162:4;2159:1;2152:15;2186:4;2183:1;2176:15;2202:135;2241:3;-1:-1:-1;;2262:17:1;;2259:43;;;2282:18;;:::i;:::-;-1:-1:-1;2329:1:1;2318:13;;2202:135::o;2552:125::-;2592:4;2620:1;2617;2614:8;2611:34;;;2625:18;;:::i;:::-;-1:-1:-1;2662:9:1;;2552:125::o;2682:127::-;2743:10;2738:3;2734:20;2731:1;2724:31;2774:4;2771:1;2764:15;2798:4;2795:1;2788:15;2814:128;2854:3;2885:1;2881:6;2878:1;2875:13;2872:39;;;2891:18;;:::i;:::-;-1:-1:-1;2927:9:1;;2814:128::o;2947:168::-;2987:7;3053:1;3049;3045:6;3041:14;3038:1;3035:21;3030:1;3023:9;3016:17;3012:45;3009:71;;;3060:18;;:::i;:::-;-1:-1:-1;3100:9:1;;2947:168::o;3120:217::-;3160:1;3186;3176:132;;3230:10;3225:3;3221:20;3218:1;3211:31;3265:4;3262:1;3255:15;3293:4;3290:1;3283:15;3176:132;-1:-1:-1;3322:9:1;;3120:217::o

ipfs://c999a8a079c99f06e84b8b0abb5ae947e4a89e4f841312a0932b141ef5cfa900