Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

import {IERC20} from "./dependencies/openzeppelin-v5.0.1/token/IERC20.sol";
import {SafeERC20} from "./dependencies/openzeppelin-v5.0.1/token/SafeERC20.sol";
import {MerkleProof} from "./dependencies/openzeppelin-v5.0.1/utils/MerkleProof.sol";
import "./dependencies/openzeppelin-v5.0.1/utils/Pausable.sol";
import "./interfaces/IACLManager.sol";
import  "./interfaces/IEthgasRebate.sol";
import {IVotingEscrow} from "./interfaces/IVotingEscrow.sol";
import "./libraries/InputValidator.sol";
import "./dependencies/openzeppelin-v5.0.1/utils/ReentrancyGuard.sol";

contract EthgasRebate is Pausable, IEthgasRebate, ReentrancyGuard {

    using SafeERC20 for IERC20;

    IACLManager public aclManager;
    IWETH public immutable weth;
    IERC20 public immutable ethgasToken;
    IVotingEscrow public immutable veToken;

    struct MerkleRootInfo {
        bool isStake;
        uint248 minUnlockDuration;
    }
    // category --> MerkleRootInfo
    mapping(bytes32 => MerkleRootInfo) public merkleRootInfo;
    // category --> merkleRoot
    mapping(bytes32 => bytes32) public merkleRoot;
    bool public isRestrictedMode;
    
    // user address --> category --> merkleRoot --> isClaimed
    mapping(address => mapping(bytes32 => mapping(bytes32 => bool))) public rewardClaimed;
    mapping(address => uint256) public dailyWithdrawalCap;
	mapping(address => uint256) public currentDailyWithdrawalAmount;
	mapping(address => uint256) public lastWithdrawalTime;
    mapping(address => bool) public depositWhitelist;
    
    constructor(IACLManager _aclManager, address[] memory _token, uint256[] memory _cap, IWETH _weth, IERC20 _ethgasToken, IVotingEscrow _veToken) {
        InputValidator.validateAddr(address(_aclManager));
        if (_token.length != _cap.length) {
            revert InvalidArrayLength();
        }
        aclManager = _aclManager;
        uint256 length = _token.length;
        weth = _weth;
        ethgasToken = _ethgasToken;
        veToken = _veToken;
        for (uint256 i = 0; i < length; i++) {
            InputValidator.validateAddr(_token[i]);
            dailyWithdrawalCap[_token[i]] = _cap[i];
            emit DailyWithdrawalCapChanged(_token[i], _cap[i]);
        }
    }

    modifier onlyPauserRole() {
		aclManager.checkPauserRole(msg.sender);
		_;
	}

    modifier onlyAdminRole() {
		aclManager.checkAdminRole(msg.sender);
		_;
	}

    modifier onlyTimelockRole() {
		aclManager.checkTimelockRole(msg.sender);
		_;
	}

    modifier onlyBookKeeperRole() {
		aclManager.checkBookKeeperRole(msg.sender);
		_;
	}

    modifier onlyDepositor() {
		if (depositWhitelist[msg.sender] == false) {
            revert DepositNotAllowed();
        }
		_;
	}
    
    function pause() external onlyPauserRole {
        _pause();
    }

    function unpause() external onlyAdminRole {
        _unpause();
    }
    

    function setAclManager(IACLManager _aclManager) external onlyTimelockRole whenNotPaused {
		InputValidator.validateAddr(address(_aclManager));
        aclManager = _aclManager;
        emit AclManagerChanged(address(_aclManager));
	}



    function setDailyWithdrawalCap(address _token, uint256 _cap) external onlyAdminRole whenNotPaused {
        InputValidator.validateAddr(_token);
		dailyWithdrawalCap[_token] = _cap;
		emit DailyWithdrawalCapChanged(_token, _cap);
	}

    function startRestrictedMode() external onlyBookKeeperRole whenNotPaused {
        isRestrictedMode = true;
        emit RestrictedModeUpdated(true);
    }

    function endRestrictedMode() external onlyBookKeeperRole whenNotPaused {
        isRestrictedMode = false;
        emit RestrictedModeUpdated(false);
    }

    function setDepositorWhitelist(address[] calldata _depositorAddr, bool[] calldata _status) external onlyBookKeeperRole whenNotPaused {
        if (_depositorAddr.length != _status.length) {
            revert InvalidArrayLength();
        }
        for (uint i; i < _depositorAddr.length; i++) {
            InputValidator.validateAddr(_depositorAddr[i]);
            depositWhitelist[_depositorAddr[i]] = _status[i];
            emit DepositWhitelistStatusChanged(_depositorAddr[i], _status[i]);
        }
	}

    function updateMerkleRoot(bytes32 _newMerkleRoot, bytes32 _category) external onlyBookKeeperRole whenNotPaused {
        // can only update when restricted mode is on
        if (!isRestrictedMode) {
            revert RestrictedModeOff();
        }
        if (_newMerkleRoot == 0) {
            revert InvalidMerkleRoot();
        }
        merkleRoot[_category] = _newMerkleRoot;
        emit MerkleRootUpdated(_newMerkleRoot, _category);
    }

    function updateMerkleRootInfo(bool _isStake, uint248 _minUnlockDuration, bytes32 _category) external onlyBookKeeperRole whenNotPaused {
        // can only update when restricted mode is on
        if (!isRestrictedMode) {
            revert RestrictedModeOff();
        }
        merkleRootInfo[_category] = MerkleRootInfo(_isStake, _minUnlockDuration);
        emit MerkleRootInfoUpdated(_isStake, _minUnlockDuration, _category);
    }

    // users have to claim all token and all primary & sub wallets at once otherwise the root is marked as claimed
    function claimReward(
        ClaimEntry[] calldata _entries,
        address[] calldata _tokens,
        bytes32[] calldata _merkleProof,
        bytes32 _category,
        bool _isStake,
        uint256 _initUnlockTime // only useful for users without any lock before
    ) external nonReentrant whenNotPaused {
        // can only claim when restricted mode is off
        if (isRestrictedMode) {
            revert RestrictedModeOn();
        }
        if(rewardClaimed[msg.sender][_category][merkleRoot[_category]]) {
            revert RewardAlreadyClaimed();
        }
        rewardClaimed[msg.sender][_category][merkleRoot[_category]] = true;
        if (_entries.length == 0) {
            revert InvalidArrayLength();
        }
        if (_entries[0].user != msg.sender) { // primary wallet address
            revert UnauthorizedClaim();
        }
        TokenClaim[] memory tokenClaims = new TokenClaim[](_tokens.length);
        for (uint256 i = 0; i < _tokens.length; i++) {
            tokenClaims[i].token = _tokens[i];
        }

        bytes memory packed;
        for (uint256 i = 0; i < _entries.length; i++) {
            packed = bytes.concat(packed, abi.encodePacked(_entries[i].user, _entries[i].token, _entries[i].claimAmount));
            for (uint256 j = 0; j < _tokens.length; j++) {
                if (tokenClaims[j].token == _entries[i].token) {
                    tokenClaims[j].totalClaimAmount += _entries[i].claimAmount;
                    break;
                }
            }
        }

        // Create leaf node
        bytes32 leaf = keccak256(abi.encodePacked(packed));
        // Verify the proof
        if(!MerkleProof.verify(_merkleProof, merkleRoot[_category], leaf)) {
            revert InvalidProof();
        }
        
        for (uint256 i = 0; i < _tokens.length; i++) {
            address token = _tokens[i];
            uint256 totalClaimAmount = tokenClaims[i].totalClaimAmount;
            if (totalClaimAmount == 0) {
                continue;
            }

            // reset limit after a day
            if (block.timestamp - lastWithdrawalTime[token] > 1 days) {
                lastWithdrawalTime[token] = block.timestamp;
                currentDailyWithdrawalAmount[token] = 0;
            }

            if (currentDailyWithdrawalAmount[token] + totalClaimAmount <= dailyWithdrawalCap[token]) {
                currentDailyWithdrawalAmount[token] += totalClaimAmount;
                if(IERC20(token).balanceOf(address(this)) < totalClaimAmount) {
                    revert RewardPoolOutOfFunds();
                }
                if (merkleRootInfo[_category].isStake && !_isStake) {
                    revert StakeRequired();
                }
                if (_isStake && token == address(ethgasToken)) {
                    IVotingEscrow.LockedBalance memory l = veToken.locked(msg.sender);
                    ethgasToken.approve(address(veToken), totalClaimAmount);
                    if (l.end > block.timestamp) {
                        if (l.end - block.timestamp < uint256(merkleRootInfo[_category].minUnlockDuration)) {
                            revert InvalidUnlockTime();
                        }
                        veToken.increase_amount_for(msg.sender, totalClaimAmount);
                        emit RewardStaked(msg.sender, totalClaimAmount, 0);
                    } else if (l.amount == 0) {
                        if (_initUnlockTime <= block.timestamp) { 
                            revert InvalidUnlockTime();
                        }
                        if (_initUnlockTime - block.timestamp < uint256(merkleRootInfo[_category].minUnlockDuration)) {
                            revert InvalidUnlockTime();
                        }
                        veToken.create_lock_for(msg.sender, totalClaimAmount, _initUnlockTime);
                        emit RewardStaked(msg.sender, totalClaimAmount, _initUnlockTime);
                    } else {
                        revert CannotStakeForExpiredLock();
                    }

                } else {
                    IERC20(token).safeTransfer(msg.sender, totalClaimAmount);
                }
                emit RewardClaimed(msg.sender, token, totalClaimAmount);
            } else {
                revert DailyWithdrawalCapReached();
            }
        }
    }

    function adminWithdraw(address _tokenAddr, address _receiver, uint256 _amount) external onlyTimelockRole whenNotPaused {
        IERC20(_tokenAddr).safeTransfer(_receiver, _amount);
        emit Withdrawal(_tokenAddr, _receiver, _amount);
    }

    function deposit() payable external onlyDepositor nonReentrant whenNotPaused {
        if(msg.value > 0) {
            IWETH(weth).deposit{value: msg.value}(); 
            emit Deposit(address(weth), msg.sender, msg.value);
        } else {
            revert InvalidDepositAmount();
        }
    }

    function deposit(address[] calldata _tokenAddr, uint256[] calldata _amount) external onlyDepositor nonReentrant whenNotPaused {
        if (_tokenAddr.length != _amount.length) {
            revert InvalidArrayLength();
        }
        for (uint256 i; i < _tokenAddr.length; i++) {
            IERC20(_tokenAddr[i]).safeTransferFrom(msg.sender, address(this), _amount[i]);
            emit Deposit(_tokenAddr[i], msg.sender, _amount[i]);
        }
    }

    
}

