Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-07-11
*/

// SPDX-License-Identifier: MIT

/*
 * @title OGV Mandatory Lockup Merkle Distributor
 * @author Origin Protocol Labs
 *
 * Origin Protocol
 * https://originprotocol.com
 * https://ousd.com
 *
 * Released under the MIT license
 * https://github.com/OriginProtocol/origin-dollar
 * https://github.com/OriginProtocol/ousd-governance
 *
 * Copyright 2022 Origin Protocol Labs
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

pragma solidity ^0.8.4;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20Upgradeable {
    /**
     * @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);

    /**
     * @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 `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 `from` to `to` 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 from,
        address to,
        uint256 amount
    ) external returns (bool);
}
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)





/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20MetadataUpgradeable is IERC20Upgradeable {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)


// OpenZeppelin Contracts (last updated v4.6.0) (proxy/utils/Initializable.sol)



// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)



/**
 * @dev Collection of functions related to the address type
 */
library AddressUpgradeable {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly
                /// @solidity memory-safe-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
 * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
 * case an upgrade adds a module that needs to be initialized.
 *
 * For example:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * contract MyToken is ERC20Upgradeable {
 *     function initialize() initializer public {
 *         __ERC20_init("MyToken", "MTK");
 *     }
 * }
 * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
 *     function initializeV2() reinitializer(2) public {
 *         __ERC20Permit_init("MyToken");
 *     }
 * }
 * ```
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
 * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() {
 *     _disableInitializers();
 * }
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     * @custom:oz-retyped-from bool
     */
    uint8 private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Triggered when the contract has been initialized or reinitialized.
     */
    event Initialized(uint8 version);

    /**
     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
     * `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`.
     */
    modifier initializer() {
        bool isTopLevelCall = !_initializing;
        require(
            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
            "Initializable: contract is already initialized"
        );
        _initialized = 1;
        if (isTopLevelCall) {
            _initializing = true;
        }
        _;
        if (isTopLevelCall) {
            _initializing = false;
            emit Initialized(1);
        }
    }

    /**
     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
     * used to initialize parent contracts.
     *
     * `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original
     * initialization step. This is essential to configure modules that are added through upgrades and that require
     * initialization.
     *
     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
     * a contract, executing them in the right order is up to the developer or operator.
     */
    modifier reinitializer(uint8 version) {
        require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
        _initialized = version;
        _initializing = true;
        _;
        _initializing = false;
        emit Initialized(version);
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} and {reinitializer} modifiers, directly or indirectly.
     */
    modifier onlyInitializing() {
        require(_initializing, "Initializable: contract is not initializing");
        _;
    }

    /**
     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
     * through proxies.
     */
    function _disableInitializers() internal virtual {
        require(!_initializing, "Initializable: contract is initializing");
        if (_initialized < type(uint8).max) {
            _initialized = type(uint8).max;
            emit Initialized(type(uint8).max);
        }
    }
}

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract ContextUpgradeable is Initializable {
    function __Context_init() internal onlyInitializing {
    }

    function __Context_init_unchained() internal onlyInitializing {
    }
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}


/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {
        __ERC20_init_unchained(name_, symbol_);
    }

    function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
        }
        _balances[to] += amount;

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[45] private __gap;
}



/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20BurnableUpgradeable is Initializable, ContextUpgradeable, ERC20Upgradeable {
    function __ERC20Burnable_init() internal onlyInitializing {
    }

    function __ERC20Burnable_init_unchained() internal onlyInitializing {
    }
    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        _spendAllowance(account, _msgSender(), amount);
        _burn(account, amount);
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}
// OpenZeppelin Contracts (last updated v4.5.0) (utils/cryptography/MerkleProof.sol)



