Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./libs/maths/SafeMath.sol";
import "./libs/string.sol";
import "./interfaces/IERC20.sol";
import "./libs/sort.sol";

struct GlqStaker {
    address wallet;
    uint256 block_number;
    uint256 amount;
    uint256 index_at;
    bool already_withdrawn;
}

struct GraphLinqApyStruct {
    uint256 tier1Apy;
    uint256 tier2Apy;
    uint256 tier3Apy;      
}

contract GlqStakingContract {

    using SafeMath for uint256;
    using strings for *;
    using QuickSorter for *;

    event NewStakerRegistered (
        address staker_address,
        uint256 at_block,
        uint256 amount_registered
    );

    /*
    ** Address of the GLQ token hash: 0x9F9c8ec3534c3cE16F928381372BfbFBFb9F4D24
    */
    address private _glqTokenAddress;

    /*
    ** Manager of the contract to add/remove APYs bonuses into the staking contract
    */
    address private _glqDeployerManager;

    /*
    ** Current amount of GLQ available in the pool as rewards
    */
    uint256 private _totalGlqIncentive;

    GlqStaker[]                     private _stakers;
    uint256                         private _stakersIndex;
    uint256                         private _totalStaked;
    bool                            private _emergencyWithdraw;

    mapping(address => uint256)     private _indexStaker;
    uint256                         private _blocksPerYear;
    GraphLinqApyStruct              private _apyStruct;

    constructor(address glqAddr, address manager) {
        _glqTokenAddress = glqAddr;
        _glqDeployerManager = manager;

        _totalStaked = 0;
        _stakersIndex = 1;
        
        _blocksPerYear = 2250000;
        
        // default t1: 30%, t2: 15%, t3: 7.5%
        _apyStruct = GraphLinqApyStruct(50*1e18, 25*1e18, 12500000000000000000);
    }


    /* Getter ---- Read-Only */

    /*
    ** Return the sender wallet position from the tier system
    */
    function getWalletCurrentTier(address wallet) public view returns (uint256) {
        uint256 currentTier = 3;
        uint256 index = _indexStaker[wallet];
        require(
            index != 0,
            "You dont have any tier rank currently in the Staking contract."
        );
        uint256 walletAggregatedIndex = (index).mul(1e18);

        // Total length of stakers
        uint256 totalIndex = _stakers.length.mul(1e18);
        // 15% of hodlers in T1 
        uint256 t1MaxIndex = totalIndex.div(100).mul(15);
        // 55% of hodlers in T2
        uint256 t2MaxIndex = totalIndex.div(100).mul(55);

        if (walletAggregatedIndex <= t1MaxIndex) {
            currentTier = 1;
        } else if (walletAggregatedIndex > t1MaxIndex && walletAggregatedIndex <= t2MaxIndex) {
            currentTier = 2;
        }

        return currentTier;
    }

    /*
    ** Return rank position of a wallet
    */
    function getPosition(address wallet) public view returns (uint256) {
         uint256 index = _indexStaker[wallet];
         return index;
    }

    /*
    ** Return the amount of GLQ that a wallet can currently claim from the staking contract
    */
    function getGlqToClaim(address wallet) public view returns(uint256) {
        uint256 index = _indexStaker[wallet];
        require (index > 0, "Invalid staking index");
        GlqStaker storage staker = _stakers[index - 1];

        uint256 calculatedApr = getWaitingPercentAPR(wallet);
        return staker.amount.mul(calculatedApr).div(100).div(1e18);
    }

    /*
    ** Return the current percent winnable for a staker wallet
    */
    function getWaitingPercentAPR(address wallet) public view returns(uint256) {
        uint256 index = _indexStaker[wallet];
        require (index > 0, "Invalid staking index");
        GlqStaker storage staker = _stakers[index - 1];

        uint256 walletTier = getWalletCurrentTier(wallet);
        uint256 blocksSpent = block.number.sub(staker.block_number);
        if (blocksSpent == 0) { return 0; }
        uint256 percentYearSpent = percent(blocksSpent.mul(10000), _blocksPerYear.mul(10000), 20);

        uint256 percentAprGlq = _apyStruct.tier3Apy;
        if (walletTier == 1) {
            percentAprGlq = _apyStruct.tier1Apy;
        } else if (walletTier == 2) {
            percentAprGlq = _apyStruct.tier2Apy;
        }

        return percentAprGlq.mul(percentYearSpent).div(100).div(1e18);
    }

    /*
    ** Return the total amount of GLQ as incentive rewards in the contract
    */
    function getTotalIncentive() public view returns (uint256) {
        return _totalGlqIncentive;
    }

    /*
    ** Return the total amount in staking for an hodler.
    */
    function getDepositedGLQ(address wallet) public view returns (uint256) {
        uint256 index = _indexStaker[wallet];
        if (index == 0) { return 0; }
        return _stakers[index-1].amount;
    }

    /*
    ** Count the total numbers of stakers in the contract
    */
    function getTotalStakers() public view returns(uint256) {
        return _stakers.length;
    }

    /*
    ** Return all APY per different Tier
    */
    function getTiersAPY() public view returns(uint256, uint256, uint256) {
        return (_apyStruct.tier1Apy, _apyStruct.tier2Apy, _apyStruct.tier3Apy);
    }

    /*
    ** Return the Total staked amount
    */
    function getTotalStaked() public view returns(uint256) {
        return _totalStaked;
    }

    /*
    ** Return the top 3 of stakers (by age)
    */
    function getTopStakers() public view returns(address[] memory, uint256[] memory) {
        uint256 len = _stakers.length;
        address[] memory addresses = new address[](3);
        uint256[] memory amounts = new uint256[](3);

        for (uint i = 0; i < len && i <= 2; i++) {
            addresses[i] = _stakers[i].wallet;
            amounts[i] = _stakers[i].amount;
        }

        return (addresses, amounts);
    }

    /*
    ** Return the total amount deposited on a rank tier
    */
    function getTierTotalStaked(uint tier) public view returns (uint256) {
        uint256 totalAmount = 0;

        // Total length of stakers
        uint256 totalIndex = _stakers.length.mul(1e18);
        // 15% of hodlers in T1 
        uint256 t1MaxIndex = totalIndex.div(100).mul(15);
        // 55% of hodlers in T2
        uint256 t2MaxIndex = totalIndex.div(100).mul(55);

        uint startIndex = (tier == 1) ? 0 : t1MaxIndex.div(1e18);
        uint endIndex = (tier == 1) ? t1MaxIndex.div(1e18) : t2MaxIndex.div(1e18);
        
        if (tier == 3) {
            startIndex = t2MaxIndex.div(1e18);
            endIndex = _stakers.length;
        }

        for (uint i = startIndex; i <= endIndex && i < _stakers.length; i++) {
            totalAmount +=  _stakers[i].amount;
        }
      
        return totalAmount;
    }

    /* Getter ---- Read-Only */


    /* Setter - Read & Modifications */


    /*
    ** Enable emergency withdraw by GLQ Deployer
    */
    function setEmergencyWithdraw(bool state) public {
        require (
            msg.sender == _glqDeployerManager,
            "Only the Glq Deployer can change the state of the emergency withdraw"
        );
        _emergencyWithdraw = state;
    }

    /*
    ** Set numbers of blocks spent per year to calculate claim rewards
    */
    function setBlocksPerYear(uint256 blocks) public {
        require(
            msg.sender == _glqDeployerManager,
            "Only the Glq Deployer can change blocks spent per year");
        _blocksPerYear = blocks;
    }

    /*
    ** Update the APY rewards for each tier in percent per year
    */
    function setApyPercentRewards(uint256 t1, uint256 t2, uint256 t3) public {
        require(
            msg.sender == _glqDeployerManager,
            "Only the Glq Deployer can APY rewards");
        GraphLinqApyStruct memory newApy = GraphLinqApyStruct(t1, t2, t3);
        _apyStruct = newApy;
    }

    /*
    ** Add GLQ liquidity in the staking contract for stakers rewards 
    */
    function addIncentive(uint256 glqAmount) public {
        IERC20 glqToken = IERC20(_glqTokenAddress);
        require(
            msg.sender == _glqDeployerManager,
            "Only the Glq Deployer can add incentive into the smart-contract");
        require(
            glqToken.balanceOf(msg.sender) >= glqAmount,
            "Insufficient funds from the deployer contract");
        require(
            glqToken.transferFrom(msg.sender, address(this), glqAmount) == true,
            "Error transferFrom on the contract"
        );
        _totalGlqIncentive += glqAmount;
    }

    /*
    ** Remove GLQ liquidity from the staking contract for stakers rewards 
    */
    function removeIncentive(uint256 glqAmount) public {
        IERC20 glqToken = IERC20(_glqTokenAddress);
        require(
            msg.sender == _glqDeployerManager,
            "Only the Glq Deployer can remove incentive from the smart-contract");
        require(
            glqToken.balanceOf(address(this)) >= glqAmount,
            "Insufficient funds from the deployer contract");
        require(
            glqToken.transfer(msg.sender, glqAmount) == true,
            "Error transfer on the contract"
        );

        _totalGlqIncentive -= glqAmount;
    }


    /*
    ** Deposit GLQ in the staking contract to stake & earn
    */
    function depositGlq(uint256 glqAmount) public {
        IERC20 glqToken = IERC20(_glqTokenAddress);
        require(
            glqToken.balanceOf(msg.sender) >= glqAmount,
            "Insufficient funds from the sender");
        require(
           glqToken.transferFrom(msg.sender, address(this), glqAmount) == true,
           "Error transferFrom on the contract"
        );

        uint256 index = _indexStaker[msg.sender];
        _totalStaked += glqAmount;

        if (index == 0) {
            GlqStaker memory staker = GlqStaker(msg.sender, block.number, glqAmount, _stakersIndex, false);
            _stakers.push(staker);
            _indexStaker[msg.sender] = _stakersIndex;

            // emit event of a new staker registered at current block position
            emit NewStakerRegistered(msg.sender, block.number, glqAmount);
            _stakersIndex = _stakersIndex.add(1);
        }
        else {
            // claim rewards before adding new staking amount
            if (_stakers[index-1].amount > 0) {
                claimGlq();
            }
            _stakers[index-1].amount += glqAmount;
        }
    }

    function removeStaker(GlqStaker storage staker) private {
        uint256 currentIndex = _indexStaker[staker.wallet]-1;
        _indexStaker[staker.wallet] = 0;
        for (uint256 i= currentIndex ; i < _stakers.length-1 ; i++) {
            _stakers[i] = _stakers[i+1];
            _stakers[i].index_at = _stakers[i].index_at.sub(1);
            _indexStaker[_stakers[i].wallet] = _stakers[i].index_at;
        }
        _stakers.pop();

        // Remove the staker and decrease stakers index
        _stakersIndex = _stakersIndex.sub(1);
        if (_stakersIndex == 0) { _stakersIndex = 1; }
    }

    /*
    ** Emergency withdraw enabled by GLQ team in an emergency case
    */
    function emergencyWithdraw() public {
        require(
            _emergencyWithdraw == true,
            "The emergency withdraw feature is not enabled"
        );
        uint256 index = _indexStaker[msg.sender];
        require (index > 0, "Invalid staking index");
        GlqStaker storage staker = _stakers[index - 1];
        IERC20 glqToken = IERC20(_glqTokenAddress);

        require(
            staker.amount > 0,
         "Not funds deposited in the staking contract");

        require(
            glqToken.transfer(msg.sender, staker.amount) == true,
            "Error transfer on the contract"
        );
        staker.amount = 0;
    }

    /*
    ** Withdraw Glq from the staking contract (reduce the tier position)
    */
    function withdrawGlq() public {
        uint256 index = _indexStaker[msg.sender];
        require (index > 0, "Invalid staking index");
        GlqStaker storage staker = _stakers[index - 1];
        IERC20 glqToken = IERC20(_glqTokenAddress);
        require(
            staker.amount > 0,
         "Not funds deposited in the staking contract");
    
        //auto claim when withdraw
        claimGlq();

        _totalStaked -= staker.amount;
        require(
            glqToken.balanceOf(address(this)) >= staker.amount,
            "Insufficient funds from the deployer contract");
        require(
            glqToken.transfer(msg.sender, staker.amount) == true,
            "Error transfer on the contract"
        );
        staker.amount = 0;
        
        if (staker.already_withdrawn) {
            removeStaker(staker);
        } else {
            staker.already_withdrawn = true;
        }
    }

    function percent(uint256 numerator, uint256 denominator, uint256 precision) private pure returns(uint256) {
        uint256 _numerator  = numerator * 10 ** (precision+1);
        // with rounding of last digit
        uint256 _quotient =  ((_numerator / denominator) + 5) / 10;
        return ( _quotient);
    }

    /*
    ** Claim waiting rewards from the staking contract
    */
    function claimGlq() public returns(uint256) {
        uint256 index = _indexStaker[msg.sender];
        require (index > 0, "Invalid staking index");
        GlqStaker storage staker = _stakers[index - 1];
        uint256 glqToClaim = getGlqToClaim(msg.sender);
        IERC20 glqToken = IERC20(_glqTokenAddress);
        if (glqToClaim == 0) { return 0; }

        require(
            glqToken.balanceOf(address(this)) >= glqToClaim,
            "Not enough funds in the staking program to claim rewards"
        );

        staker.block_number = block.number;

        require(
            glqToken.transfer(msg.sender, glqToClaim) == true,
            "Error transfer on the contract"
        );
        return (glqToClaim);
    }

    /* Setter - Read & Modifications */

}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    function decimals() external view returns (uint8);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

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

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        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;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