// 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/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/utils/SafeERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "./IERC20.sol";
import {IERC20Permit} from "./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/Pausable.sol)

pragma solidity ^0.8.20;

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

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    bool private _paused;

    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    /**
     * @dev The operation failed because the contract is paused.
     */
    error EnforcedPause();

    /**
     * @dev The operation failed because the contract is not paused.
     */
    error ExpectedPause();

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        if (paused()) {
            revert EnforcedPause();
        }
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        if (!paused()) {
            revert ExpectedPause();
        }
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

// 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.12;

interface IACLManager {

    function checkAdminRole(address _account) external view;
    function checkTreasurerRole(address _account) external view;
    function checkTimelockRole(address _account) external view;
    function checkPauserRole(address _account) external view;
    function checkBookKeeperRole(address _account) external view;
    function checkPayouterRole(address _account) external view;
    function checkOtherRole1(address _account) external view;
    function checkOtherRole2(address _account) external view;
    function checkOtherRole3(address _account) external view;

}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;


interface IEthgasPool {


	struct TokenTransfer {
		address token;
		uint256 amount;
	}

	error InvalidParamLength();
	error InvalidBlockNumber();
	error CannotSendEthDirectly();
	
	event DepositsTriggered(
		address indexed sender,
		TokenTransfer[] transfers
	);