/**
 * @dev These functions deal with verification of Merkle Trees proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the merkle tree could be reinterpreted as a leaf value.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * _Available since v4.4._
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            bytes32 proofElement = proof[i];
            if (computedHash <= proofElement) {
                // Hash(current computed hash + current element of the proof)
                computedHash = _efficientHash(computedHash, proofElement);
            } else {
                // Hash(current element of the proof + current computed hash)
                computedHash = _efficientHash(proofElement, computedHash);
            }
        }
        return computedHash;
    }

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)



/**
 * @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 `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 `from` to `to` 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 from,
        address to,
        uint256 amount
    ) external returns (bool);

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

abstract contract AbstractLockupDistributor {
    //@notice This event is triggered whenever a call to #claim succeeds.
    event Claimed(uint256 indexed index, address indexed account, uint256 amount);

    event OGVBurned(uint256 amount);

    address public immutable token;
    bytes32 public immutable merkleRoot;
    address public immutable stakingContract;
    uint256 public immutable endBlock;

    // This is a packed array of booleans.
    mapping(uint256 => uint256) private claimedBitMap;

    constructor(
        address _token,
        bytes32 _merkleRoot,
        address _stakingContract,
        uint256 _endBlock
    ) {
        token = _token;
        merkleRoot = _merkleRoot;
        stakingContract = _stakingContract;
        endBlock = _endBlock;
    }

    /**
     * @dev
     * @param _index Index in the tree
     */
    function isClaimed(uint256 _index) public view returns (bool) {
        uint256 claimedWordIndex = _index / 256;
        uint256 claimedBitIndex = _index % 256;
        uint256 claimedWord = claimedBitMap[claimedWordIndex];
        uint256 mask = (1 << claimedBitIndex);
        return claimedWord & mask == mask;
    }

    /**
     * @dev
     * @param _index Index in the tree
     */
    function setClaimed(uint256 _index) internal {
        uint256 claimedWordIndex = _index / 256;
        uint256 claimedBitIndex = _index % 256;
        claimedBitMap[claimedWordIndex] =
            claimedBitMap[claimedWordIndex] |
            (1 << claimedBitIndex);
    }

    function isProofValid(
        uint256 _index,
        uint256 _amount,
        address _account,
        bytes32[] calldata _merkleProof
    ) external view returns (bool) {
        // Verify the Merkle proof.
        bytes32 node = keccak256(abi.encodePacked(_index, _account, _amount));
        return MerkleProof.verify(_merkleProof, merkleRoot, node);
    }

    /**
     * @dev burn all the remaining OGV balance
     */
    function burnRemainingOGV() external {
    	require(block.number >= endBlock, "Can not yet burn the remaining OGV");
    	uint256 burnAmount = IERC20(token).balanceOf(address(this));

    	ERC20BurnableUpgradeable(token).burn(burnAmount);
    	emit OGVBurned(burnAmount);

    }
}

interface IOGVStaking {
    function stake(
        uint256 amount,
        uint256 end,
        address to
    ) external;
}

contract MandatoryLockupDistributor is AbstractLockupDistributor {

    constructor(
        address _token,
        bytes32 _merkleRoot,
        address _stakingContract,
        uint256 _endBlock
    ) AbstractLockupDistributor(_token, _merkleRoot, _stakingContract, _endBlock) {}

    /**
     * @dev Execute a claim using a merkle proof with optional lockup in the staking contract.
     * @param _index Index in the tree
     * @param _amount Amount eligible to claim
     * @param _merkleProof The proof
     */
    function claim(
        uint256 _index,
        uint256 _amount,
        bytes32[] calldata _merkleProof
    ) external {
        require(!isClaimed(_index), "MerkleDistributor: Drop already claimed.");
        require(block.number < endBlock, "Can no longer claim. Claim period expired");

        // Verify the merkle proof.
        bytes32 node = keccak256(abi.encodePacked(_index, msg.sender, _amount));
        require(
            MerkleProof.verify(_merkleProof, merkleRoot, node),
            "MerkleDistributor: Invalid proof."
        );

        // Mark it claimed and send the token.
        setClaimed(_index);

        IERC20(token).approve(stakingContract, _amount);

        // Create four lockups in 12 month increments (1 month = 2629800 seconds)
        IOGVStaking(stakingContract).stake(_amount / 4, 2629800 * 12, msg.sender);
        IOGVStaking(stakingContract).stake(_amount / 4, 2629800 * 24, msg.sender);
        IOGVStaking(stakingContract).stake(_amount / 4, 2629800 * 36, msg.sender);
        IOGVStaking(stakingContract).stake(_amount / 4, 2629800 * 48, msg.sender);

        emit Claimed(_index, msg.sender, _amount);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"},{"internalType":"address","name":"_stakingContract","type":"address"},{"internalType":"uint256","name":"_endBlock","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"index","type":"uint256"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Claimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"OGVBurned","type":"event"},{"inputs":[],"name":"burnRemainingOGV","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_index","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"bytes32[]","name":"_merkleProof","type":"bytes32[]"}],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"endBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_index","type":"uint256"}],"name":"isClaimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_index","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"address","name":"_account","type":"address"},{"internalType":"bytes32[]","name":"_merkleProof","type":"bytes32[]"}],"name":"isProofValid","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakingContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