pragma solidity ^0.8.0;

library QuickSorter {


  function sort(uint[] storage data) internal {

    uint n = data.length;
    uint[] memory arr = new uint[](n);
    uint i;

    for(i=0; i<n; i++) {
      arr[i] = data[i];
    }

    uint[] memory stack = new uint[](n+2);

    //Push initial lower and higher bound
    uint top = 1;
    stack[top] = 0;
    top = top + 1;
    stack[top] = n-1;

    //Keep popping from stack while is not empty
    while (top > 0) {

      uint h = stack[top];
      top = top - 1;
      uint l = stack[top];
      top = top - 1;

      i = l;
      uint x = arr[h];

      for(uint j=l; j<h; j++){
        if  (arr[j] <= x) {
          //Move smaller element
          (arr[i], arr[j]) = (arr[j],arr[i]);
          i = i + 1;
        }
      }
      (arr[i], arr[h]) = (arr[h],arr[i]);
      uint p = i;

      //Push left side to stack
      if (p > l + 1) {
        top = top + 1;
        stack[top] = l;
        top = top + 1;
        stack[top] = p - 1;
      }

      //Push right side to stack
      if (p+1 < h) {
        top = top + 1;
        stack[top] = p + 1;
        top = top + 1;
        stack[top] = h;
      }
    }

    for(i=0; i<n; i++) {
      data[i] = arr[i];
    }
  }

}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

