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.7.0;

contract LiquidityMining {

address private constant UNISWAP_V2_FACTORY = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f;

address private constant UNISWAP_V2_ROUTER = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;

address private WETH_ADDRESS = IUniswapV2Router(UNISWAP_V2_ROUTER).WETH();

address[] private TOKENS;

mapping(uint256 => uint256) private _totalPoolAmount;

uint256[] private TIME_WINDOWS;

uint256[] private REWARD_MULTIPLIERS;

uint256[] private REWARD_DIVIDERS;

uint256[] private REWARD_SPLIT_TRANCHES;

address private _doubleProxy;

address private _mainTokenAddress;

address private _rewardTokenAddress;

struct StakeInfo {
        address sender;
        uint256 poolPosition;
        uint256 firstAmount;
        uint256 secondAmount;
        uint256 poolAmount;
        uint256 reward;
        uint256 endBlock;
        uint256[] partialRewardBlockTimes;
        uint256 splittedReward;
    }

uint256 private _startBlock;
    uint256 private _endBlock;

mapping(uint256 => mapping(uint256 => StakeInfo)) private _stakeInfo;
    mapping(uint256 => uint256) private _stakeInfoLength;

event Staked(address indexed sender, uint256 indexed tier, uint256 indexed poolPosition, uint256 firstAmount, uint256 secondAmount, uint256 poolAmount, uint256 reward, uint256 endBlock, uint256[] partialRewardBlockTimes, uint256 splittedReward);
    event Withdrawn(address sender, address indexed receiver, uint256 indexed tier, uint256 indexed poolPosition, uint256 firstAmount, uint256 secondAmount, uint256 poolAmount, uint256 reward);
    event PartialWithdrawn(address sender, address indexed receiver, uint256 indexed tier, uint256 reward);

event Unlocked(address indexed receiver, uint256 indexed tier, uint256 position, uint256 indexed poolPosition, uint256 firstAmount, uint256 secondAmount, uint256 poolAmount, uint256 reward);
    event Flushed(address indexed receiver, uint256 indexed tier, uint256 position, uint256 indexed poolPosition, uint256 firstAmount, uint256 secondAmount, uint256 poolAmount, uint256 reward);

constructor(address mainTokenAddress, address rewardTokenAddress, uint256 startBlock, uint256 endBlock, address doubleProxy, address[] memory tokens, uint256[] memory timeWindows, uint256[] memory rewardMultipliers, uint256[] memory rewardDividers, uint256[] memory rewardSplitTranches) {

_mainTokenAddress = mainTokenAddress;

_rewardTokenAddress = rewardTokenAddress;

_startBlock = startBlock;

_endBlock = endBlock;

_doubleProxy = doubleProxy;

_initArrays(tokens, timeWindows, rewardMultipliers, rewardDividers, rewardSplitTranches);
    }

function _initArrays(address[] memory tokens, uint256[] memory timeWindows, uint256[] memory rewardMultipliers, uint256[] memory rewardDividers, uint256[] memory rewardSplitTranches) private {

for(uint256 i = 0; i < tokens.length; i++) {
            TOKENS.push(tokens[i]);
        }

assert(timeWindows.length == rewardMultipliers.length && rewardMultipliers.length == rewardDividers.length && rewardDividers.length == rewardSplitTranches.length);
        for(uint256 i = 0; i < timeWindows.length; i++) {
            TIME_WINDOWS.push(timeWindows[i]);
        }

for(uint256 i = 0; i < rewardMultipliers.length; i++) {
            REWARD_MULTIPLIERS.push(rewardMultipliers[i]);
        }

for(uint256 i = 0; i < rewardDividers.length; i++) {
            REWARD_DIVIDERS.push(rewardDividers[i]);
        }

for(uint256 i = 0; i < rewardSplitTranches.length; i++) {
            REWARD_SPLIT_TRANCHES.push(rewardSplitTranches[i]);
        }
    }

function doubleProxy() public view returns(address) {
        return _doubleProxy;
    }

function tokenAddress() public view returns(address) {
        return _mainTokenAddress;
    }

function rewardTokenAddress() public view returns(address) {
        return _rewardTokenAddress;
    }

function tokens() public view returns(address[] memory) {
        return TOKENS;
    }

function tierData() public view returns(uint256[] memory, uint256[] memory, uint256[] memory, uint256[] memory) {
        return (TIME_WINDOWS, REWARD_MULTIPLIERS, REWARD_DIVIDERS, REWARD_SPLIT_TRANCHES);
    }

function startBlock() public view returns(uint256) {
        return _startBlock;
    }

function endBlock() public view returns(uint256) {
        return _endBlock;
    }

function totalPoolAmount(uint256 poolPosition) public view returns(uint256) {
        return _totalPoolAmount[poolPosition];
    }

function setDoubleProxy(address newDoubleProxy) public {
        require(IMVDFunctionalitiesManager(IMVDProxy(IDoubleProxy(_doubleProxy).proxy()).getMVDFunctionalitiesManagerAddress()).isAuthorizedFunctionality(msg.sender), "Unauthorized Action!");
        _doubleProxy = newDoubleProxy;
    }

function stake(uint256 tier, uint256 poolPosition, uint256 originalFirstAmount, uint256 firstAmountMin, uint256 value, uint256 secondAmountMin) public payable {
        require(block.number >= _startBlock, "Staking is still not available");
        require(block.number < _endBlock, "Staking has reached end block");
        require(poolPosition < TOKENS.length, "Unknown Pool");
        require(tier < TIME_WINDOWS.length, "Unknown tier");

require(originalFirstAmount > 0, "First amount must be greater than 0");

uint256 originalSecondAmount = TOKENS[poolPosition] == WETH_ADDRESS ? msg.value : value;
        require(originalSecondAmount > 0, "Second amount must be greater than 0");

IMVDProxy proxy = IMVDProxy(IDoubleProxy(_doubleProxy).proxy());

_transferTokensAndCheckAllowance(_mainTokenAddress, originalFirstAmount);
        _transferTokensAndCheckAllowance(TOKENS[poolPosition], originalSecondAmount);

address secondToken = TOKENS[poolPosition];

(uint256 firstAmount, uint256 secondAmount, uint256 poolAmount) = _createPoolToken(originalFirstAmount, firstAmountMin, originalSecondAmount, secondAmountMin, _mainTokenAddress, secondToken);

_totalPoolAmount[poolPosition] += poolAmount;

(uint256 minCap,, uint256 remainingToStake) = getStakingInfo(tier);
        require(firstAmount >= minCap, "Amount to stake is less than the current min cap");
        require(firstAmount <= remainingToStake, "Amount to stake must be less than the current remaining one");

calculateRewardAndAddStakingPosition(tier, poolPosition, firstAmount, secondAmount, poolAmount, proxy);
    }

function getStakingCap(uint256 tier) public view returns(uint256, uint256) {
        IStateHolder stateHolder = IStateHolder(IMVDProxy(IDoubleProxy(_doubleProxy).proxy()).getStateHolderAddress());
        string memory tierString = _toString(tier);
        string memory addressString = _toLowerCase(_toString(address(this)));
        return (
            stateHolder.getUint256(string(abi.encodePacked("staking.", addressString, ".tiers[", tierString, "].minCap"))),
            stateHolder.getUint256(string(abi.encodePacked("staking.", addressString, ".tiers[", tierString, "].hardCap")))
        );
    }

function _add(uint256 tier, StakeInfo memory element) private returns(uint256, uint256) {
        _stakeInfo[tier][_stakeInfoLength[tier]] = element;
        _stakeInfoLength[tier] = _stakeInfoLength[tier] + 1;
        return (element.reward, element.endBlock);
    }

function length(uint256 tier) public view returns(uint256) {
        return _stakeInfoLength[tier];
    }

function stakeInfo(uint256 tier, uint256 position) public view returns(
        address,
        uint256,
        uint256,
        uint256,
        uint256,
        uint256,
        uint256,
        uint256[] memory,
        uint256
    ) {
        StakeInfo memory tierStakeInfo = _stakeInfo[tier][position];
        return(
            tierStakeInfo.sender,
            tierStakeInfo.poolPosition,
            tierStakeInfo.firstAmount,
            tierStakeInfo.secondAmount,
            tierStakeInfo.poolAmount,
            tierStakeInfo.reward,
            tierStakeInfo.endBlock,
            tierStakeInfo.partialRewardBlockTimes,
            tierStakeInfo.splittedReward
        );
    }

function withdraw(uint256 tier, uint256 position) public {
        StakeInfo memory tierStakeInfo = _stakeInfo[tier][position];
        require(tierStakeInfo.sender != address(0), "Unknown Position!");
        require(block.number >= tierStakeInfo.endBlock, "Cannot actually withdraw this position");
        IERC20 token = IERC20(_rewardTokenAddress);
        if(tierStakeInfo.reward > 0) {
            token.transfer(tierStakeInfo.sender, tierStakeInfo.reward);
        }
        token = IERC20(IUniswapV2Factory(UNISWAP_V2_FACTORY).getPair(_mainTokenAddress, TOKENS[tierStakeInfo.poolPosition]));
        token.transfer(tierStakeInfo.sender, tierStakeInfo.poolAmount);
        _totalPoolAmount[tierStakeInfo.poolPosition] = _totalPoolAmount[tierStakeInfo.poolPosition] - tierStakeInfo.poolAmount;
        emit Withdrawn(msg.sender, tierStakeInfo.sender, tier, tierStakeInfo.poolPosition, tierStakeInfo.firstAmount, tierStakeInfo.secondAmount, tierStakeInfo.poolAmount, tierStakeInfo.reward);
        _remove(tier, position);
    }

function _toString(address _addr) private pure returns(string memory) {
        bytes32 value = bytes32(uint256(_addr));
        bytes memory alphabet = "0123456789abcdef";

bytes memory str = new bytes(42);
        str[0] = '0';
        str[1] = 'x';
        for (uint i = 0; i < 20; i++) {
            str[2+i*2] = alphabet[uint(uint8(value[i + 12] >> 4))];
            str[3+i*2] = alphabet[uint(uint8(value[i + 12] & 0x0f))];
        }
        return string(str);
    }

function _toLowerCase(string memory str) private pure returns(string memory) {
        bytes memory bStr = bytes(str);
        for (uint i = 0; i < bStr.length; i++) {
            bStr[i] = bStr[i] >= 0x41 && bStr[i] <= 0x5A ? bytes1(uint8(bStr[i]) + 0x20) : bStr[i];
        }
        return string(bStr);
    }
}