61010060405234801561001157600080fd5b50604051610de7380380610de78339810160408190526100309161006e565b6001600160a01b0393841660805260a09290925290911660c05260e0526100b2565b80516001600160a01b038116811461006957600080fd5b919050565b6000806000806080858703121561008457600080fd5b61008d85610052565b9350602085015192506100a260408601610052565b6060959095015193969295505050565b60805160a05160c05160e051610caa61013d600039600081816092015281816101a90152610415015260008181610146015281816105b40152818161065b015281816106ee0152818161078b015261082801526000818160cc0152818161051301526109890152600081816101850152818161023f015281816102cb01526105e30152610caa6000f3fe608060405234801561001057600080fd5b50600436106100885760003560e01c8063ae0b51df1161005b578063ae0b51df1461011b578063cb26baeb1461012e578063ee99205c14610141578063fc0c546a1461018057600080fd5b8063083c63231461008d5780632eb4a7ab146100c75780638f6f6966146100ee5780639e34070f146100f8575b600080fd5b6100b47f000000000000000000000000000000000000000000000000000000000000000081565b6040519081526020015b60405180910390f35b6100b47f000000000000000000000000000000000000000000000000000000000000000081565b6100f66101a7565b005b61010b610106366004610a87565b61036b565b60405190151581526020016100be565b6100f6610129366004610aec565b6103ac565b61010b61013c366004610b3f565b610901565b6101687f000000000000000000000000000000000000000000000000000000000000000081565b6040516001600160a01b0390911681526020016100be565b6101687f000000000000000000000000000000000000000000000000000000000000000081565b7f00000000000000000000000000000000000000000000000000000000000000004310156102275760405162461bcd60e51b815260206004820152602260248201527f43616e206e6f7420796574206275726e207468652072656d61696e696e67204f60448201526123ab60f11b60648201526084015b60405180910390fd5b6040516370a0823160e01b81523060048201526000907f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316906370a0823190602401602060405180830381865afa15801561028e573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906102b29190610bb5565b604051630852cd8d60e31b8152600481018290529091507f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316906342966c6890602401600060405180830381600087803b15801561031757600080fd5b505af115801561032b573d6000803e3d6000fd5b505050507f6c503bd76738aacb466b50f0e1e1a98baeb5c216e2f170a86c048cea6bbb16148160405161036091815260200190565b60405180910390a150565b60008061037a61010084610be4565b9050600061038a61010085610bf8565b60009283526020839052604090922054600190921b9182169091149392505050565b6103b58461036b565b156104135760405162461bcd60e51b815260206004820152602860248201527f4d65726b6c654469737472696275746f723a2044726f7020616c72656164792060448201526731b630b4b6b2b21760c11b606482015260840161021e565b7f000000000000000000000000000000000000000000000000000000000000000043106104945760405162461bcd60e51b815260206004820152602960248201527f43616e206e6f206c6f6e67657220636c61696d2e20436c61696d20706572696f6044820152681908195e1c1a5c995960ba1b606482015260840161021e565b60408051602081018690526bffffffffffffffffffffffff193360601b16918101919091526054810184905260009060740160405160208183030381529060405280519060200120905061053e8383808060200260200160405190810160405280939291908181526020018383602002808284376000920191909152507f000000000000000000000000000000000000000000000000000000000000000092508591506109bf9050565b6105945760405162461bcd60e51b815260206004820152602160248201527f4d65726b6c654469737472696275746f723a20496e76616c69642070726f6f666044820152601760f91b606482015260840161021e565b61059d856109d5565b60405163095ea7b360e01b81526001600160a01b037f000000000000000000000000000000000000000000000000000000000000000081166004830152602482018690527f0000000000000000000000000000000000000000000000000000000000000000169063095ea7b3906044016020604051808303816000875af115801561062c573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906106509190610c0c565b506001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016637628a37d61068b600487610be4565b6040516001600160e01b031960e084901b16815260048101919091526301e187e06024820152336044820152606401600060405180830381600087803b1580156106d457600080fd5b505af11580156106e8573d6000803e3d6000fd5b505050507f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316637628a37d6004866107289190610be4565b6040516001600160e01b031960e084901b16815260048101919091526303c30fc06024820152336044820152606401600060405180830381600087803b15801561077157600080fd5b505af1158015610785573d6000803e3d6000fd5b505050507f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316637628a37d6004866107c59190610be4565b6040516001600160e01b031960e084901b16815260048101919091526305a497a06024820152336044820152606401600060405180830381600087803b15801561080e57600080fd5b505af1158015610822573d6000803e3d6000fd5b505050507f00000000000000000000000000000000000000000000000000000000000000006001600160a01b0316637628a37d6004866108629190610be4565b6040516001600160e01b031960e084901b16815260048101919091526307861f806024820152336044820152606401600060405180830381600087803b1580156108ab57600080fd5b505af11580156108bf573d6000803e3d6000fd5b50506040518681523392508791507f4ec90e965519d92681267467f775ada5bd214aa92c0dc93d90a5e880ce9ed0269060200160405180910390a35050505050565b60008086858760405160200161093c9392919092835260609190911b6bffffffffffffffffffffffff19166020830152603482015260540190565b6040516020818303038152906040528051906020012090506109b48484808060200260200160405190810160405280939291908181526020018383602002808284376000920191909152507f000000000000000000000000000000000000000000000000000000000000000092508591506109bf9050565b979650505050505050565b6000826109cc8584610a13565b14949350505050565b60006109e361010083610be4565b905060006109f361010084610bf8565b6000928352602083905260409092208054600190931b9092179091555050565b600081815b8451811015610a7f576000858281518110610a3557610a35610c35565b60200260200101519050808311610a5b5760008381526020829052604090209250610a6c565b600081815260208490526040902092505b5080610a7781610c4b565b915050610a18565b509392505050565b600060208284031215610a9957600080fd5b5035919050565b60008083601f840112610ab257600080fd5b50813567ffffffffffffffff811115610aca57600080fd5b6020830191508360208260051b8501011115610ae557600080fd5b9250929050565b60008060008060608587031215610b0257600080fd5b8435935060208501359250604085013567ffffffffffffffff811115610b2757600080fd5b610b3387828801610aa0565b95989497509550505050565b600080600080600060808688031215610b5757600080fd5b853594506020860135935060408601356001600160a01b0381168114610b7c57600080fd5b9250606086013567ffffffffffffffff811115610b9857600080fd5b610ba488828901610aa0565b969995985093965092949392505050565b600060208284031215610bc757600080fd5b5051919050565b634e487b7160e01b600052601260045260246000fd5b600082610bf357610bf3610bce565b500490565b600082610c0757610c07610bce565b500690565b600060208284031215610c1e57600080fd5b81518015158114610c2e57600080fd5b9392505050565b634e487b7160e01b600052603260045260246000fd5b6000600019821415610c6d57634e487b7160e01b600052601160045260246000fd5b506001019056fea2646970667358221220792d401af2638c988853edecad9f22f20049acb8f55f51d67713caac737911b664736f6c634300080b00330000000000000000000000009c354503c38481a7a7a51629142963f98ecc12d0986c55fab27288e81c33482ea4f15f9557e3d60eb4e4b11fed1897e8167feda70000000000000000000000000c4576ca1c365868e162554af8e385dc3e7c66d90000000000000000000000000000000000000000000000000000000000efc560

