Contract 0x23de2004592b04d594d23c9a928d0552e29d6bea

Txn Hash Method
Block
From
To
Value [Txn Fee]
0x3f524981a7d805ed210f648d6b4094cfcaf788853fe6fff25fe841324c9be6acClaim128491692022-04-01 8:31:5750 days 23 hrs ago0xd5763d80763fa2599fb5feb578d1e963db0b0559 IN 0x23de2004592b04d594d23c9a928d0552e29d6bea0 AVAX0.00100169142135.032750015
0x391450444a3d34badc906bddc6bed2c077dd0f2b6b92334f97e9d91081c84db9Claim128491692022-04-01 8:31:5750 days 23 hrs ago0xd5763d80763fa2599fb5feb578d1e963db0b0559 IN 0x23de2004592b04d594d23c9a928d0552e29d6bea0 AVAX0.00099659935234.854662056
0x4937c37f761605005e0d532c4043f59efc25d103c1597735c4fac03fc2501f2cBecome Implement...45106282021-09-18 11:47:35245 days 20 hrs ago0x5423819b3b5bb38b0e9e9e59f22f9034e2d8819b IN 0x23de2004592b04d594d23c9a928d0552e29d6bea0 AVAX0.004677465 85
0x351f589b164751c1e26da6c03913a29fb17f15242a07ac15769f6605d36199800x6080604045104942021-09-18 11:43:07245 days 20 hrs ago0x5423819b3b5bb38b0e9e9e59f22f9034e2d8819b IN  Create: QiTokenSaleDistributor0 AVAX0.11903859 85
[ Download CSV Export 
Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
QiTokenSaleDistributor

Compiler Version
v0.6.12+commit.27d51765

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, None license

Contract Source Code (Solidity)

/**
 *Submitted for verification at snowtrace.io on 2021-11-02
*/

/**
 * File: ReentrancyGuard.sol
 */

// SPDX-License-Identifier: MIT

pragma solidity 0.6.12;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() public {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}


/**
 * File: EIP20Interface.sol
 */

pragma solidity 0.6.12;

/**
 * @title ERC 20 Token Standard Interface
 *  https://eips.ethereum.org/EIPS/eip-20
 */
interface EIP20Interface {
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);

    /**
      * @notice Get the total number of tokens in circulation
      * @return The supply of tokens
      */
    function totalSupply() external view returns (uint256);

    /**
     * @notice Gets the balance of the specified address
     * @param owner The address from which the balance will be retrieved
     * @return balance The balance
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
      * @notice Transfer `amount` tokens from `msg.sender` to `dst`
      * @param dst The address of the destination account
      * @param amount The number of tokens to transfer
      * @return success Whether or not the transfer succeeded
      */
    function transfer(address dst, uint256 amount) external returns (bool success);

    /**
      * @notice Transfer `amount` tokens from `src` to `dst`
      * @param src The address of the source account
      * @param dst The address of the destination account
      * @param amount The number of tokens to transfer
      * @return success Whether or not the transfer succeeded
      */
    function transferFrom(address src, address dst, uint256 amount) external returns (bool success);

    /**
      * @notice Approve `spender` to transfer up to `amount` from `src`
      * @dev This will overwrite the approval amount for `spender`
      *  and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve)
      * @param spender The address of the account which may transfer tokens
      * @param amount The number of tokens that are approved (-1 means infinite)
      * @return success Whether or not the approval succeeded
      */
    function approve(address spender, uint256 amount) external returns (bool success);

    /**
      * @notice Get the current allowance from `owner` for `spender`
      * @param owner The address of the account which owns the tokens to be spent
      * @param spender The address of the account which may transfer tokens
      * @return  remaining The number of tokens allowed to be spent (-1 means infinite)
      */
    function allowance(address owner, address spender) external view returns (uint256 remaining);

    event Transfer(address indexed from, address indexed to, uint256 amount);
    event Approval(address indexed owner, address indexed spender, uint256 amount);
}


/**
 * File: SafeMath.sol
 */

pragma solidity 0.6.12;

// From https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/Math.sol
// Subject to the MIT license.

/**
 * @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 addition of two unsigned integers, reverting with custom message on overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, errorMessage);

        return c;
    }

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

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on underflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot underflow.
     */
    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 multiplication of two unsigned integers, reverting on overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b, string memory errorMessage) 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, errorMessage);

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

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


/**
 * File: QiTokenSaleDistributorProxyStorage.sol
 */

pragma solidity 0.6.12;


