Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

pragma solidity 0.8.20;

import {Ownable} from "@openzeppelin/access/Ownable.sol";
import {ReentrancyGuard} from "@openzeppelin/utils/ReentrancyGuard.sol";
import {IERC20} from "@openzeppelin/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/token/ERC20/utils/SafeERC20.sol";
import {MerkleProof} from "@openzeppelin/utils/cryptography/MerkleProof.sol";

import {IDistributor} from "./IDistributor.sol";
import {IWeth} from "./IWeth.sol";

contract Distributor is IDistributor, Ownable, ReentrancyGuard {
    using SafeERC20 for IERC20;

    /// @inheritdoc IDistributor
    address public immutable wNative;

    /// @inheritdoc IDistributor
    bytes32 public root;

    /// @notice Mapping of whether a user has claimed their rewards
    mapping(
        address user
            => mapping(
                address pool
                    => mapping(address token => mapping(bytes identifier => uint256 amount))
            )
    ) public claimed;

    /// @inheritdoc IDistributor
    address public merkleUpdater;

    /// @notice Whether the contract is paused or not
    bool public paused;

    /// @param _owner The owner of the contract
    /// @param _updater Address that can update the merkle root of the contract
    /// @param _wNative The address of the wrapped native token for the deployed chain
    constructor(address _owner, address _updater, address _wNative) Ownable(_owner) {
        if (_updater == address(0)) revert InvalidMerkleUpdater();

        merkleUpdater = _updater;
        wNative = _wNative;
    }

    /// @inheritdoc IDistributor
    function harvest(
        address user,
        address pool,
        address token,
        uint256 amount,
        bytes calldata identifier,
        bytes32[] calldata proof
    ) external nonReentrant {
        _requireNotPaused();
        _harvest(user, pool, token, amount, identifier, proof);
    }

    /// @inheritdoc IDistributor
    function multiHarvest(
        address user,
        address[] calldata pools,
        address[] calldata tokens,
        uint256[] calldata amounts,
        bytes[] calldata identifiers,
        bytes32[][] calldata proofs
    ) external nonReentrant {
        _requireNotPaused();

        if (
            tokens.length == 0 || tokens.length != pools.length || tokens.length != amounts.length
                || tokens.length != identifiers.length || tokens.length != proofs.length
        ) revert InvalidLengths();

        for (uint256 i; i < tokens.length;) {
            _harvest(user, pools[i], tokens[i], amounts[i], identifiers[i], proofs[i]);

            unchecked {
                i++;
            }
        }
    }

    /// @inheritdoc IDistributor
    function isHarvested(
        address user,
        address pool,
        address token,
        uint256 amount,
        bytes calldata identifier
    ) public view returns (bool) {
        return claimed[user][pool][token][identifier] >= amount;
    }

    // @inheritdoc IDistributor
    function getUnclaimedAmount(
        address user,
        address pool,
        address token,
        uint256 amount,
        bytes calldata identifier
    ) public view returns (uint256) {
        uint256 claimedAmount = claimed[user][pool][token][identifier];
        return amount < claimedAmount ? 0 : amount - claimedAmount;
    }

    /// @inheritdoc IDistributor
    function updateRoot(bytes32 newRoot) external {
        _requireOnlyMerkleUpdater();

        root = newRoot;

        emit RootUpdated(newRoot);
    }

    /// @inheritdoc IDistributor
    function recoverERC20(address to, address token, uint256 amount) external {
        _requireOnlyOwner();

        IERC20(token).safeTransfer(to, amount);
        emit RecoveredERC20(to, token, amount);
    }

    /// @inheritdoc IDistributor
    function pause() external {
        _requireOnlyOwner();

        paused = true;

        emit DistributorPaused();
    }

    /// @inheritdoc IDistributor
    function unpause() external {
        _requireOnlyOwner();

        paused = false;

        emit DistributorUnpaused();
    }

    /// @inheritdoc IDistributor
    function updateMerkleUpdater(address updater) external {
        _requireOnlyOwner();

        if (updater == address(0)) revert InvalidMerkleUpdater();

        address old = merkleUpdater;
        merkleUpdater = updater;

        emit MerkleUpdaterChanged(old, merkleUpdater);
    }

    receive() external payable {}

    /// @dev Checks if contract is paused
    function _requireNotPaused() internal view {
        if (paused) revert ContractIsPaused();
    }

    /// @dev Checks if caller has operator rights
    function _requireOnlyOwner() internal view {
        if (msg.sender != owner()) revert Unauthorized();
    }

    /// @dev Checks if caller has updater rights
    function _requireOnlyMerkleUpdater() internal view {
        if (msg.sender != merkleUpdater) revert Unauthorized();
    }

    /// @dev Internal function to handle harvest of rewards
    function _harvest(
        address user,
        address pool,
        address token,
        uint256 amount,
        bytes calldata identifier,
        bytes32[] calldata proof
    ) internal {
        bytes32 leaf = keccak256(abi.encode(user, pool, token, amount, identifier));
        if (!MerkleProof.verify(proof, root, leaf)) revert InvalidProof();

        uint256 toSend = getUnclaimedAmount(user, pool, token, amount, identifier);
        if (toSend == 0) revert AlreadyClaimed();

        claimed[user][pool][token][identifier] = amount;

        if (token == wNative) {
            _unwrap(amount);
            (bool ok,) = user.call{value: amount}("");

            if (!ok) revert FailedToSendNative();
        } else {
            IERC20(token).safeTransfer(user, toSend);
        }

        emit Claimed(user, pool, token, toSend, amount, identifier);
    }

    /// @dev Internal function to withdraw wrapped native into native
    function _unwrap(uint256 _amount) internal {
        IWeth(wNative).withdraw(_amount);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;

import {Context} from "../utils/Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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 value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens 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 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` 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 value) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";
import {IERC20Permit} from "../extensions/IERC20Permit.sol";
import {Address} from "../../../utils/Address.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    /**
     * @dev An operation with an ERC20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @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://consensys.net/diligence/blog/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.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @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 or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * 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.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @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`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // 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 FailedInnerCall();
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @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 Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.20;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The tree and the proofs can be generated using our
 * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
 * You will find a quickstart guide in the readme.
 *
 * 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.
 * OpenZeppelin's JavaScript library generates Merkle trees that are safe
 * against this attack out of the box.
 */
library MerkleProof {
    /**
     *@dev The multiproof provided is not valid.
     */
    error MerkleProofInvalidMultiproof();

    /**
     * @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 Calldata version of {verify}
     */
    function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProofCalldata(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.
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Calldata version of {processProof}
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a Merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the Merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proofLen != totalHashes + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            if (proofPos != proofLen) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the Merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proofLen != totalHashes + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            if (proofPos != proofLen) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Sorts the pair (a, b) and hashes the result.
     */
    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    /**
     * @dev Implementation of keccak256(abi.encode(a, b)) that doesn't allocate or expand memory.
     */
    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)

pragma solidity ^0.8.20;

/**
 * @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].
 */
abstract 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;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _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 making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

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

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

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.20;

interface IDistributor {
    /// @dev The given leaf has already been claimed
    error AlreadyClaimed();

    /// @dev Contract is paused for claiming rewards
    error ContractIsPaused();

    /// @dev Failed to send native token
    error FailedToSendNative();

    /// @dev Array lengths do not match
    error InvalidLengths();

    /// @dev MerkleUpdater cannot be the zero address
    error InvalidMerkleUpdater();

    /// @dev Provided proof is invalid
    error InvalidProof();

    /// @dev msg.sender is not authorized to call this function
    error Unauthorized();

    /// @dev Emitted when pending rewards are claimed
    /// @param user Address of the user who earned the rewards
    /// @param pool Address of the pool that earned the user the rewards
    /// @param token Address of the token that was claimed
    /// @param amount Amount of token claimed
    /// @param accAmount Total accumulated claimed amount
    /// @param identifier Identifier of the incentives (ie: positionId, gamma pool address, etc)
    event Claimed(
        address indexed user,
        address indexed pool,
        address indexed token,
        uint256 amount,
        uint256 accAmount,
        bytes identifier
    );

    /// @dev Emitted when the distributor contract is paused
    event DistributorPaused();

    /// @dev Emitted when the merkle updater is modified
    /// @param old Address of the previous merkle updater
    /// @param merkleUpdater Address of the new merkle updater
    event MerkleUpdaterChanged(address old, address merkleUpdater);

    /// @dev Emitted when an authorized user recovers an ERC20 token
    /// @param to Address to send the tokens to
    /// @param token Address of the token to recover
    /// @param amount Amount of token to recover
    event RecoveredERC20(address indexed to, address indexed token, uint256 amount);

    /// @dev Emitted when the merkle root is updated
    /// @param root The new root
    event RootUpdated(bytes32 root);

    /// @dev Emitted when the distributor contract is unpaused
    event DistributorUnpaused();

    /// @notice The root for the current epoch
    function root() external view returns (bytes32);

    /// @notice Returns the address capable of updating merkle root
    function merkleUpdater() external view returns (address);

    /// @notice Returns the address of the wrapped version of the native token
    function wNative() external view returns (address);

    /// @notice Checks whether a given leaf has already been claimed
    /// @param user Address of the account to check rewards for
    /// @param pool Address of the pool that earned the rewards
    /// @param token Address of the token earned as rewards
    /// @param amount Total cumulative amount of rewards earned
    /// @param identifier Identifier of how rewards were earned
    function isHarvested(
        address user,
        address pool,
        address token,
        uint256 amount,
        bytes calldata identifier
    ) external returns (bool);

    /// @notice Claims rewards accrued by the user as incentives
    /// @param user Address of the user who earned the rewards
    /// @param pool Address of the pool that earned the rewards
    /// @param token Address of the token to be claimed
    /// @param amount Total cumulative amount of rewards earned
    /// @param proof Merkle proof to verify user can claim rewards
    /// @param identifier Identifier of the incentives (ie: positionId, gamma pool address, etc)
    function harvest(
        address user,
        address pool,
        address token,
        uint256 amount,
        bytes calldata identifier,
        bytes32[] calldata proof
    ) external;

    /// @notice Claims multiple rewards accrued by the user as incentives
    /// @param user Address of the user who earned the rewards
    /// @param pools List of addresses of the pools that earned the rewards
    /// @param tokens List of addresses of tokens to be claimed
    /// @param amounts List of total cumulative amount of rewards earned
    /// @param identifiers List of identifiers of incentives earned
    /// @param proofs List of Merkle proofs to verify user can claim rewards
    function multiHarvest(
        address user,
        address[] calldata pools,
        address[] calldata tokens,
        uint256[] calldata amounts,
        bytes[] calldata identifiers,
        bytes32[][] calldata proofs
    ) external;

    /// @notice Updates the Merkle root
    /// @dev Only callable by the owner
    /// @param newRoot The new Merkle root
    function updateRoot(bytes32 newRoot) external;

    /// @notice Recovers ERC20 tokens accidentally sent to the contract
    /// @dev Only callable by the owner
    /// @param to Address receiving the ERC20 tokens
    /// @param token Address of the token to transfer
    /// @param amount Amount of tokens to transfer
    function recoverERC20(address to, address token, uint256 amount) external;

    /// @notice Pauses the protocol.
    /// @dev Only callable by the owner
    function pause() external;

    /// @notice Unpauses the protocol.
    /// @dev Only callable by the owner
    function unpause() external;

    /// @notice Updates the merkle updater
    /// @dev Only callable by the owner
    function updateMerkleUpdater(address updater) external;
}

// SPDX-License-Identifier: MIT

pragma solidity 0.8.20;

interface IWeth {
    /// @notice Unwraps ERC20 token into native token
    /// @param amount Amount to withdraw
    function withdraw(uint256 amount) external;

    /// @notice Wraps native token into ERC20 token
    function deposit() external payable;
}

{
  "optimizer": {
    "enabled": true,
    "runs": 2000
  },
  "evmVersion": "paris",
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "metadata": {
    "useLiteralContent": true
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_updater","type":"address"},{"internalType":"address","name":"_wNative","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"AlreadyClaimed","type":"error"},{"inputs":[],"name":"ContractIsPaused","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[],"name":"FailedToSendNative","type":"error"},{"inputs":[],"name":"InvalidLengths","type":"error"},{"inputs":[],"name":"InvalidMerkleUpdater","type":"error"},{"inputs":[],"name":"InvalidProof","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"pool","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"accAmount","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"identifier","type":"bytes"}],"name":"Claimed","type":"event"},{"anonymous":false,"inputs":[],"name":"DistributorPaused","type":"event"},{"anonymous":false,"inputs":[],"name":"DistributorUnpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"old","type":"address"},{"indexed":false,"internalType":"address","name":"merkleUpdater","type":"address"}],"name":"MerkleUpdaterChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RecoveredERC20","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"root","type":"bytes32"}],"name":"RootUpdated","type":"event"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"address","name":"pool","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"bytes","name":"identifier","type":"bytes"}],"name":"claimed","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"address","name":"pool","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"identifier","type":"bytes"}],"name":"getUnclaimedAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"address","name":"pool","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"identifier","type":"bytes"},{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"name":"harvest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"address","name":"pool","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"identifier","type":"bytes"}],"name":"isHarvested","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleUpdater","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"address[]","name":"pools","type":"address[]"},{"internalType":"address[]","name":"tokens","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"bytes[]","name":"identifiers","type":"bytes[]"},{"internalType":"bytes32[][]","name":"proofs","type":"bytes32[][]"}],"name":"multiHarvest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"recoverERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"root","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"updater","type":"address"}],"name":"updateMerkleUpdater","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"newRoot","type":"bytes32"}],"name":"updateRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"wNative","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

00000000000000000000000001bb7b44cc398aaa2b76ac6253f0f5634279db9d000000000000000000000000f6c5d78053529b65c956ab66bdf11fc96aaf4bbb00000000000000000000000048b62137edfa95a428d35c09e44256a739f6b557

-----Decoded View---------------
Arg [0] : _owner (address): 0x01Bb7B44cc398AaA2b76Ac6253F0F5634279Db9D
Arg [1] : _updater (address): 0xF6C5d78053529b65c956AB66bdF11FC96aAF4Bbb
Arg [2] : _wNative (address): 0x48b62137EdfA95a428D35C09E44256a739F6B557

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 00000000000000000000000001bb7b44cc398aaa2b76ac6253f0f5634279db9d
Arg [1] : 000000000000000000000000f6c5d78053529b65c956ab66bdf11fc96aaf4bbb
Arg [2] : 00000000000000000000000048b62137edfa95a428d35c09e44256a739f6b557