	event Withdrawal(
		address indexed clientAddress,
		IEthgasPool.TokenTransfer tokenTranfer
	);

	event AclManagerChanged(address aclManager);

	event DailyWithdrawalCapChanged(
		address token, uint256 cap
	);

	event DailyPayoutCapChanged(
		address token, uint256 cap
	);

	event SupportedTokenChanged(
		address token, bool isSupport
	);

}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

import "./IACLManager.sol";


/// @title Staking Pool Interface
/// @notice An interface containing externally accessible functions of the StakingPool contract
/// @dev The automatically generated public view functions for the state variables and mappings are not included in the interface
interface IEthgasRebate{

    /*//////////////////////////////////////////////////////////////
                            Errors
    //////////////////////////////////////////////////////////////*/

    error MerkleRootNotSet(); // Thrown when the claimReward function is called but not Merkle Root is stored in contract.
    error InvalidMerkleRoot(); // Thrown when if the merkle root to be updated is invalid
    error InvalidProof(); //Thrown if the token as already been enabled or disabled 
    error RewardAlreadyClaimed(); // Thrown if staker attempts to call deposit() with zero amount
    error RewardPoolOutOfFunds(); //Thrown if staker attempts to call withdraw() with zero amount
    error DailyWithdrawalCapReached(); // Thrown if the withdrawal hits the daily withdrawal cap for the particular token.
    error RestrictedModeOn(); // Thrown if users claim reward when restricted mode on.
    error RestrictedModeOff(); // Thrown if merkle root is updated when restricted mode off.
    error InvalidArrayLength();
    error InvalidDepositAmount(); //Thrown if user does not have sufficient balance to deposit
    error DepositNotAllowed(); //Thrown if user is not whitelisted for deposits. 
    error UnauthorizedClaim(); // Thrown if primary wallet of the claim entry is not msg.sender
    error StakeRequired(); // Thrown if staking is required for the merkle tree category but the user refuses to stake
    error InvalidUnlockTime(); // Thrown if user specified unlock time is less than the min unlock time of the merkle tree category
    error CannotStakeForExpiredLock();
    