library strings {
    using strings for *;
    
    struct slice {
        uint _len;
        uint _ptr;
    }

    function memcpy(uint dest, uint src, uint len_cpy) private pure {
        // Copy word-length chunks while possible
        for(; len_cpy >= 32; len_cpy -= 32) {
            assembly {
                mstore(dest, mload(src))
            }
            dest += 32;
            src += 32;
        }

        // Copy remaining bytes
        uint mask = 256 ** (32 - len_cpy) - 1;
        assembly {
            let srcpart := and(mload(src), not(mask))
            let destpart := and(mload(dest), mask)
            mstore(dest, or(destpart, srcpart))
        }
    }

    /*
     * @dev Returns a slice containing the entire string.
     * @param self The string to make a slice from.
     * @return A newly allocated slice containing the entire string.
     */
    function toSlice(string memory self) internal pure returns (slice memory) {
        uint ptr;
        assembly {
            ptr := add(self, 0x20)
        }
        return slice(bytes(self).length, ptr);
    }


    /*
     * @dev Returns a new slice containing the same data as the current slice.
     * @param self The slice to copy.
     * @return A new slice containing the same data as `self`.
     */
    function copy(slice memory self) internal pure returns (slice memory) {
        return slice(self._len, self._ptr);
    }

    /*
     * @dev Copies a slice to a new string.
     * @param self The slice to copy.
     * @return A newly allocated string containing the slice's text.
     */
    function toString(slice memory self) internal pure returns (string memory) {
        string memory ret = new string(self._len);
        uint retptr;
        assembly { retptr := add(ret, 32) }

        memcpy(retptr, self._ptr, self._len);
        return ret;
    }

    /*
     * @dev Returns the length in runes of the slice. Note that this operation
     *      takes time proportional to the length of the slice; avoid using it
     *      in loops, and call `slice.empty()` if you only need to know whether
     *      the slice is empty or not.
     * @param self The slice to operate on.
     * @return The length of the slice in runes.
     */
    function len(slice memory self) internal pure returns (uint l) {
        // Starting at ptr-31 means the LSB will be the byte we care about
        uint ptr = self._ptr - 31;
        uint end = ptr + self._len;
        for (l = 0; ptr < end; l++) {
            uint8 b;
            assembly { b := and(mload(ptr), 0xFF) }
            if (b < 0x80) {
                ptr += 1;
            } else if(b < 0xE0) {
                ptr += 2;
            } else if(b < 0xF0) {
                ptr += 3;
            } else if(b < 0xF8) {
                ptr += 4;
            } else if(b < 0xFC) {
                ptr += 5;
            } else {
                ptr += 6;
            }
        }
    }

    /*
     * @dev Returns true if the slice is empty (has a length of 0).
     * @param self The slice to operate on.
     * @return True if the slice is empty, False otherwise.
     */
    function empty(slice memory self) internal pure returns (bool) {
        return self._len == 0;
    }

    /*
     * @dev Returns a positive number if `other` comes lexicographically after
     *      `self`, a negative number if it comes before, or zero if the
     *      contents of the two slices are equal. Comparison is done per-rune,
     *      on unicode codepoints.
     * @param self The first slice to compare.
     * @param other The second slice to compare.
     * @return The result of the comparison.
     */
    function compare(slice memory self, slice memory other) internal pure returns (int) {
        uint shortest = self._len;
        if (other._len < self._len)
            shortest = other._len;

        uint selfptr = self._ptr;
        uint otherptr = other._ptr;
        for (uint idx = 0; idx < shortest; idx += 32) {
            uint a;
            uint b;
            assembly {
                a := mload(selfptr)
                b := mload(otherptr)
            }
            if (a != b) {
                // Mask out irrelevant bytes and check again
                uint256 mask = ~(2 ** (8 * (32 - shortest + idx)) - 1);
                uint256 diff = (a & mask) - (b & mask);
                if (diff != 0)
                    return int(diff);
            }
            selfptr += 32;
            otherptr += 32;
        }
        return int(self._len) - int(other._len);
    }

    /*
     * @dev Returns true if the two slices contain the same text.
     * @param self The first slice to compare.
     * @param self The second slice to compare.
     * @return True if the slices are equal, false otherwise.
     */
    function equals(slice memory self, slice memory other) internal pure returns (bool) {
        return compare(self, other) == 0;
    }

    /*
     * @dev Extracts the first rune in the slice into `rune`, advancing the
     *      slice to point to the next rune and returning `self`.
     * @param self The slice to operate on.
     * @param rune The slice that will contain the first rune.
     * @return `rune`.
     */
    function nextRune(slice memory self, slice memory rune) internal pure returns (slice memory) {
        rune._ptr = self._ptr;

        if (self._len == 0) {
            rune._len = 0;
            return rune;
        }

        uint l;
        uint b;
        // Load the first byte of the rune into the LSBs of b
        assembly { b := and(mload(sub(mload(add(self, 32)), 31)), 0xFF) }
        if (b < 0x80) {
            l = 1;
        } else if(b < 0xE0) {
            l = 2;
        } else if(b < 0xF0) {
            l = 3;
        } else {
            l = 4;
        }

        // Check for truncated codepoints
        if (l > self._len) {
            rune._len = self._len;
            self._ptr += self._len;
            self._len = 0;
            return rune;
        }

        self._ptr += l;
        self._len -= l;
        rune._len = l;
        return rune;
    }

    /*
     * @dev Returns the first rune in the slice, advancing the slice to point
     *      to the next rune.
     * @param self The slice to operate on.
     * @return A slice containing only the first rune from `self`.
     */
    function nextRune(slice memory self) internal pure returns (slice memory ret) {
        nextRune(self, ret);
    }

    /*
     * @dev Returns the number of the first codepoint in the slice.
     * @param self The slice to operate on.
     * @return The number of the first codepoint in the slice.
     */
    function ord(slice memory self) internal pure returns (uint ret) {
        if (self._len == 0) {
            return 0;
        }

        uint word;
        uint length;
        uint divisor = 2 ** 248;

        // Load the rune into the MSBs of b
        assembly { word:= mload(mload(add(self, 32))) }
        uint b = word / divisor;
        if (b < 0x80) {
            ret = b;
            length = 1;
        } else if(b < 0xE0) {
            ret = b & 0x1F;
            length = 2;
        } else if(b < 0xF0) {
            ret = b & 0x0F;
            length = 3;
        } else {
            ret = b & 0x07;
            length = 4;
        }

        // Check for truncated codepoints
        if (length > self._len) {
            return 0;
        }

        for (uint i = 1; i < length; i++) {
            divisor = divisor / 256;
            b = (word / divisor) & 0xFF;
            if (b & 0xC0 != 0x80) {
                // Invalid UTF-8 sequence
                return 0;
            }
            ret = (ret * 64) | (b & 0x3F);
        }

        return ret;
    }

    /*
     * @dev Returns the keccak-256 hash of the slice.
     * @param self The slice to hash.
     * @return The hash of the slice.
     */
    function keccak(slice memory self) internal pure returns (bytes32 ret) {
        assembly {
            ret := keccak256(mload(add(self, 32)), mload(self))
        }
    }

    /*
     * @dev Returns true if `self` starts with `needle`.
     * @param self The slice to operate on.
     * @param needle The slice to search for.
     * @return True if the slice starts with the provided text, false otherwise.
     */
    function startsWith(slice memory self, slice memory needle) internal pure returns (bool) {
        if (self._len < needle._len) {
            return false;
        }

        if (self._ptr == needle._ptr) {
            return true;
        }

        bool equal;
        assembly {
            let length := mload(needle)
            let selfptr := mload(add(self, 0x20))
            let needleptr := mload(add(needle, 0x20))
            equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
        }
        return equal;
    }

    /*
     * @dev Returns true if the slice ends with `needle`.
     * @param self The slice to operate on.
     * @param needle The slice to search for.
     * @return True if the slice starts with the provided text, false otherwise.
     */
    function endsWith(slice memory self, slice memory needle) internal pure returns (bool) {
        if (self._len < needle._len) {
            return false;
        }

        uint selfptr = self._ptr + self._len - needle._len;

        if (selfptr == needle._ptr) {
            return true;
        }

        bool equal;
        assembly {
            let length := mload(needle)
            let needleptr := mload(add(needle, 0x20))
            equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
        }

        return equal;
    }

    /*
     * @dev If `self` ends with `needle`, `needle` is removed from the
     *      end of `self`. Otherwise, `self` is unmodified.
     * @param self The slice to operate on.
     * @param needle The slice to search for.
     * @return `self`
     */
    function until(slice memory self, slice memory needle) internal pure returns (slice memory) {
        if (self._len < needle._len) {
            return self;
        }

        uint selfptr = self._ptr + self._len - needle._len;
        bool equal = true;
        if (selfptr != needle._ptr) {
            assembly {
                let length := mload(needle)
                let needleptr := mload(add(needle, 0x20))
                equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
            }
        }

        if (equal) {
            self._len -= needle._len;
        }

        return self;
    }

    event log_bytemask(bytes32 mask);


    // Returns the memory address of the first byte of the first occurrence of
    // `needle` in `self`, or the first byte after `self` if not found.
    function findPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
        uint ptr = selfptr;
        uint idx;

        if (needlelen <= selflen) {
            if (needlelen <= 32) {
                bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));

                bytes32 needledata;
                assembly { needledata := and(mload(needleptr), mask) }

                uint end = selfptr + selflen - needlelen;
                bytes32 ptrdata;
                assembly { ptrdata := and(mload(ptr), mask) }

                while (ptrdata != needledata) {
                    if (ptr >= end)
                        return selfptr + selflen;
                    ptr++;
                    assembly { ptrdata := and(mload(ptr), mask) }
                }
                return ptr;
            } else {
                // For long needles, use hashing
                bytes32 hash;
                assembly { hash := keccak256(needleptr, needlelen) }

                for (idx = 0; idx <= selflen - needlelen; idx++) {
                    bytes32 testHash;
                    assembly { testHash := keccak256(ptr, needlelen) }
                    if (hash == testHash)
                        return ptr;
                    ptr += 1;
                }
            }
        }
        return selfptr + selflen;
    }
    // Returns the memory address of the first byte after the last occurrence of
    // `needle` in `self`, or the address of `self` if not found.
    function rfindPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
        uint ptr;

        if (needlelen <= selflen) {
            if (needlelen <= 32) {
                bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));

                bytes32 needledata;
                assembly { needledata := and(mload(needleptr), mask) }

                ptr = selfptr + selflen - needlelen;
                bytes32 ptrdata;
                assembly { ptrdata := and(mload(ptr), mask) }

                while (ptrdata != needledata) {
                    if (ptr <= selfptr) 
                        return selfptr;
                    ptr--;
                    assembly { ptrdata := and(mload(ptr), mask) }
                }
                return ptr + needlelen;
            } else {
                // For long needles, use hashing
                bytes32 hash;
                assembly { hash := keccak256(needleptr, needlelen) }
                ptr = selfptr + (selflen - needlelen);
                while (ptr >= selfptr) {
                    bytes32 testHash;
                    assembly { testHash := keccak256(ptr, needlelen) }
                    if (hash == testHash)
                        return ptr + needlelen;
                    ptr -= 1;
                }
            }
        }
        return selfptr;
    }

    /*
     * @dev Modifies `self` to contain everything from the first occurrence of
     *      `needle` to the end of the slice. `self` is set to the empty slice
     *      if `needle` is not found.
     * @param self The slice to search and modify.
     * @param needle The text to search for.
     * @return `self`.
     */
    function find(slice memory self, slice memory needle) internal pure returns (slice memory) {
        uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
        self._len -= ptr - self._ptr;
        self._ptr = ptr;
        return self;
    }

    /*
     * @dev Modifies `self` to contain the part of the string from the start of
     *      `self` to the end of the first occurrence of `needle`. If `needle`
     *      is not found, `self` is set to the empty slice.
     * @param self The slice to search and modify.
     * @param needle The text to search for.
     * @return `self`.
     */
    function rfind(slice memory self, slice memory needle) internal pure returns (slice memory) {
        uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
        self._len = ptr - self._ptr;
        return self;
    }

    /*
     * @dev Splits the slice, setting `self` to everything after the first
     *      occurrence of `needle`, and `token` to everything before it. If
     *      `needle` does not occur in `self`, `self` is set to the empty slice,
     *      and `token` is set to the entirety of `self`.
     * @param self The slice to split.
     * @param needle The text to search for in `self`.
     * @param token An output parameter to which the first token is written.
     * @return `token`.
     */
    function split(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {
        uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
        token._ptr = self._ptr;
        token._len = ptr - self._ptr;
        if (ptr == self._ptr + self._len) {
            // Not found
            self._len = 0;
        } else {
            self._len -= token._len + needle._len;
            self._ptr = ptr + needle._len;
        }
        return token;
    }

    /*
     * @dev Splits the slice, setting `self` to everything after the first
     *      occurrence of `needle`, and returning everything before it. If
     *      `needle` does not occur in `self`, `self` is set to the empty slice,
     *      and the entirety of `self` is returned.
     * @param self The slice to split.
     * @param needle The text to search for in `self`.
     * @return The part of `self` up to the first occurrence of `delim`.
     */
    function split(slice memory self, slice memory needle) internal pure returns (slice memory token) {
        split(self, needle, token);
    }

    /*
     * @dev Splits the slice, setting `self` to everything before the last
     *      occurrence of `needle`, and `token` to everything after it. If
     *      `needle` does not occur in `self`, `self` is set to the empty slice,
     *      and `token` is set to the entirety of `self`.
     * @param self The slice to split.
     * @param needle The text to search for in `self`.
     * @param token An output parameter to which the first token is written.
     * @return `token`.
     */
    function rsplit(slice memory self, slice memory needle, slice memory token) internal pure returns (slice memory) {
        uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
        token._ptr = ptr;
        token._len = self._len - (ptr - self._ptr);
        if (ptr == self._ptr) {
            // Not found
            self._len = 0;
        } else {
            self._len -= token._len + needle._len;
        }
        return token;
    }

    /*
     * @dev Splits the slice, setting `self` to everything before the last
     *      occurrence of `needle`, and returning everything after it. If
     *      `needle` does not occur in `self`, `self` is set to the empty slice,
     *      and the entirety of `self` is returned.
     * @param self The slice to split.
     * @param needle The text to search for in `self`.
     * @return The part of `self` after the last occurrence of `delim`.
     */
    function rsplit(slice memory self, slice memory needle) internal pure returns (slice memory token) {
        rsplit(self, needle, token);
    }

    /*
     * @dev Counts the number of nonoverlapping occurrences of `needle` in `self`.
     * @param self The slice to search.
     * @param needle The text to search for in `self`.
     * @return The number of occurrences of `needle` found in `self`.
     */
    function count(slice memory self, slice memory needle) internal pure returns (uint cnt) {
        uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr) + needle._len;
        while (ptr <= self._ptr + self._len) {
            cnt++;
            ptr = findPtr(self._len - (ptr - self._ptr), ptr, needle._len, needle._ptr) + needle._len;
        }
    }

    /*
     * @dev Returns True if `self` contains `needle`.
     * @param self The slice to search.
     * @param needle The text to search for in `self`.
     * @return True if `needle` is found in `self`, false otherwise.
     */
    function contains(slice memory self, slice memory needle) internal pure returns (bool) {
        return rfindPtr(self._len, self._ptr, needle._len, needle._ptr) != self._ptr;
    }

    /*
     * @dev Returns a newly allocated string containing the concatenation of
     *      `self` and `other`.
     * @param self The first slice to concatenate.
     * @param other The second slice to concatenate.
     * @return The concatenation of the two strings.
     */
    function concat(slice memory self, slice memory other) internal pure returns (string memory) {
        string memory ret = new string(self._len + other._len);
        uint retptr;
        assembly { retptr := add(ret, 32) }
        memcpy(retptr, self._ptr, self._len);
        memcpy(retptr + self._len, other._ptr, other._len);
        return ret;
    }

    /*
     * @dev Joins an array of slices, using `self` as a delimiter, returning a
     *      newly allocated string.
     * @param self The delimiter to use.
     * @param parts A list of slices to join.
     * @return A newly allocated string containing all the slices in `parts`,
     *         joined with `self`.
     */
    function join(slice memory self, slice[] memory parts) internal pure returns (string memory) {
        if (parts.length == 0)
            return "";

        uint length = self._len * (parts.length - 1);
        for(uint i = 0; i < parts.length; i++)
            length += parts[i]._len;

        string memory ret = new string(length);
        uint retptr;
        assembly { retptr := add(ret, 32) }

        for(uint i = 0; i < parts.length; i++) {
            memcpy(retptr, parts[i]._ptr, parts[i]._len);
            retptr += parts[i]._len;
            if (i < parts.length - 1) {
                memcpy(retptr, self._ptr, self._len);
                retptr += self._len;
            }
        }

        return ret;
    }

     function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
        if (_i == 0) {
            return "0";
        }
        uint j = _i;
        uint lenn;
        while (j != 0) {
            lenn++;
            j /= 10;
        }
        bytes memory bstr = new bytes(lenn);
        uint k = lenn - 1;
        while (_i != 0) {
            bstr[k--] = bytes1(uint8(48 + _i % 10));
            _i /= 10;
        }
        return string(bstr);
    }

 function parseInt(string memory _a, uint _b) internal pure returns (uint _parsedInt) {
        bytes memory bresult = bytes(_a);
        uint mint = 0;
        bool decimals = false;
        for (uint i = 0; i < bresult.length; i++) {
            if ((uint(uint8(bresult[i])) >= 48) && (uint(uint8(bresult[i])) <= 57)) {
                if (decimals) {
                   if (_b == 0) {
                       break;
                   } else {
                       _b--;
                   }
                }
                mint *= 10;
                mint += uint(uint8(bresult[i])) - 48;
            } else if (uint(uint8(bresult[i])) == 46) {
                decimals = true;
            }
        }
        if (_b > 0) {
            mint *= 10 ** _b;
        }
        return mint;
    }

    function split_string(string memory raw, string memory by) pure internal returns(string[] memory)
	{
		strings.slice memory s = raw.toSlice();
		strings.slice memory delim = by.toSlice();
		string[] memory parts = new string[](s.count(delim));
		for (uint i = 0; i < parts.length; i++) {
			parts[i] = s.split(delim).toString();
		}
		return parts;
	}
}