contract QiTokenSaleDistributorProxyStorage {
    // Current contract admin address
    address public admin;

    // Requested new admin for the contract
    address public pendingAdmin;

    // Current contract implementation address
    address public implementation;

    // Requested new contract implementation address
    address public pendingImplementation;
}


/**
 * File: QiTokenSaleDistributorStorage.sol
 */

pragma solidity 0.6.12;



contract QiTokenSaleDistributorStorage is QiTokenSaleDistributorProxyStorage {
    // Token release interval in seconds
    uint constant public releasePeriodLength = 2628000; // = 60 * 60 * 24 * 365 / 12 = 1 month

    // Block time when the purchased tokens were initially released for claiming
    uint constant public vestingScheduleEpoch = 1629356400;

    address public dataAdmin;

    address public qiContractAddress;

    // Number of release periods in the vesting schedule; i.e.,
    // releasePeriods * releasePeriodLength = vesting period length
    // address => purchase round => release periods
    mapping(address => mapping(uint => uint)) public releasePeriods;

    // The percentage of tokens released on vesting schedule start (0-100)
    // address => purchase round => initial release percentage
    mapping(address => mapping(uint => uint)) public initialReleasePercentages;

    // Total number of purchased QI tokens by user
    // address => purchase round => purchased tokens
    mapping(address => mapping(uint => uint)) public purchasedTokens;

    // Total number of claimed QI tokens by user
    // address => purchase round => claimed tokens
    mapping(address => mapping(uint => uint)) public claimedTokens;

    // Number of purchase rounds completed by the user
    mapping(address => uint) public completedPurchaseRounds;
}


/**
 * File: QiTokenSaleDistributorProxy.sol
 */

pragma solidity 0.6.12;



contract QiTokenSaleDistributorProxy is ReentrancyGuard, QiTokenSaleDistributorProxyStorage {
    constructor() public {
        admin = msg.sender;
    }

    /**
     * Request a new admin to be set for the contract.
     *
     * @param newAdmin New admin address
     */
    function setPendingAdmin(address newAdmin) public adminOnly {
        pendingAdmin = newAdmin;
    }

    /**
     * Accept admin transfer from the current admin to the new.
     */
    function acceptPendingAdmin() public {
        require(msg.sender == pendingAdmin && pendingAdmin != address(0), "Caller must be the pending admin");

        admin = pendingAdmin;
        pendingAdmin = address(0);
    }

    /**
     * Request a new implementation to be set for the contract.
     *
     * @param newImplementation New contract implementation contract address
     */
    function setPendingImplementation(address newImplementation) public adminOnly {
        pendingImplementation = newImplementation;
    }

    /**
     * Accept pending implementation change
     */
    function acceptPendingImplementation() public {
        require(msg.sender == pendingImplementation && pendingImplementation != address(0), "Only the pending implementation contract can call this");

        implementation = pendingImplementation;
        pendingImplementation = address(0);
    }

    fallback() payable external {
        (bool success, ) = implementation.delegatecall(msg.data);

        assembly {
            let free_mem_ptr := mload(0x40)
            let size := returndatasize()
            returndatacopy(free_mem_ptr, 0, size)

            switch success
            case 0 { revert(free_mem_ptr, size) }
            default { return(free_mem_ptr, size) }
        }
    }

    /********************************************************
     *                                                      *
     *                      MODIFIERS                       *
     *                                                      *
     ********************************************************/

    modifier adminOnly {
        require(msg.sender == admin, "admin only");
        _;
    }
}


/**
 * File: QiTokenSaleDistributor.sol
 */

pragma solidity 0.6.12;