    /*//////////////////////////////////////////////////////////////
                            Staker Events
    //////////////////////////////////////////////////////////////*/

    ///@notice Emitted an reward is successfully claimed. 
    ///@param user The user that is conducting the claim. 
    ///@param token The token that the user is claiming
    ///@param amount The amount of the reward to be claimed. 
    event RewardClaimed(address user, address token, uint256 amount);

    ///@notice Emitted an reward is successfully staked. 
    ///@param user The user that is conducting the stake. 
    ///@param amount The amount of the reward to be staked. 
    event RewardStaked(address user, uint256 amount, uint256 initUnlockTime);
    
    
    ///@notice Emitted when the Merkle Root of this contract is updated. 
    ///@param newRoot The root to be updated to. 
    event MerkleRootUpdated(bytes32 newRoot, bytes32 category);

    event MerkleRootInfoUpdated(bool isStake, uint256 minUnlockDuration, bytes32 category);

    ///@notice Emitted when ACLManager has been changed
    ///@param aclManager The address of the new ACLManager
    event AclManagerChanged(address aclManager);

    /// @notice Emitted when restricted mode is updated
    /// @param mode either true or false
    event RestrictedModeUpdated(bool mode);

    ///@notice Emitted an address is whitelisted for deposit 
    ///@param depositor The address of the depositor
    ///@param status The status of the whitelist.
	event DepositWhitelistStatusChanged(
		address depositor, bool status
	);

    ///@notice Emitted when the daily withdrawal cap is set. 
    ///@param token The token address of the cap to be implemeneted on. 
    ///@param cap The amount that is capped. 
	event DailyWithdrawalCapChanged(
		address token, uint256 cap
	);

    ///@notice Emitted when some calls the deposits function to deposit funds to the rewards contract. 
	event Deposit(
		address token, address depositor, uint256 amount
	);

    ///@notice Emitted when some calls the withdraws function to withdraw funds to the rewards contract. 
	event Withdrawal(
		address token, address receiver, uint256 amount
	);

    /*//////////////////////////////////////////////////////////////
                            Admin Functions
    //////////////////////////////////////////////////////////////*/


    ///@notice Change the ACL Manager to update the ACL 
    ///@param _aclManager address of the ACL Manager
    function setAclManager(IACLManager _aclManager) external ;

    ///@notice Pause further staking through the deposit function.
    ///@dev Only callable by the owner. Withdrawals and migrations will still be possible when paused
    function pause() external;

    ///@notice Unpause staking allowing the deposit function to be used again
    ///@dev Only callable by the owner
    function unpause() external;

    ///@notice function to set the daily withdrawal cap 
    ///@param _tokenAddr The token address of the cap to be implemeneted on. 
    ///@param _cap The amount that is capped. 
    function setDailyWithdrawalCap(address _tokenAddr, uint256 _cap) external;

    ///@notice function to set depositor whitelist
    ///@param _depositorAddr The address of the depositor to be whitelisted.
    ///@param _status Enable or disaable whitelist.
    function setDepositorWhitelist(address[] calldata _depositorAddr, bool[] calldata _status) external;

    ///@notice function withdraw funds from the rewards contract to admin. 
    ///@param _tokenAddr, Token to withdraw 
    ///@param amount Amount to withdraw
    function adminWithdraw(address _tokenAddr, address _receiver, uint256 amount) external;

    /*//////////////////////////////////////////////////////////////
                            Reward Claim Functions
    //////////////////////////////////////////////////////////////*/

    ///@notice called to update the Merkle Root from the backend server
    ///@param _newMerkleRoot The Merkle Root to be updated. 
    ///@param _category The Merkle Root Category 
    ///@dev only callable by bookkeeper
    function updateMerkleRoot(bytes32 _newMerkleRoot, bytes32 _category) external;