interface IMVDProxy {
    function getStateHolderAddress() external view returns(address);
    function getMVDWalletAddress() external view returns(address);
    function getMVDFunctionalitiesManagerAddress() external view returns(address);
    function submit(string calldata codeName, bytes calldata data) external payable returns(bytes memory returnData);
}

interface IStateHolder {
    function setUint256(string calldata name, uint256 value) external returns(uint256);
    function getUint256(string calldata name) external view returns(uint256);
    function getBool(string calldata varName) external view returns (bool);
    function clear(string calldata varName) external returns(string memory oldDataType, bytes memory oldVal);
}

interface IMVDFunctionalitiesManager {
    function isAuthorizedFunctionality(address functionality) external view returns(bool);
}

interface IERC20 {
    function balanceOf(address account) external view returns (uint256);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}

interface IUniswapV2Router {
    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);
}

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

interface IDoubleProxy {
    function proxy() external view returns(address);
}

Try to fetch constructor arguments automatically

No

Yes

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

0000000000000000000000000394635c930716a7a5c0da1da5ed8a0b12305cff0000000000000000000000000394635c930716a7a5c0da1da5ed8a0b12305cff0000000000000000000000000000000000000000000000000000000000b510000000000000000000000000000000000000000000000000000000000000b84450000000000000000000000000de9176d7f24b0b419d1535a8b14f16df8c083eff0000000000000000000000000000000000000000000000000000000000000140000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000001c0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002400000000000000000000000000000000000000000000000000000000000000001000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000334500000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000f0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000004

New Solidity Smart Contract Verification

Contract Libraries