0x608060405234801561001057600080fd5b50600436106100885760003560e01c8063ae0b51df1161005b578063ae0b51df1461011b578063cb26baeb1461012e578063ee99205c14610141578063fc0c546a1461018057600080fd5b8063083c63231461008d5780632eb4a7ab146100c75780638f6f6966146100ee5780639e34070f146100f8575b600080fd5b6100b47f0000000000000000000000000000000000000000000000000000000000efc56081565b6040519081526020015b60405180910390f35b6100b47f986c55fab27288e81c33482ea4f15f9557e3d60eb4e4b11fed1897e8167feda781565b6100f66101a7565b005b61010b610106366004610a87565b61036b565b60405190151581526020016100be565b6100f6610129366004610aec565b6103ac565b61010b61013c366004610b3f565b610901565b6101687f0000000000000000000000000c4576ca1c365868e162554af8e385dc3e7c66d981565b6040516001600160a01b0390911681526020016100be565b6101687f0000000000000000000000009c354503c38481a7a7a51629142963f98ecc12d081565b7f0000000000000000000000000000000000000000000000000000000000efc5604310156102275760405162461bcd60e51b815260206004820152602260248201527f43616e206e6f7420796574206275726e207468652072656d61696e696e67204f60448201526123ab60f11b60648201526084015b60405180910390fd5b6040516370a0823160e01b81523060048201526000907f0000000000000000000000009c354503c38481a7a7a51629142963f98ecc12d06001600160a01b0316906370a0823190602401602060405180830381865afa15801561028e573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906102b29190610bb5565b604051630852cd8d60e31b8152600481018290529091507f0000000000000000000000009c354503c38481a7a7a51629142963f98ecc12d06001600160a01b0316906342966c6890602401600060405180830381600087803b15801561031757600080fd5b505af115801561032b573d6000803e3d6000fd5b505050507f6c503bd76738aacb466b50f0e1e1a98baeb5c216e2f170a86c048cea6bbb16148160405161036091815260200190565b60405180910390a150565b60008061037a61010084610be4565b9050600061038a61010085610bf8565b60009283526020839052604090922054600190921b9182169091149392505050565b6103b58461036b565b156104135760405162461bcd60e51b815260206004820152602860248201527f4d65726b6c654469737472696275746f723a2044726f7020616c72656164792060448201526731b630b4b6b2b21760c11b606482015260840161021e565b7f0000000000000000000000000000000000000000000000000000000000efc56043106104945760405162461bcd60e51b815260206004820152602960248201527f43616e206e6f206c6f6e67657220636c61696d2e20436c61696d20706572696f6044820152681908195e1c1a5c995960ba1b606482015260840161021e565b60408051602081018690526bffffffffffffffffffffffff193360601b16918101919091526054810184905260009060740160405160208183030381529060405280519060200120905061053e8383808060200260200160405190810160405280939291908181526020018383602002808284376000920191909152507f986c55fab27288e81c33482ea4f15f9557e3d60eb4e4b11fed1897e8167feda792508591506109bf9050565b6105945760405162461bcd60e51b815260206004820152602160248201527f4d65726b6c654469737472696275746f723a20496e76616c69642070726f6f666044820152601760f91b606482015260840161021e565b61059d856109d5565b60405163095ea7b360e01b81526001600160a01b037f0000000000000000000000000c4576ca1c365868e162554af8e385dc3e7c66d981166004830152602482018690527f0000000000000000000000009c354503c38481a7a7a51629142963f98ecc12d0169063095ea7b3906044016020604051808303816000875af115801561062c573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906106509190610c0c565b506001600160a01b037f0000000000000000000000000c4576ca1c365868e162554af8e385dc3e7c66d916637628a37d61068b600487610be4565b6040516001600160e01b031960e084901b16815260048101919091526301e187e06024820152336044820152606401600060405180830381600087803b1580156106d457600080fd5b505af11580156106e8573d6000803e3d6000fd5b505050507f0000000000000000000000000c4576ca1c365868e162554af8e385dc3e7c66d96001600160a01b0316637628a37d6004866107289190610be4565b6040516001600160e01b031960e084901b16815260048101919091526303c30fc06024820152336044820152606401600060405180830381600087803b15801561077157600080fd5b505af1158015610785573d6000803e3d6000fd5b505050507f0000000000000000000000000c4576ca1c365868e162554af8e385dc3e7c66d96001600160a01b0316637628a37d6004866107c59190610be4565b6040516001600160e01b031960e084901b16815260048101919091526305a497a06024820152336044820152606401600060405180830381600087803b15801561080e57600080fd5b505af1158015610822573d6000803e3d6000fd5b505050507f0000000000000000000000000c4576ca1c365868e162554af8e385dc3e7c66d96001600160a01b0316637628a37d6004866108629190610be4565b6040516001600160e01b031960e084901b16815260048101919091526307861f806024820152336044820152606401600060405180830381600087803b1580156108ab57600080fd5b505af11580156108bf573d6000803e3d6000fd5b50506040518681523392508791507f4ec90e965519d92681267467f775ada5bd214aa92c0dc93d90a5e880ce9ed0269060200160405180910390a35050505050565b60008086858760405160200161093c9392919092835260609190911b6bffffffffffffffffffffffff19166020830152603482015260540190565b6040516020818303038152906040528051906020012090506109b48484808060200260200160405190810160405280939291908181526020018383602002808284376000920191909152507f986c55fab27288e81c33482ea4f15f9557e3d60eb4e4b11fed1897e8167feda792508591506109bf9050565b979650505050505050565b6000826109cc8584610a13565b14949350505050565b60006109e361010083610be4565b905060006109f361010084610bf8565b6000928352602083905260409092208054600190931b9092179091555050565b600081815b8451811015610a7f576000858281518110610a3557610a35610c35565b60200260200101519050808311610a5b5760008381526020829052604090209250610a6c565b600081815260208490526040902092505b5080610a7781610c4b565b915050610a18565b509392505050565b600060208284031215610a9957600080fd5b5035919050565b60008083601f840112610ab257600080fd5b50813567ffffffffffffffff811115610aca57600080fd5b6020830191508360208260051b8501011115610ae557600080fd5b9250929050565b60008060008060608587031215610b0257600080fd5b8435935060208501359250604085013567ffffffffffffffff811115610b2757600080fd5b610b3387828801610aa0565b95989497509550505050565b600080600080600060808688031215610b5757600080fd5b853594506020860135935060408601356001600160a01b0381168114610b7c57600080fd5b9250606086013567ffffffffffffffff811115610b9857600080fd5b610ba488828901610aa0565b969995985093965092949392505050565b600060208284031215610bc757600080fd5b5051919050565b634e487b7160e01b600052601260045260246000fd5b600082610bf357610bf3610bce565b500490565b600082610c0757610c07610bce565b500690565b600060208284031215610c1e57600080fd5b81518015158114610c2e57600080fd5b9392505050565b634e487b7160e01b600052603260045260246000fd5b6000600019821415610c6d57634e487b7160e01b600052601160045260246000fd5b506001019056fea2646970667358221220792d401af2638c988853edecad9f22f20049acb8f55f51d67713caac737911b664736f6c634300080b0033

