Contract Address Details

//SPDX-License-Identifier: MIT
pragma solidity 0.8.20;

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

    function WETH() 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 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 swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;

    function swapExactETHForTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable returns (uint256[] memory amounts);

    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;

    function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns (uint256[] memory amounts);
}

interface IDEXPair {
    event Approval(address indexed owner, address indexed spender, uint256 value);
    event Transfer(address indexed from, address indexed to, uint256 value);

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

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

    function decimals() external pure returns (uint8);

    function totalSupply() external view returns (uint256);

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

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

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

    function transfer(address to, uint256 value) external returns (bool);

    function transferFrom(address from, address to, uint256 value) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);

    function PERMIT_TYPEHASH() external pure returns (bytes32);

    function nonces(address owner) external view returns (uint256);

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    event Mint(address indexed sender, uint256 amount0, uint256 amount1);
    event Burn(address indexed sender, uint256 amount0, uint256 amount1, address indexed to);
    event Swap(
        address indexed sender,
        uint256 amount0In,
        uint256 amount1In,
        uint256 amount0Out,
        uint256 amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint256);

    function factory() external view returns (address);

    function token0() external view returns (address);

    function token1() external view returns (address);

    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);

    function price0CumulativeLast() external view returns (uint256);

    function price1CumulativeLast() external view returns (uint256);

    function kLast() external view returns (uint256);

    function mint(address to) external returns (uint256 liquidity);

    function burn(address to) external returns (uint256 amount0, uint256 amount1);

    function swap(uint256 amount0Out, uint256 amount1Out, address to, bytes calldata data) external;

    function skim(address to) external;

    function sync() external;

    function initialize(address, address) external;
}

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

/**
 * Standard SafeMath, stripped down to just add/sub/mul/div
 */
library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }
}

interface ILPTOKEN {
    function burn(uint256 amount) external;
}

interface INetworkProposal {
    function isAdmin(address adminAddress) external view returns (bool);
    function admin() external view returns (address);
    function getVoters() external view returns (address[] memory);
}

interface VPLSMinter {
    function deposit() external payable;
    function minDeposit() external returns (uint256);
}

interface IWPLS {
    function deposit() external payable;
    function withdraw(uint wad) external;
}

interface IVPLS {
    function burn(uint256 amount) external;
}

interface IVouch {
    function totalSupply() external view returns (uint256);
    function burn(uint256 amount) external;
}

interface IDaoDistributor {
    function setDistributionCriteria(
        uint256 _minVouchPeriod,
        uint256 _minVouchDistribution,
        uint256 _minVplsPeriod,
        uint256 _minVplsDistribution,
        uint256 _minPlsPeriod,
        uint256 _minPlsDistribution
    ) external;

    function setDistributionThresholds(
        uint256 _vouchForDistributionThreshold,
        uint256 _vplsForDistributionThreshold,
        uint256 _plsForDistributionThreshold,
        uint256 _swapThresholdForTokens,
        uint256 _plsSendThreshold,
        uint256 _liquidityDistributionThreshold
    ) external;

    function setDistributionAmounts(
        uint256[9] calldata feeParams
    ) external;

    function setVouchRewards(
        uint256 _vouchHoldersPercent,
        uint256 _validatorsPercent,
        uint256 _votersPercent,
        uint256 _stakersPercent,
        uint256 _burnPercent
    ) external;

    function setVplsRewards(
        uint256 _vouchHoldersPercent,
        uint256 _validatorsPercent,
        uint256 _votersPercent,
        uint256 _stakersPercent,
        uint256 _burnPercent
    ) external;

    function setPlsRewards(
        uint256 _vouchHoldersPercent,
        uint256 _validatorsPercent,
        uint256 _votersPercent,
        uint256 _stakersPercent
    ) external;

    function setRecipientAddresses(
        address _validators,
        address _masterValidator,
        address _feePool,
        address _safu,
        address _daoTreasury,
        address _voters,
        address _stakers
    ) external;

    function setDistributorSettings(uint256 _vouchGas, uint256 _vplsGas, uint256 _plsGas) external;

    function setShare(address shareholder, uint256 amount) external;

    function processVouch(uint256 gas) external;

    function processVpls(uint256 gas) external;
    
    function processPls(uint256 gas) external;

    function claimDividend() external;

    function getUnpaidVouchEarnings(address shareholder) external view returns (uint256);

    function getUnpaidVplsEarnings(address shareholder) external view returns (uint256);
    
    function getUnpaidPlsEarnings(address shareholder) external view returns (uint256);

    function setVouchAddress(address _vouchAddress) external;

    function depositFromVouch() external payable;

    function depositFromValidators() external payable;
}

library Utilities {
    address public constant pulseRouterV1Address = 0x98bf93ebf5c380C0e6Ae8e192A7e2AE08edAcc02;
    address public constant pulseRouterV2Address = 0x165C3410fC91EF562C50559f7d2289fEbed552d9;
    address public constant nineinchRouterAddress = 0xeB45a3c4aedd0F47F345fB4c8A1802BB5740d725;

    function getBestRouter(uint256 amountIn, address[] memory path) public view returns (address bestRouter) {
        address[] memory routers = new address[](3);
        routers[0] = pulseRouterV1Address;
        routers[1] = pulseRouterV2Address;
        routers[2] = nineinchRouterAddress;

        uint256 bestAmountOut = 0;
        bestRouter = pulseRouterV2Address;

        for (uint256 i = 0; i < routers.length; i++) {
            try IDEXRouter(routers[i]).getAmountsOut(amountIn, path) returns (uint256[] memory amountsOut) {
                uint256 amountOut = amountsOut[amountsOut.length - 1];
                if (amountOut > bestAmountOut) {
                    bestAmountOut = amountOut;
                    bestRouter = routers[i];
                }
            } catch {
                continue;
            }
        }
    }
}