    function updateMerkleRootInfo(bool _isStake, uint248 _minUnlockDuration, bytes32 _category) external;
    
    struct ClaimEntry {
        address user;
        address token;
        uint256 claimAmount;
    }
    struct TokenClaim {
        address token;
        uint256 totalClaimAmount;
    }
    ///@notice After the Merkle Proof is retrived from the backend server, user can call this function to claim the rewards
    ///@param _entries refer to ClaimEntry Struct
    ///@param _merkleProof Merkle Proof retrieved from backend server to verify this transaction
    ///@param _category The Merkle Root Category
    ///@dev cannot be called when the contract is paused. 
    function claimReward(
        ClaimEntry[] calldata _entries,
        address[] calldata _tokens,
        bytes32[] calldata _merkleProof,
        bytes32 _category,
        bool _isStake,
        uint256 _initUnlockTime
    ) external;

    /*//////////////////////////////////////////////////////////////
                            Other Functions
    //////////////////////////////////////////////////////////////*/
    ///@notice function to deposit native ETH to the rewards contract.
    function deposit() payable external; 


    ///@notice function to deposit funds to the rewards contract.
    ///@param _tokenAddr The token address of the deposit.
    ///@param _amount The amount to deposit.
    function deposit(address[] calldata _tokenAddr, uint256[] calldata _amount) external; 

}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

interface IVotingEscrow {

    struct LockedBalance {
        int128 amount;
        uint256 end;
    }

    function create_lock(uint256 _value, uint256 _unlock_time) external;
    function increase_amount(uint256 _value) external;
    function create_lock_for(address _addr, uint256 _value, uint256 _unlock_time) external;
    function increase_amount_for(address _addr, uint256 _value) external;
    function increase_unlock_time(uint256 _unlock_time) external;
    function withdraw() external;
    function whitelist_contracts(address[30] memory contracts, bool[30] memory is_whitelists) external;