0000000000000000000000009c354503c38481a7a7a51629142963f98ecc12d0986c55fab27288e81c33482ea4f15f9557e3d60eb4e4b11fed1897e8167feda70000000000000000000000000c4576ca1c365868e162554af8e385dc3e7c66d90000000000000000000000000000000000000000000000000000000000efc560

-----Decoded View---------------
Arg [0] : _token (address): 0x9c354503C38481a7A7a51629142963F98eCC12D0
Arg [1] : _merkleRoot (bytes32): 0x986c55fab27288e81c33482ea4f15f9557e3d60eb4e4b11fed1897e8167feda7
Arg [2] : _stakingContract (address): 0x0C4576Ca1c365868E162554AF8e385dc3e7C66D9
Arg [3] : _endBlock (uint256): 15713632

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000009c354503c38481a7a7a51629142963f98ecc12d0
Arg [1] : 986c55fab27288e81c33482ea4f15f9557e3d60eb4e4b11fed1897e8167feda7
Arg [2] : 0000000000000000000000000c4576ca1c365868e162554af8e385dc3e7c66d9
Arg [3] : 0000000000000000000000000000000000000000000000000000000000efc560

42018:1721:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39951:33;;;;;;;;160:25:1;;;148:2;133:18;39951:33:0;;;;;;;;39862:35;;;;;41591:285;;;:::i;:::-;;40455:325;;;;;;:::i;:::-;;:::i;:::-;;;728:14:1;;721:22;703:41;;691:2;676:18;40455:325:0;563:187:1;42555:1181:0;;;;;;:::i;:::-;;:::i;41146:371::-;;;;;;:::i;:::-;;:::i;39904:40::-;;;;;;;;-1:-1:-1;;;;;2622:32:1;;;2604:51;;2592:2;2577:18;39904:40:0;2458:203:1;39825:30:0;;;;;41591:285;41660:8;41644:12;:24;;41636:71;;;;-1:-1:-1;;;41636:71:0;;2868:2:1;41636:71:0;;;2850:21:1;2907:2;2887:18;;;2880:30;2946:34;2926:18;;;2919:62;-1:-1:-1;;;2997:18:1;;;2990:32;3039:19;;41636:71:0;;;;;;;;;41736:38;;-1:-1:-1;;;41736:38:0;;41768:4;41736:38;;;2604:51:1;41715:18:0;;41743:5;-1:-1:-1;;;;;41736:23:0;;;;2577:18:1;;41736:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;41784:48;;-1:-1:-1;;;41784:48:0;;;;;160:25:1;;;41715:59:0;;-1:-1:-1;41809:5:0;-1:-1:-1;;;;;41784:36:0;;;;133:18:1;;41784:48:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41845:21;41855:10;41845:21;;;;160:25:1;;148:2;133:18;;14:177;41845:21:0;;;;;;;;41628:248;41591:285::o;40455:325::-;40511:4;;40555:12;40564:3;40555:6;:12;:::i;:::-;40528:39;-1:-1:-1;40578:23:0;40604:12;40613:3;40604:6;:12;:::i;:::-;40627:19;40649:31;;;;;;;;;;;;40707:1;:20;;;40746:18;;;:26;;;;40455:325;-1:-1:-1;;;40455:325:0:o;42555:1181::-;42699:17;42709:6;42699:9;:17::i;:::-;42698:18;42690:71;;;;-1:-1:-1;;;42690:71:0;;3834:2:1;42690:71:0;;;3816:21:1;3873:2;3853:18;;;3846:30;3912:34;3892:18;;;3885:62;-1:-1:-1;;;3963:18:1;;;3956:38;4011:19;;42690:71:0;3632:404:1;42690:71:0;42795:8;42780:12;:23;42772:77;;;;-1:-1:-1;;;42772:77:0;;4243:2:1;42772:77:0;;;4225:21:1;4282:2;4262:18;;;4255:30;4321:34;4301:18;;;4294:62;-1:-1:-1;;;4372:18:1;;;4365:39;4421:19;;42772:77:0;4041:405:1;42772:77:0;42924:45;;;;;;4636:19:1;;;-1:-1:-1;;42949:10:0;4693:2:1;4689:15;4685:53;4671:12;;;4664:75;;;;4755:12;;;4748:28;;;42899:12:0;;4792::1;;42924:45:0;;;;;;;;;;;;42914:56;;;;;;42899:71;;43003:50;43022:12;;43003:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;43036:10:0;;-1:-1:-1;43048:4:0;;-1:-1:-1;43003:18:0;;-1:-1:-1;43003:50:0:i;:::-;42981:133;;;;-1:-1:-1;;;42981:133:0;;5017:2:1;42981:133:0;;;4999:21:1;5056:2;5036:18;;;5029:30;5095:34;5075:18;;;5068:62;-1:-1:-1;;;5146:18:1;;;5139:31;5187:19;;42981:133:0;4815:397:1;42981:133:0;43175:18;43186:6;43175:10;:18::i;:::-;43206:47;;-1:-1:-1;;;43206:47:0;;-1:-1:-1;;;;;43228:15:0;5409:32:1;;43206:47:0;;;5391:51:1;5458:18;;;5451:34;;;43213:5:0;43206:21;;;;5364:18:1;;43206:47:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;;43361:15:0;43349:34;;43384:11;43394:1;43384:7;:11;:::i;:::-;43349:73;;-1:-1:-1;;;;;;43349:73:0;;;;;;;;;;5995:25:1;;;;43397:12:0;6036:18:1;;;6029:34;43411:10:0;6079:18:1;;;6072:60;5968:18;;43349:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43445:15;-1:-1:-1;;;;;43433:34:0;;43478:1;43468:7;:11;;;;:::i;:::-;43433:73;;-1:-1:-1;;;;;;43433:73:0;;;;;;;;;;5995:25:1;;;;43481:12:0;6036:18:1;;;6029:34;43495:10:0;6079:18:1;;;6072:60;5968:18;;43433:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43529:15;-1:-1:-1;;;;;43517:34:0;;43562:1;43552:7;:11;;;;:::i;:::-;43517:73;;-1:-1:-1;;;;;;43517:73:0;;;;;;;;;;5995:25:1;;;;43565:12:0;6036:18:1;;;6029:34;43579:10:0;6079:18:1;;;6072:60;5968:18;;43517:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43613:15;-1:-1:-1;;;;;43601:34:0;;43646:1;43636:7;:11;;;;:::i;:::-;43601:73;;-1:-1:-1;;;;;;43601:73:0;;;;;;;;;;5995:25:1;;;;43649:12:0;6036:18:1;;;6029:34;43663:10:0;6079:18:1;;;6072:60;5968:18;;43601:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;43692:36:0;;160:25:1;;;43708:10:0;;-1:-1:-1;43700:6:0;;-1:-1:-1;43692:36:0;;148:2:1;133:18;43692:36:0;;;;;;;42679:1057;42555:1181;;;;:::o;41146:371::-;41318:4;41372:12;41414:6;41422:8;41432:7;41397:43;;;;;;;;;4636:19:1;;;4693:2;4689:15;;;;-1:-1:-1;;4685:53:1;4680:2;4671:12;;4664:75;4764:2;4755:12;;4748:28;4801:2;4792:12;;4451:359;41397:43:0;;;;;;;;;;;;;41387:54;;;;;;41372:69;;41459:50;41478:12;;41459:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;41492:10:0;;-1:-1:-1;41504:4:0;;-1:-1:-1;41459:18:0;;-1:-1:-1;41459:50:0:i;:::-;41452:57;41146:371;-1:-1:-1;;;;;;;41146:371:0:o;35315:190::-;35440:4;35493;35464:25;35477:5;35484:4;35464:12;:25::i;:::-;:33;;35315:190;-1:-1:-1;;;;35315:190:0:o;40859:279::-;40915:24;40942:12;40951:3;40942:6;:12;:::i;:::-;40915:39;-1:-1:-1;40965:23:0;40991:12;41000:3;40991:6;:12;:::i;:::-;41061:13;:31;;;;;;;;;;;;;41109:1;:20;;;41061:69;;;41014:116;;;-1:-1:-1;;40859:279:0:o;35866:675::-;35949:7;35992:4;35949:7;36007:497;36031:5;:12;36027:1;:16;36007:497;;;36065:20;36088:5;36094:1;36088:8;;;;;;;;:::i;:::-;;;;;;;36065:31;;36131:12;36115;:28;36111:382;;36617:13;36667:15;;;36703:4;36696:15;;;36750:4;36734:21;;36243:57;;36111:382;;;36617:13;36667:15;;;36703:4;36696:15;;;36750:4;36734:21;;36420:57;;36111:382;-1:-1:-1;36045:3:0;;;;:::i;:::-;;;;36007:497;;;-1:-1:-1;36521:12:0;35866:675;-1:-1:-1;;;35866:675:0:o;378:180:1:-;437:6;490:2;478:9;469:7;465:23;461:32;458:52;;;506:1;503;496:12;458:52;-1:-1:-1;529:23:1;;378:180;-1:-1:-1;378:180:1:o;755:367::-;818:8;828:6;882:3;875:4;867:6;863:17;859:27;849:55;;900:1;897;890:12;849:55;-1:-1:-1;923:20:1;;966:18;955:30;;952:50;;;998:1;995;988:12;952:50;1035:4;1027:6;1023:17;1011:29;;1095:3;1088:4;1078:6;1075:1;1071:14;1063:6;1059:27;1055:38;1052:47;1049:67;;;1112:1;1109;1102:12;1049:67;755:367;;;;;:::o;1127:573::-;1231:6;1239;1247;1255;1308:2;1296:9;1287:7;1283:23;1279:32;1276:52;;;1324:1;1321;1314:12;1276:52;1360:9;1347:23;1337:33;;1417:2;1406:9;1402:18;1389:32;1379:42;;1472:2;1461:9;1457:18;1444:32;1499:18;1491:6;1488:30;1485:50;;;1531:1;1528;1521:12;1485:50;1570:70;1632:7;1623:6;1612:9;1608:22;1570:70;:::i;:::-;1127:573;;;;-1:-1:-1;1659:8:1;-1:-1:-1;;;;1127:573:1:o;1705:748::-;1818:6;1826;1834;1842;1850;1903:3;1891:9;1882:7;1878:23;1874:33;1871:53;;;1920:1;1917;1910:12;1871:53;1943:23;;;-1:-1:-1;2013:2:1;1998:18;;1985:32;;-1:-1:-1;2067:2:1;2052:18;;2039:32;-1:-1:-1;;;;;2100:31:1;;2090:42;;2080:70;;2146:1;2143;2136:12;2080:70;2169:5;-1:-1:-1;2225:2:1;2210:18;;2197:32;2252:18;2241:30;;2238:50;;;2284:1;2281;2274:12;2238:50;2323:70;2385:7;2376:6;2365:9;2361:22;2323:70;:::i;:::-;1705:748;;;;-1:-1:-1;1705:748:1;;-1:-1:-1;2412:8:1;;2297:96;1705:748;-1:-1:-1;;;1705:748:1:o;3069:184::-;3139:6;3192:2;3180:9;3171:7;3167:23;3163:32;3160:52;;;3208:1;3205;3198:12;3160:52;-1:-1:-1;3231:16:1;;3069:184;-1:-1:-1;3069:184:1:o;3258:127::-;3319:10;3314:3;3310:20;3307:1;3300:31;3350:4;3347:1;3340:15;3374:4;3371:1;3364:15;3390:120;3430:1;3456;3446:35;;3461:18;;:::i;:::-;-1:-1:-1;3495:9:1;;3390:120::o;3515:112::-;3547:1;3573;3563:35;;3578:18;;:::i;:::-;-1:-1:-1;3612:9:1;;3515:112::o;5496:277::-;5563:6;5616:2;5604:9;5595:7;5591:23;5587:32;5584:52;;;5632:1;5629;5622:12;5584:52;5664:9;5658:16;5717:5;5710:13;5703:21;5696:5;5693:32;5683:60;;5739:1;5736;5729:12;5683:60;5762:5;5496:277;-1:-1:-1;;;5496:277:1:o;7239:127::-;7300:10;7295:3;7291:20;7288:1;7281:31;7331:4;7328:1;7321:15;7355:4;7352:1;7345:15;7371:232;7410:3;-1:-1:-1;;7431:17:1;;7428:140;;;7490:10;7485:3;7481:20;7478:1;7471:31;7525:4;7522:1;7515:15;7553:4;7550:1;7543:15;7428:140;-1:-1:-1;7595:1:1;7584:13;;7371:232::o

ipfs://792d401af2638c988853edecad9f22f20049acb8f55f51d67713caac737911b6