contract QiTokenSaleDistributor is ReentrancyGuard, QiTokenSaleDistributorStorage {
    using SafeMath for uint256;

    event Claim(address recipient, uint amount);

    constructor() public {
        admin = msg.sender;
    }


    /********************************************************
     *                                                      *
     *                   PUBLIC FUNCTIONS                   *
     *                                                      *
     ********************************************************/

    /*
     * Claim all available tokens for the invoking user.
     */
    function claim() public nonReentrant {
        uint availableTokensToClaim = 0;
        for (uint round = 0; round < completedPurchaseRounds[msg.sender]; round += 1) {
            uint claimableRoundTokens = _getClaimableTokenAmountPerRound(msg.sender, round);
            availableTokensToClaim = availableTokensToClaim.add(claimableRoundTokens);
            claimedTokens[msg.sender][round] = claimedTokens[msg.sender][round].add(claimableRoundTokens);
        }

        require(availableTokensToClaim > 0, "No available tokens to claim");

        EIP20Interface qi = EIP20Interface(qiContractAddress);
        qi.transfer(msg.sender, availableTokensToClaim);

        emit Claim(msg.sender, availableTokensToClaim);
    }

    /**
     * Get the amount of QI tokens available for the caller to claim.
     *
     * @return Number of QI tokens available for claiming
     */
    function getClaimableTokenAmount() public view returns (uint) {
        return _getClaimableTokenAmount(msg.sender);
    }

    /**
     * Get the amount of QI tokens available for the caller to claim from
     * the given purchase round.
     *
     * @param round Purchase round number
     * @return Number of QI tokens available for claiming from the given round
     */
    function getRoundClaimableTokenAmount(uint round) public view returns (uint) {
        return _getClaimableTokenAmountPerRound(msg.sender, round);
    }

    /**
     * Get the total number of claimed tokens by the user.
     *
     * @return Number of claimed QI tokens
     */
    function getClaimedTokenAmount() public view returns (uint) {
        uint claimedTokenAmount = 0;
        for (uint round = 0; round < completedPurchaseRounds[msg.sender]; round += 1) {
            claimedTokenAmount = claimedTokenAmount.add(claimedTokens[msg.sender][round]);
        }

        return claimedTokenAmount;
    }

    /**
     * Get the number of claimed tokens in a specific round by the user.
     *
     * @param round Purchase round number
     * @return Number of claimed QI tokens
     */
    function getRoundClaimedTokenAmount(uint round) public view returns (uint) {
        return claimedTokens[msg.sender][round];
    }

    /********************************************************
     *                                                      *
     *               ADMIN-ONLY FUNCTIONS                   *
     *                                                      *
     ********************************************************/

    /**
     * Set the QI token contract address.
     *
     * @param newQiContractAddress New address of the QI token contract
     */
    function setQiContractAddress(address newQiContractAddress) public adminOnly {
        qiContractAddress = newQiContractAddress;
    }

    /**
     * Set the amount of purchased QI tokens per user.
     *
     * @param recipients QI token recipients
     * @param rounds Purchase round number
     * @param tokenInitialReleasePercentages Initial token release percentages
     * @param tokenReleasePeriods Number of token release periods
     * @param amounts Purchased token amounts
     */
    function setPurchasedTokensByUser(
        address[] memory recipients,
        uint[] memory rounds,
        uint[] memory tokenInitialReleasePercentages,
        uint[] memory tokenReleasePeriods,
        uint[] memory amounts
    )
        public
        adminOrDataAdminOnly
    {
        require(recipients.length == rounds.length);
        require(recipients.length == tokenInitialReleasePercentages.length);
        require(recipients.length == tokenReleasePeriods.length);
        require(recipients.length == amounts.length);

        for (uint i = 0; i < recipients.length; i += 1) {
            address recipient = recipients[i];

            require(tokenInitialReleasePercentages[i] <= 100, "Invalid percentage");
            require(rounds[i] == completedPurchaseRounds[recipient], "Invalid round number");

            initialReleasePercentages[recipient][rounds[i]] = tokenInitialReleasePercentages[i].mul(1e18);
            releasePeriods[recipient][rounds[i]] = tokenReleasePeriods[i];
            purchasedTokens[recipient][rounds[i]] = amounts[i];
            completedPurchaseRounds[recipient] = rounds[i] + 1;
            claimedTokens[recipient][rounds[i]] = tokenInitialReleasePercentages[i].mul(1e18).mul(amounts[i]).div(100e18);
        }
    }

    /**
     * Reset all data for the given addresses.
     *
     * @param recipients Addresses whose data to reset
     */
    function resetPurchasedTokensByUser(address[] memory recipients) public adminOrDataAdminOnly {
        for (uint i = 0; i < recipients.length; i += 1) {
            address recipient = recipients[i];

            for (uint round = 0; round < completedPurchaseRounds[recipient]; round += 1) {
                initialReleasePercentages[recipient][round] = 0;
                releasePeriods[recipient][round] = 0;
                purchasedTokens[recipient][round] = 0;
                claimedTokens[recipient][round] = 0;
            }

            completedPurchaseRounds[recipient] = 0;
        }
    }

    /**
     * Withdraw deposited QI tokens from the contract.
     *
     * @param amount QI amount to withdraw from the contract balance
     */
    function withdrawQi(uint amount) public adminOnly {
        EIP20Interface qi = EIP20Interface(qiContractAddress);
        qi.transfer(msg.sender, amount);
    }

    /**
     * Accept this contract as the implementation for a proxy.
     *
     * @param proxy QiTokenSaleDistributorProxy
     */
    function becomeImplementation(QiTokenSaleDistributorProxy proxy) external {
        require(msg.sender == proxy.admin(), "Only proxy admin can change the implementation");
        proxy.acceptPendingImplementation();
    }

    /**
     * Set the data admin.
     *
     * @param newDataAdmin New data admin address
     */
    function setDataAdmin(address newDataAdmin) public adminOnly {
        dataAdmin = newDataAdmin;
    }


    /********************************************************
     *                                                      *
     *                  INTERNAL FUNCTIONS                  *
     *                                                      *
     ********************************************************/

    /**
     * Get the number of claimable QI tokens for a user at the time of calling.
     *
     * @param recipient Claiming user
     * @return Number of QI tokens
     */
    function _getClaimableTokenAmount(address recipient) internal view returns (uint) {
        if (completedPurchaseRounds[recipient] == 0) {
            return 0;
        }

        uint remainingClaimableTokensToDate = 0;
        for (uint round = 0; round < completedPurchaseRounds[recipient]; round += 1) {
            uint remainingRoundClaimableTokensToDate = _getClaimableTokenAmountPerRound(recipient, round);
            remainingClaimableTokensToDate = remainingClaimableTokensToDate.add(remainingRoundClaimableTokensToDate);
        }

        return remainingClaimableTokensToDate;
    }

    /**
     * Get the number of claimable QI tokens from a specific purchase round
     * for a user at the time of calling.
     *
     * @param recipient Recipient address
     * @param round Purchase round number
     * @return Available tokens to claim from the round
     */
    function _getClaimableTokenAmountPerRound(address recipient, uint round) internal view returns (uint) {
        require(round < completedPurchaseRounds[recipient], "Invalid round");

        if (completedPurchaseRounds[recipient] == 0) {
            return 0;
        }

        uint initialClaimableTokens = initialReleasePercentages[recipient][round].mul(purchasedTokens[recipient][round]).div(100e18);

        uint elapsedSecondsSinceEpoch = block.timestamp.sub(vestingScheduleEpoch);
        // Number of elapsed release periods after the initial release
        uint elapsedVestingReleasePeriods = elapsedSecondsSinceEpoch.div(releasePeriodLength);

        uint claimableTokensToDate = 0;
        if (elapsedVestingReleasePeriods.add(1) >= releasePeriods[recipient][round]) {
            claimableTokensToDate = purchasedTokens[recipient][round];
        } else {
            uint claimableTokensPerPeriod = purchasedTokens[recipient][round].sub(initialClaimableTokens).div(releasePeriods[recipient][round].sub(1));
            claimableTokensToDate = claimableTokensPerPeriod.mul(elapsedVestingReleasePeriods).add(initialClaimableTokens);
            if (claimableTokensToDate > purchasedTokens[recipient][round]) {
                claimableTokensToDate = purchasedTokens[recipient][round];
            }
        }

        uint remainingClaimableTokensToDate = claimableTokensToDate.sub(claimedTokens[recipient][round]);

        return remainingClaimableTokensToDate;
    }


    /********************************************************
     *                                                      *
     *                      MODIFIERS                       *
     *                                                      *
     ********************************************************/

    modifier adminOnly {
        require(msg.sender == admin, "admin only");
        _;
    }

    modifier adminOrDataAdminOnly {
        require(msg.sender == admin || (dataAdmin != address(0) && msg.sender == dataAdmin), "admin only");
        _;
    }
}

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Claim","type":"event"},{"inputs":[],"name":"admin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract QiTokenSaleDistributorProxy","name":"proxy","type":"address"}],"name":"becomeImplementation","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"claimedTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"completedPurchaseRounds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"dataAdmin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getClaimableTokenAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getClaimedTokenAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"round","type":"uint256"}],"name":"getRoundClaimableTokenAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"round","type":"uint256"}],"name":"getRoundClaimedTokenAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"implementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"initialReleasePercentages","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingAdmin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingImplementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"purchasedTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"qiContractAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"releasePeriodLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"releasePeriods","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"recipients","type":"address[]"}],"name":"resetPurchasedTokensByUser","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newDataAdmin","type":"address"}],"name":"setDataAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"recipients","type":"address[]"},{"internalType":"uint256[]","name":"rounds","type":"uint256[]"},{"internalType":"uint256[]","name":"tokenInitialReleasePercentages","type":"uint256[]"},{"internalType":"uint256[]","name":"tokenReleasePeriods","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"setPurchasedTokensByUser","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newQiContractAddress","type":"address"}],"name":"setQiContractAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"vestingScheduleEpoch","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawQi","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed ByteCode Sourcemap

16470:10342:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13038:24;;;:::i;:::-;;;;-1:-1:-1;;;;;13038:24:0;;;;;;;;;;;;;;13511:74;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;13511:74:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;14002:55;;;;;;;;;;;;;;;;-1:-1:-1;14002:55:0;-1:-1:-1;;;;;14002:55:0;;:::i;12360:27::-;;;:::i;18011:124::-;;;:::i;12536:36::-;;;:::i;17107:740::-;;;:::i;:::-;;12444:29;;;:::i;13071:32::-;;;:::i;23193:104::-;;;;;;;;;;;;;;;;-1:-1:-1;23193:104:0;-1:-1:-1;;;;;23193:104:0;;:::i;12975:54::-;;;:::i;18401:154::-;;;;;;;;;;;;;;;;-1:-1:-1;18401:154:0;;:::i;20335:1297::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;20335:1297:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;20335:1297:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20335:1297:0;;;;;;;;-1:-1:-1;20335:1297:0;;-1:-1:-1;;;;;20335:1297:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;20335:1297:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20335:1297:0;;;;;;;;-1:-1:-1;20335:1297:0;;-1:-1:-1;;;;;20335:1297:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;20335:1297:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20335:1297:0;;;;;;;;-1:-1:-1;20335:1297:0;;-1:-1:-1;;;;;20335:1297:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;20335:1297:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20335:1297:0;;;;;;;;-1:-1:-1;20335:1297:0;;-1:-1:-1;;;;;20335:1297:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;20335:1297:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20335:1297:0;;-1:-1:-1;20335:1297:0;;-1:-1:-1;;;;;20335:1297:0:i;22544:164::-;;;;;;;;;;;;;;;;-1:-1:-1;22544:164:0;;:::i;13299:63::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;13299:63:0;;;;;;;;:::i;21770:614::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;21770:614:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;21770:614:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;21770:614:0;;-1:-1:-1;21770:614:0;;-1:-1:-1;;;;;21770:614:0:i;13700:64::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;13700:64:0;;;;;;;;:::i;12795:50::-;;;:::i;13875:62::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;13875:62:0;;;;;;;;:::i;19825:136::-;;;;;;;;;;;;;;;;-1:-1:-1;19825:136:0;-1:-1:-1;;;;;19825:136:0;;:::i;19224:133::-;;;;;;;;;;;;;;;;-1:-1:-1;19224:133:0;;:::i;22855:225::-;;;;;;;;;;;;;;;;-1:-1:-1;22855:225:0;-1:-1:-1;;;;;22855:225:0;;:::i;18693:336::-;;;:::i;12286:20::-;;;:::i;13038:24::-;;;-1:-1:-1;;;;;13038:24:0;;:::o;13511:74::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;14002:55::-;;;;;;;;;;;;;:::o;12360:27::-;;;-1:-1:-1;;;;;12360:27:0;;:::o;18011:124::-;18067:4;18091:36;18116:10;18091:24;:36::i;:::-;18084:43;;18011:124;:::o;12536:36::-;;;-1:-1:-1;;;;;12536:36:0;;:::o;17107:740::-;1746:1;2349:7;;:19;;2341:63;;;;;-1:-1:-1;;;2341:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;1746:1;2482:7;:18;;;:7;17197:380:::1;17250:10;17226:35;::::0;;;:23:::1;:35;::::0;;;;;17218:43;::::1;17197:380;;;17290:25;17318:51;17351:10;17363:5;17318:32;:51::i;:::-;17290:79:::0;-1:-1:-1;17409:48:0::1;:22:::0;17290:79;17409:26:::1;:48::i;:::-;17521:10;17507:25;::::0;;;:13:::1;:25;::::0;;;;;;;:32;;;;;;;;;17384:73;;-1:-1:-1;17507:58:0::1;::::0;17544:20;17507:36:::1;:58::i;:::-;17486:10;17472:25;::::0;;;:13:::1;:25;::::0;;;;;;;:32;;;;;;;;:93;-1:-1:-1;17272:1:0::1;17263:10;17197:380;;;;17622:1;17597:22;:26;17589:67;;;::::0;;-1:-1:-1;;;17589:67:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;17704:17;::::0;17733:47:::1;::::0;;-1:-1:-1;;;17733:47:0;;17745:10:::1;17733:47;::::0;::::1;::::0;;;;;;;;;-1:-1:-1;;;;;17704:17:0;;::::1;::::0;;;17733:11:::1;::::0;:47;;;;;::::1;::::0;;;;;;;;17669:17:::1;17704::::0;17733:47;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;;17798:41:0::1;::::0;;17804:10:::1;17798:41:::0;;17733:47:::1;17798:41:::0;::::1;::::0;;;;;::::1;::::0;;;;;;;;;::::1;-1:-1:-1::0;;1702:1:0;2661:7;:22;17107:740::o;12444:29::-;;;-1:-1:-1;;;;;12444:29:0;;:::o;13071:32::-;;;-1:-1:-1;;;;;13071:32:0;;:::o;23193:104::-;26602:5;;-1:-1:-1;;;;;26602:5:0;26588:10;:19;26580:42;;;;;-1:-1:-1;;;26580:42:0;;;;;;;;;;;;-1:-1:-1;;;26580:42:0;;;;;;;;;;;;;;;23265:9:::1;:24:::0;;-1:-1:-1;;;;;;23265:24:0::1;-1:-1:-1::0;;;;;23265:24:0;;;::::1;::::0;;;::::1;::::0;;23193:104::o;12975:54::-;13019:10;12975:54;:::o;18401:154::-;18472:4;18496:51;18529:10;18541:5;18496:32;:51::i;:::-;18489:58;;18401:154;;;;:::o;20335:1297::-;26713:5;;-1:-1:-1;;;;;26713:5:0;26699:10;:19;;:75;;-1:-1:-1;26723:9:0;;-1:-1:-1;;;;;26723:9:0;:23;;;;:50;;-1:-1:-1;26764:9:0;;-1:-1:-1;;;;;26764:9:0;26750:10;:23;26723:50;26691:98;;;;;-1:-1:-1;;;26691:98:0;;;;;;;;;;;;-1:-1:-1;;;26691:98:0;;;;;;;;;;;;;;;20667:6:::1;:13;20646:10;:17;:34;20638:43;;;::::0;::::1;;20721:30;:37;20700:10;:17;:58;20692:67;;;::::0;::::1;;20799:19;:26;20778:10;:17;:47;20770:56;;;::::0;::::1;;20866:7;:14;20845:10;:17;:35;20837:44;;;::::0;::::1;;20899:6;20894:731;20915:10;:17;20911:1;:21;20894:731;;;20957:17;20977:10;20988:1;20977:13;;;;;;;;;;;;;;20957:33;;21052:3;21015:30;21046:1;21015:33;;;;;;;;;;;;;;:40;;21007:71;;;::::0;;-1:-1:-1;;;21007:71:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;21007:71:0;;;;;;;;;;;;;::::1;;-1:-1:-1::0;;;;;21114:34:0;::::1;;::::0;;;:23:::1;:34;::::0;;;;;21101:9;;:6;;21108:1;;21101:9;::::1;;;;;;;;;;;:47;21093:80;;;::::0;;-1:-1:-1;;;21093:80:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;21093:80:0;;;;;;;;;;;;;::::1;;21240:43;21278:4;21240:30;21271:1;21240:33;;;;;;;;;;;;;;:37;;:43;;;;:::i;:::-;-1:-1:-1::0;;;;;21190:36:0;::::1;;::::0;;;:25:::1;:36;::::0;;;;21227:9;;21190:36;;;21227:6;;21234:1;;21227:9;::::1;;;;;;;;;;;21190:47;;;;;;;;;;;:93;;;;21337:19;21357:1;21337:22;;;;;;;;;;;;;;21298:14;:25;21313:9;-1:-1:-1::0;;;;;21298:25:0::1;-1:-1:-1::0;;;;;21298:25:0::1;;;;;;;;;;;;:36;21324:6;21331:1;21324:9;;;;;;;;;;;;;;21298:36;;;;;;;;;;;:61;;;;21414:7;21422:1;21414:10;;;;;;;;;;;;;;21374:15;:26;21390:9;-1:-1:-1::0;;;;;21374:26:0::1;-1:-1:-1::0;;;;;21374:26:0::1;;;;;;;;;;;;:37;21401:6;21408:1;21401:9;;;;;;;;;;;;;;21374:37;;;;;;;;;;;:50;;;;21476:6;21483:1;21476:9;;;;;;;;;;;;;;21488:1;21476:13;21439:23;:34;21463:9;-1:-1:-1::0;;;;;21439:34:0::1;-1:-1:-1::0;;;;;21439:34:0::1;;;;;;;;;;;;:50;;;;21542:71;21606:6;21542:59;21590:7;21598:1;21590:10;;;;;;;;;;;;;;21542:43;21580:4;21542:30;21573:1;21542:33;;;;;;;:43;:47:::0;::::1;:59::i;:::-;:63:::0;::::1;:71::i;:::-;-1:-1:-1::0;;;;;21504:24:0;::::1;;::::0;;;:13:::1;:24;::::0;;;;21529:9;;21504:24;;;21529:6;;21536:1;;21529:9;::::1;;;;;;;;;;;21504:35;;;;;;;;;;;:109;;;;20894:731;20939:1;20934:6;;;;20894:731;;;;20335:1297:::0;;;;;:::o;22544:164::-;26602:5;;-1:-1:-1;;;;;26602:5:0;26588:10;:19;26580:42;;;;;-1:-1:-1;;;26580:42:0;;;;;;;;;;;;-1:-1:-1;;;26580:42:0;;;;;;;;;;;;;;;22640:17:::1;::::0;22669:31:::1;::::0;;-1:-1:-1;;;22669:31:0;;22681:10:::1;22669:31;::::0;::::1;::::0;;;;;;;;;-1:-1:-1;;;;;22640:17:0;;::::1;::::0;;;22669:11:::1;::::0;:31;;;;;::::1;::::0;;;;;;;;22605:17:::1;22640::::0;22669:31;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;;;;22544:164:0:o;13299:63::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;21770:614::-;26713:5;;-1:-1:-1;;;;;26713:5:0;26699:10;:19;;:75;;-1:-1:-1;26723:9:0;;-1:-1:-1;;;;;26723:9:0;:23;;;;:50;;-1:-1:-1;26764:9:0;;-1:-1:-1;;;;;26764:9:0;26750:10;:23;26723:50;26691:98;;;;;-1:-1:-1;;;26691:98:0;;;;;;;;;;;;-1:-1:-1;;;26691:98:0;;;;;;;;;;;;;;;21879:6:::1;21874:503;21895:10;:17;21891:1;:21;21874:503;;;21937:17;21957:10;21968:1;21957:13;;;;;;;;;;;;;;21937:33;;21992:10;21987:324;-1:-1:-1::0;;;;;22016:34:0;::::1;;::::0;;;:23:::1;:34;::::0;;;;;22008:42;::::1;21987:324;;;-1:-1:-1::0;;;;;22083:36:0;::::1;22129:1;22083:36:::0;;;:25:::1;:36;::::0;;;;;;;:43;;;;;;;;:47;;;22149:25;;;:14:::1;:25:::0;;;;;:32;;;;;;;;:36;;;22204:26;;;:15:::1;:26:::0;;;;;:33;;;;;;;;:37;;;22260:24;;;:13:::1;:24:::0;;;;;:31;;;;;;;;:35;22061:1:::1;22052:10;21987:324;;;-1:-1:-1::0;;;;;;22327:34:0::1;22364:1;22327:34:::0;;;:23:::1;:34;::::0;;;;:38;21919:1:::1;21914:6;21874:503;;;;21770:614:::0;:::o;13700:64::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;12795:50::-;12838:7;12795:50;:::o;13875:62::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;19825:136::-;26602:5;;-1:-1:-1;;;;;26602:5:0;26588:10;:19;26580:42;;;;;-1:-1:-1;;;26580:42:0;;;;;;;;;;;;-1:-1:-1;;;26580:42:0;;;;;;;;;;;;;;;19913:17:::1;:40:::0;;-1:-1:-1;;;;;;19913:40:0::1;-1:-1:-1::0;;;;;19913:40:0;;;::::1;::::0;;;::::1;::::0;;19825:136::o;19224:133::-;19331:10;19293:4;19317:25;;;:13;:25;;;;;;;;:32;;;;;;;;;19224:133::o;22855:225::-;22962:5;-1:-1:-1;;;;;22962:11:0;;:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;22962:13:0;-1:-1:-1;;;;;22948:27:0;:10;:27;22940:86;;;;-1:-1:-1;;;22940:86:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23037:5;-1:-1:-1;;;;;23037:33:0;;:35;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22855:225;:::o;18693:336::-;18747:4;;;18802:182;18855:10;18831:35;;;;:23;:35;;;;;;18823:43;;18802:182;;;18953:10;18939:25;;;;:13;:25;;;;;;;;:32;;;;;;;;;18916:56;;:18;;:22;:56::i;:::-;18895:77;-1:-1:-1;18877:1:0;18868:10;18802:182;;;-1:-1:-1;19003:18:0;-1:-1:-1;18693:336:0;:::o;12286:20::-;;;-1:-1:-1;;;;;12286:20:0;;:::o;23807:608::-;-1:-1:-1;;;;;23904:34:0;;23883:4;23904:34;;;:23;:34;;;;;;23900:80;;-1:-1:-1;23967:1:0;23960:8;;23900:80;23992:35;24047:10;24042:316;-1:-1:-1;;;;;24071:34:0;;;;;;:23;:34;;;;;;24063:42;;24042:316;;;24134:40;24177:50;24210:9;24221:5;24177:32;:50::i;:::-;24134:93;-1:-1:-1;24275:71:0;:30;24134:93;24275:34;:71::i;:::-;24242:104;-1:-1:-1;;24116:1:0;24107:10;24042:316;;;-1:-1:-1;24377:30:0;23807:608;-1:-1:-1;;23807:608:0:o;24712:1510::-;-1:-1:-1;;;;;24841:34:0;;24808:4;24841:34;;;:23;:34;;;;;;24833:42;;24825:68;;;;;-1:-1:-1;;;24825:68:0;;;;;;;;;;;;-1:-1:-1;;;24825:68:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;24910:34:0;;;;;;:23;:34;;;;;;24906:80;;-1:-1:-1;24973:1:0;24966:8;;24906:80;-1:-1:-1;;;;;25076:26:0;;24998:27;25076:26;;;:15;:26;;;;;;;;:33;;;;;;;;;25028:36;;;:25;:36;;;;;:43;;;;;;;;;24998:27;;25028:94;;25115:6;;25028:82;;:43;:47;:82::i;:94::-;24998:124;-1:-1:-1;25135:29:0;25167:41;:15;13019:10;25167:19;:41::i;:::-;25135:73;-1:-1:-1;25291:33:0;25327:49;25135:73;12838:7;25327:28;:49::i;:::-;-1:-1:-1;;;;;25473:25:0;;25389:26;25473:25;;;:14;:25;;;;;;;;:32;;;;;;;;;25291:85;;-1:-1:-1;25389:26:0;25434:35;25291:85;25467:1;25434:32;:35::i;:::-;:71;25430:626;;-1:-1:-1;;;;;;25546:26:0;;;;;;:15;:26;;;;;;;;:33;;;;;;;;;25430:626;;;-1:-1:-1;;;;;25710:25:0;;25612:29;25710:25;;;:14;:25;;;;;;;;:32;;;;;;;;;25644:106;;25710:39;;25747:1;25710:36;:39::i;:::-;-1:-1:-1;;;;;25644:26:0;;;;;;:15;:26;;;;;;;;:33;;;;;;;;;:61;;25682:22;25644:37;:61::i;:106::-;25612:138;-1:-1:-1;25789:86:0;25852:22;25789:58;25612:138;25818:28;25789;:58::i;:::-;:62;;:86::i;:::-;-1:-1:-1;;;;;25918:26:0;;;;;;:15;:26;;;;;;;;:33;;;;;;;;;25765:110;;-1:-1:-1;25894:57:0;;25890:155;;;-1:-1:-1;;;;;25996:26:0;;;;;;:15;:26;;;;;;;;:33;;;;;;;;;;-1:-1:-1;25890:155:0;25430:626;;-1:-1:-1;;;;;26132:24:0;;26068:35;26132:24;;;:13;:24;;;;;;;;:31;;;;;;;;;26106:58;;:21;;:25;:58::i;:::-;26068:96;-1:-1:-1;;;;;;24712:1510:0;;;;;:::o;6490:181::-;6548:7;6580:5;;;6604:6;;;;6596:46;;;;;-1:-1:-1;;;6596:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;6662:1;6490:181;-1:-1:-1;;;6490:181:0:o;8244:471::-;8302:7;8547:6;8543:47;;-1:-1:-1;8577:1:0;8570:8;;8543:47;8614:5;;;8618:1;8614;:5;:1;8638:5;;;;;:10;8630:56;;;;-1:-1:-1;;;8630:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9902:132;9960:7;9987:39;9991:1;9994;9987:39;;;;;;;;;;;;;;;;;:3;:39::i;7383:137::-;7441:7;7468:44;7472:1;7475;7468:44;;;;;;;;;;;;;;;;;:3;:44::i;10522:345::-;10608:7;10710:12;10703:5;10695:28;;;;-1:-1:-1;;;10695:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10734:9;10750:1;10746;:5;;;;;;;10522:345;-1:-1:-1;;;;;10522:345:0:o;7809:192::-;7895:7;7931:12;7923:6;;;;7915:29;;;;-1:-1:-1;;;7915:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;7967:5:0;;;7809:192::o

Swarm Source

ipfs://0d71d069714b2636444c4ad6407ae0046e3a5bf952d21591fe01c6cca7d5ec70
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.