    // view
    function locked(address user) external view returns (LockedBalance memory);
    function balanceOf(address addr) external view returns (uint256);
    function totalSupply() external view returns (uint256);
    function admin() external view returns (address);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.12;

import "../dependencies/openzeppelin-v5.0.1/token/SafeERC20.sol";

interface IWETH is IERC20 {
    function deposit() external payable;
    function withdraw(uint) external;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.12;

import "../interfaces/IWETH.sol";
import "../interfaces/IEthgasPool.sol";


library InputValidator {



	error IncorrectAddress();

	function validateAddr (address _inputAddr) internal pure {
		if (_inputAddr == address(0)) {
			revert IncorrectAddress();
		}

	}

}

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IACLManager","name":"_aclManager","type":"address"},{"internalType":"address[]","name":"_token","type":"address[]"},{"internalType":"uint256[]","name":"_cap","type":"uint256[]"},{"internalType":"contract IWETH","name":"_weth","type":"address"},{"internalType":"contract IERC20","name":"_ethgasToken","type":"address"},{"internalType":"contract IVotingEscrow","name":"_veToken","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":"CannotStakeForExpiredLock","type":"error"},{"inputs":[],"name":"DailyWithdrawalCapReached","type":"error"},{"inputs":[],"name":"DepositNotAllowed","type":"error"},{"inputs":[],"name":"EnforcedPause","type":"error"},{"inputs":[],"name":"ExpectedPause","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[],"name":"IncorrectAddress","type":"error"},{"inputs":[],"name":"InvalidArrayLength","type":"error"},{"inputs":[],"name":"InvalidDepositAmount","type":"error"},{"inputs":[],"name":"InvalidMerkleRoot","type":"error"},{"inputs":[],"name":"InvalidProof","type":"error"},{"inputs":[],"name":"InvalidUnlockTime","type":"error"},{"inputs":[],"name":"MerkleRootNotSet","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[],"name":"RestrictedModeOff","type":"error"},{"inputs":[],"name":"RestrictedModeOn","type":"error"},{"inputs":[],"name":"RewardAlreadyClaimed","type":"error"},{"inputs":[],"name":"RewardPoolOutOfFunds","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[],"name":"StakeRequired","type":"error"},{"inputs":[],"name":"UnauthorizedClaim","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"aclManager","type":"address"}],"name":"AclManagerChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"cap","type":"uint256"}],"name":"DailyWithdrawalCapChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"address","name":"depositor","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"depositor","type":"address"},{"indexed":false,"internalType":"bool","name":"status","type":"bool"}],"name":"DepositWhitelistStatusChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"isStake","type":"bool"},{"indexed":false,"internalType":"uint256","name":"minUnlockDuration","type":"uint256"},{"indexed":false,"internalType":"bytes32","name":"category","type":"bytes32"}],"name":"MerkleRootInfoUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"newRoot","type":"bytes32"},{"indexed":false,"internalType":"bytes32","name":"category","type":"bytes32"}],"name":"MerkleRootUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"mode","type":"bool"}],"name":"RestrictedModeUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RewardClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"initUnlockTime","type":"uint256"}],"name":"RewardStaked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"address","name":"receiver","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdrawal","type":"event"},{"inputs":[],"name":"aclManager","outputs":[{"internalType":"contract IACLManager","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_tokenAddr","type":"address"},{"internalType":"address","name":"_receiver","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"adminWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"user","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"claimAmount","type":"uint256"}],"internalType":"struct IEthgasRebate.ClaimEntry[]","name":"_entries","type":"tuple[]"},{"internalType":"address[]","name":"_tokens","type":"address[]"},{"internalType":"bytes32[]","name":"_merkleProof","type":"bytes32[]"},{"internalType":"bytes32","name":"_category","type":"bytes32"},{"internalType":"bool","name":"_isStake","type":"bool"},{"internalType":"uint256","name":"_initUnlockTime","type":"uint256"}],"name":"claimReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"currentDailyWithdrawalAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"dailyWithdrawalCap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deposit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_tokenAddr","type":"address[]"},{"internalType":"uint256[]","name":"_amount","type":"uint256[]"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"depositWhitelist","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"endRestrictedMode","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"ethgasToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isRestrictedMode","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"lastWithdrawalTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"merkleRootInfo","outputs":[{"internalType":"bool","name":"isStake","type":"bool"},{"internalType":"uint248","name":"minUnlockDuration","type":"uint248"}],"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":"","type":"address"},{"internalType":"bytes32","name":"","type":"bytes32"},{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"rewardClaimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IACLManager","name":"_aclManager","type":"address"}],"name":"setAclManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_cap","type":"uint256"}],"name":"setDailyWithdrawalCap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_depositorAddr","type":"address[]"},{"internalType":"bool[]","name":"_status","type":"bool[]"}],"name":"setDepositorWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startRestrictedMode","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_newMerkleRoot","type":"bytes32"},{"internalType":"bytes32","name":"_category","type":"bytes32"}],"name":"updateMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_isStake","type":"bool"},{"internalType":"uint248","name":"_minUnlockDuration","type":"uint248"},{"internalType":"bytes32","name":"_category","type":"bytes32"}],"name":"updateMerkleRootInfo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"veToken","outputs":[{"internalType":"contract IVotingEscrow","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"weth","outputs":[{"internalType":"contract IWETH","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

00000000000000000000000049cad6920e26a36bad8db25f8dbf037d4855369000000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000100000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc20000000000000000000000002798b1cc5a993085e8a9d46e80499f1b63f4220400000000000000000000000013ab49189ebc2287e941a82d9af154130f96eb2100000000000000000000000000000000000000000000000000000000000000010000000000000000000000002798b1cc5a993085e8a9d46e80499f1b63f422040000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000295be96e64066972000000

-----Decoded View---------------
Arg [0] : _aclManager (address): 0x49CAD6920e26a36BAD8db25f8dBf037d48553690
Arg [1] : _token (address[]): 0x2798b1cC5A993085E8A9D46e80499F1B63f42204
Arg [2] : _cap (uint256[]): 50000000000000000000000000
Arg [3] : _weth (address): 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2
Arg [4] : _ethgasToken (address): 0x2798b1cC5A993085E8A9D46e80499F1B63f42204
Arg [5] : _veToken (address): 0x13aB49189EBC2287E941a82D9Af154130f96Eb21

-----Encoded View---------------
10 Constructor Arguments found :
Arg [0] : 00000000000000000000000049cad6920e26a36bad8db25f8dbf037d48553690
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000100
Arg [3] : 000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2
Arg [4] : 0000000000000000000000002798b1cc5a993085e8a9d46e80499f1b63f42204
Arg [5] : 00000000000000000000000013ab49189ebc2287e941a82d9af154130f96eb21
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [7] : 0000000000000000000000002798b1cc5a993085e8a9d46e80499f1b63f42204
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [9] : 000000000000000000000000000000000000000000295be96e64066972000000