{
  "remappings": [],
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "evmVersion": "istanbul",
  "libraries": {},
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"glqAddr","type":"address"},{"internalType":"address","name":"manager","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"staker_address","type":"address"},{"indexed":false,"internalType":"uint256","name":"at_block","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount_registered","type":"uint256"}],"name":"NewStakerRegistered","type":"event"},{"inputs":[{"internalType":"uint256","name":"glqAmount","type":"uint256"}],"name":"addIncentive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimGlq","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"glqAmount","type":"uint256"}],"name":"depositGlq","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"}],"name":"getDepositedGLQ","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"}],"name":"getGlqToClaim","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"}],"name":"getPosition","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tier","type":"uint256"}],"name":"getTierTotalStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTiersAPY","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTopStakers","outputs":[{"internalType":"address[]","name":"","type":"address[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalIncentive","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalStakers","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"}],"name":"getWaitingPercentAPR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"}],"name":"getWalletCurrentTier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"glqAmount","type":"uint256"}],"name":"removeIncentive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"t1","type":"uint256"},{"internalType":"uint256","name":"t2","type":"uint256"},{"internalType":"uint256","name":"t3","type":"uint256"}],"name":"setApyPercentRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"blocks","type":"uint256"}],"name":"setBlocksPerYear","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"state","type":"bool"}],"name":"setEmergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawGlq","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000009f9c8ec3534c3ce16f928381372bfbfbfb9f4d24000000000000000000000000e87e9c55a720c89257302237b76cd5ba386d3819

-----Decoded View---------------
Arg [0] : glqAddr (address): 0x9F9c8ec3534c3cE16F928381372BfbFBFb9F4D24
Arg [1] : manager (address): 0xe87e9c55A720C89257302237B76CD5bA386d3819

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000009f9c8ec3534c3ce16f928381372bfbfbfb9f4d24
Arg [1] : 000000000000000000000000e87e9c55a720c89257302237b76cd5ba386d3819