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.23;

import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

interface INonfungiblePositionManager {
    struct CollectParams {
        uint256 tokenId;
        address recipient;
        uint128 amount0Max;
        uint128 amount1Max;
    }

    function collect(CollectParams calldata params) external returns (uint256 amount0, uint256 amount1);
    function ownerOf(uint256 tokenId) external view returns (address);
    function isApprovedForAll(address owner, address operator) external view returns (bool);
    function positions(uint256 tokenId) external view returns (
        uint96 nonce,
        address operator,
        address token0,
        address token1,
        uint24 fee,
        int24 tickLower,
        int24 tickUpper,
        uint128 liquidity,
        uint256 feeGrowthInside0LastX128,
        uint256 feeGrowthInside1LastX128,
        uint128 tokensOwed0,
        uint128 tokensOwed1
    );
}

interface IWETH {
    function withdraw(uint256) external;
}

/// @title BatchClaim
/// @notice Batch claim fees from multiple V3 positions and swap to target token via multihop
contract BatchClaim is ReentrancyGuard {
    using SafeERC20 for IERC20;

    /*//////////////////////////////////////////////////////////////
                                 ERRORS
    //////////////////////////////////////////////////////////////*/
    
    error ZeroAddress();
    error NotPositionOwner(uint256 tokenId);
    error TooManyPositions();
    error TooManySwaps();
    error SwapFailed();
    error InsufficientOutput();
    error TransferFailed();
    error DeadlineExpired();
    error InvalidSwapSelector();
    error InvalidSwapRecipient();

    /*//////////////////////////////////////////////////////////////
                                CONSTANTS
    //////////////////////////////////////////////////////////////*/

    uint256 public constant MAX_POSITIONS = 50;
    uint256 public constant MAX_SWAPS = 20;

    bytes4 private constant EXACT_INPUT_SINGLE_SELECTOR = 0x414bf389;
    bytes4 private constant EXACT_INPUT_SELECTOR = 0xc04b8d59;

    /*//////////////////////////////////////////////////////////////
                            STATE VARIABLES
    //////////////////////////////////////////////////////////////*/

    INonfungiblePositionManager public immutable positionManager;
    address public immutable swapRouter;
    address public immutable weth;

    /*//////////////////////////////////////////////////////////////
                                STRUCTS
    //////////////////////////////////////////////////////////////*/

    struct SwapParams {
        address tokenIn;
        bytes swapCalldata;
    }

    struct CollectedToken {
        address token;
        uint256 amount;
    }

    /// @dev V3 SwapRouter ExactInputSingleParams
    struct ExactInputSingleParams {
        address tokenIn;
        address tokenOut;
        uint24 fee;
        address recipient;
        uint256 deadline;
        uint256 amountIn;
        uint256 amountOutMinimum;
        uint160 sqrtPriceLimitX96;
    }

    /// @dev V3 SwapRouter ExactInputParams
    struct ExactInputParams {
        bytes path;
        address recipient;
        uint256 deadline;
        uint256 amountIn;
        uint256 amountOutMinimum;
    }

    /*//////////////////////////////////////////////////////////////
                              CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/

    constructor(address _positionManager, address _swapRouter, address _weth) {
        if (_positionManager == address(0)) revert ZeroAddress();
        if (_swapRouter == address(0)) revert ZeroAddress();
        if (_weth == address(0)) revert ZeroAddress();
        
        positionManager = INonfungiblePositionManager(_positionManager);
        swapRouter = _swapRouter;
        weth = _weth;
    }

    receive() external payable {}

    /*//////////////////////////////////////////////////////////////
                            VIEW FUNCTIONS
    //////////////////////////////////////////////////////////////*/

    /// @notice Check if user has approved this contract to manage their positions
    /// @param user The user address to check
    /// @return True if approved
    function isApproved(address user) external view returns (bool) {
        return positionManager.isApprovedForAll(user, address(this));
    }

    /*//////////////////////////////////////////////////////////////
                            MAIN FUNCTION
    //////////////////////////////////////////////////////////////*/

    /// @notice Batch claim fees from V3 positions and swap to target token
    /// @param tokenIds Array of position tokenIds to collect from
    /// @param swaps Array of swap params for each unique token to swap
    /// @param targetToken The token to receive after swaps
    /// @param minReceived Minimum amount of target token required (reverts if not met)
    /// @param unwrapWETH If true and targetToken is WETH, unwrap to native ETH
    /// @param deadline Timestamp after which the transaction will revert
    /// @return totalReceived Total amount of target token received
    function batchClaim(
        uint256[] calldata tokenIds,
        SwapParams[] calldata swaps,
        address targetToken,
        uint256 minReceived,
        bool unwrapWETH,
        uint256 deadline
    ) external nonReentrant returns (uint256 totalReceived) {
        // Validate deadline
        if (block.timestamp > deadline) revert DeadlineExpired();

        // Validate array lengths
        if (tokenIds.length > MAX_POSITIONS) revert TooManyPositions();
        if (swaps.length > MAX_SWAPS) revert TooManySwaps();

        uint256 balanceBefore = IERC20(targetToken).balanceOf(address(this));

        // Track collected tokens with exact amounts
        CollectedToken[] memory collected = new CollectedToken[](tokenIds.length * 2);
        uint256 collectedCount;

        // Step 1: Verify ownership and collect all fees
        for (uint256 i; i < tokenIds.length; ) {
            uint256 tokenId = tokenIds[i];
            
            // Verify caller owns the position
            if (positionManager.ownerOf(tokenId) != msg.sender) {
                revert NotPositionOwner(tokenId);
            }

            (, , address token0, address token1, , , , , , , , ) = positionManager.positions(tokenId);
            
            // Collect fees - returns exact amounts collected
            (uint256 amount0, uint256 amount1) = positionManager.collect(
                INonfungiblePositionManager.CollectParams({
                    tokenId: tokenId,
                    recipient: address(this),
                    amount0Max: type(uint128).max,
                    amount1Max: type(uint128).max
                })
            );

            // Track exact collected amounts
            if (amount0 > 0) {
                _addCollected(collected, collectedCount, token0, amount0);
                collectedCount = _updateCount(collected, collectedCount, token0);
            }
            if (amount1 > 0) {
                _addCollected(collected, collectedCount, token1, amount1);
                collectedCount = _updateCount(collected, collectedCount, token1);
            }

            unchecked { ++i; }
        }

        // Step 2: Execute swaps
        for (uint256 i; i < swaps.length; ) {
            SwapParams calldata swap = swaps[i];
            uint256 balance = IERC20(swap.tokenIn).balanceOf(address(this));
            
            if (balance > 0 && swap.tokenIn != targetToken && swap.swapCalldata.length > 0) {
                _validateSwapCalldata(swap.swapCalldata);

                IERC20(swap.tokenIn).forceApprove(swapRouter, balance);

                (bool success, ) = swapRouter.call(swap.swapCalldata);
                if (!success) revert SwapFailed();

                // Reset approval to 0 to prevent leftover allowance
                IERC20(swap.tokenIn).forceApprove(swapRouter, 0);
            }
            unchecked { ++i; }
        }

        // Step 3: Calculate total received and verify minimum
        totalReceived = IERC20(targetToken).balanceOf(address(this)) - balanceBefore;
        if (totalReceived < minReceived) revert InsufficientOutput();

        // Step 4: Transfer target tokens to caller
        if (totalReceived > 0) {
            if (unwrapWETH && targetToken == weth) {
                IWETH(weth).withdraw(totalReceived);
                (bool success, ) = msg.sender.call{value: totalReceived}("");
                if (!success) revert TransferFailed();
            } else {
                IERC20(targetToken).safeTransfer(msg.sender, totalReceived);
            }
        }

        // Step 5: Sweep ALL remaining balances back to caller (prevents dust accumulation)
        for (uint256 i; i < collectedCount; ) {
            address token = collected[i].token;
            if (token != address(0)) {
                uint256 remaining = IERC20(token).balanceOf(address(this));
                if (remaining > 0) {
                    IERC20(token).safeTransfer(msg.sender, remaining);
                }
            }
            unchecked { ++i; }
        }
    }

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

    /// @dev Validates swap calldata: must be exactInputSingle or exactInput with recipient = address(this)
    function _validateSwapCalldata(bytes calldata swapCalldata) internal view {
        if (swapCalldata.length < 4) revert InvalidSwapSelector();

        bytes4 selector = bytes4(swapCalldata[:4]);
        address recipient;

        if (selector == EXACT_INPUT_SINGLE_SELECTOR) {
            ExactInputSingleParams memory params = abi.decode(swapCalldata[4:], (ExactInputSingleParams));
            recipient = params.recipient;
        } else if (selector == EXACT_INPUT_SELECTOR) {
            ExactInputParams memory params = abi.decode(swapCalldata[4:], (ExactInputParams));
            recipient = params.recipient;
        } else {
            revert InvalidSwapSelector();
        }

        if (recipient != address(this)) revert InvalidSwapRecipient();
    }

    /// @dev Add or update collected token amount
    function _addCollected(
        CollectedToken[] memory collected,
        uint256 count,
        address token,
        uint256 amount
    ) internal pure {
        for (uint256 i; i < count; ) {
            if (collected[i].token == token) {
                collected[i].amount += amount;
                return;
            }
            unchecked { ++i; }
        }
        collected[count].token = token;
        collected[count].amount = amount;
    }

    /// @dev Get updated count after adding token
    function _updateCount(
        CollectedToken[] memory collected,
        uint256 count,
        address token
    ) internal pure returns (uint256) {
        for (uint256 i; i < count; ) {
            if (collected[i].token == token) {
                return count; // Already exists
            }
            unchecked { ++i; }
        }
        return count + 1; // New token added
    }
}

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

pragma solidity ^0.8.20;

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

/**
 * @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 EIP-1153 (transient storage) is available on the chain you're deploying at,
 * consider using {ReentrancyGuardTransient} instead.
 *
 * 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].
 *
 * IMPORTANT: Deprecated. This storage-based reentrancy guard will be removed and replaced
 * by the {ReentrancyGuardTransient} variant in v6.0.
 *
 * @custom:stateless
 */
abstract contract ReentrancyGuard {
    using StorageSlot for bytes32;

    // keccak256(abi.encode(uint256(keccak256("openzeppelin.storage.ReentrancyGuard")) - 1)) & ~bytes32(uint256(0xff))
    bytes32 private constant REENTRANCY_GUARD_STORAGE =
        0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00;

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

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

    constructor() {
        _reentrancyGuardStorageSlot().getUint256Slot().value = 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();
    }

    /**
     * @dev A `view` only version of {nonReentrant}. Use to block view functions
     * from being called, preventing reading from inconsistent contract state.
     *
     * CAUTION: This is a "view" modifier and does not change the reentrancy
     * status. Use it only on view functions. For payable or non-payable functions,
     * use the standard {nonReentrant} modifier instead.
     */
    modifier nonReentrantView() {
        _nonReentrantBeforeView();
        _;
    }

    function _nonReentrantBeforeView() private view {
        if (_reentrancyGuardEntered()) {
            revert ReentrancyGuardReentrantCall();
        }
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        _nonReentrantBeforeView();

        // Any calls to nonReentrant after this point will fail
        _reentrancyGuardStorageSlot().getUint256Slot().value = ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _reentrancyGuardStorageSlot().getUint256Slot().value = 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 _reentrancyGuardStorageSlot().getUint256Slot().value == ENTERED;
    }

    function _reentrancyGuardStorageSlot() internal pure virtual returns (bytes32) {
        return REENTRANCY_GUARD_STORAGE;
    }
}

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

pragma solidity >=0.4.16;

/**
 * @dev Interface of the ERC-20 standard as defined in the ERC.
 */
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.5.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";
import {IERC1363} from "../../../interfaces/IERC1363.sol";

/**
 * @title SafeERC20
 * @dev Wrappers around ERC-20 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 {
    /**
     * @dev An operation with an ERC-20 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 {
        if (!_safeTransfer(token, to, value, true)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @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 {
        if (!_safeTransferFrom(token, from, to, value, true)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.
     */
    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {
        return _safeTransfer(token, to, value, false);
    }

    /**
     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.
     */
    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {
        return _safeTransferFrom(token, from, to, value, false);
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     *
     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
     * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
     */
    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.
     *
     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the "client"
     * smart contract uses ERC-7674 to set temporary allowances, then the "client" smart contract should avoid using
     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract
     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.
     */
    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.
     *
     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function
     * only sets the "standard" allowance. Any temporary allowance will remain active, in addition to the value being
     * set here.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        if (!_safeApprove(token, spender, value, false)) {
            if (!_safeApprove(token, spender, 0, true)) revert SafeERC20FailedOperation(address(token));
            if (!_safeApprove(token, spender, value, true)) revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no
     * code. This can be used to implement an {ERC721}-like safe transfer that relies on {ERC1363} checks when
     * targeting contracts.
     *
     * Reverts if the returned value is other than `true`.
     */
    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
        if (to.code.length == 0) {
            safeTransfer(token, to, value);
        } else if (!token.transferAndCall(to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target
     * has no code. This can be used to implement an {ERC721}-like safe transfer that relies on {ERC1363} checks when
     * targeting contracts.
     *
     * Reverts if the returned value is other than `true`.
     */
    function transferFromAndCallRelaxed(
        IERC1363 token,
        address from,
        address to,
        uint256 value,
        bytes memory data
    ) internal {
        if (to.code.length == 0) {
            safeTransferFrom(token, from, to, value);
        } else if (!token.transferFromAndCall(from, to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no
     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when
     * targeting contracts.
     *
     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.
     * Oppositely, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}
     * once without retrying, and relies on the returned value to be true.
     *
     * Reverts if the returned value is other than `true`.
     */
    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {
        if (to.code.length == 0) {
            forceApprove(token, to, value);
        } else if (!token.approveAndCall(to, value, data)) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @dev Imitates a Solidity `token.transfer(to, value)` call, 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 to The recipient of the tokens
     * @param value The amount of token to transfer
     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.
     */
    function _safeTransfer(IERC20 token, address to, uint256 value, bool bubble) private returns (bool success) {
        bytes4 selector = IERC20.transfer.selector;

        assembly ("memory-safe") {
            let fmp := mload(0x40)
            mstore(0x00, selector)
            mstore(0x04, and(to, shr(96, not(0))))
            mstore(0x24, value)
            success := call(gas(), token, 0, 0x00, 0x44, 0x00, 0x20)
            // if call success and return is true, all is good.
            // otherwise (not success or return is not true), we need to perform further checks
            if iszero(and(success, eq(mload(0x00), 1))) {
                // if the call was a failure and bubble is enabled, bubble the error
                if and(iszero(success), bubble) {
                    returndatacopy(fmp, 0x00, returndatasize())
                    revert(fmp, returndatasize())
                }
                // if the return value is not true, then the call is only successful if:
                // - the token address has code
                // - the returndata is empty
                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))
            }
            mstore(0x40, fmp)
        }
    }

    /**
     * @dev Imitates a Solidity `token.transferFrom(from, to, value)` call, 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 from The sender of the tokens
     * @param to The recipient of the tokens
     * @param value The amount of token to transfer
     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.
     */
    function _safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value,
        bool bubble
    ) private returns (bool success) {
        bytes4 selector = IERC20.transferFrom.selector;

        assembly ("memory-safe") {
            let fmp := mload(0x40)
            mstore(0x00, selector)
            mstore(0x04, and(from, shr(96, not(0))))
            mstore(0x24, and(to, shr(96, not(0))))
            mstore(0x44, value)
            success := call(gas(), token, 0, 0x00, 0x64, 0x00, 0x20)
            // if call success and return is true, all is good.
            // otherwise (not success or return is not true), we need to perform further checks
            if iszero(and(success, eq(mload(0x00), 1))) {
                // if the call was a failure and bubble is enabled, bubble the error
                if and(iszero(success), bubble) {
                    returndatacopy(fmp, 0x00, returndatasize())
                    revert(fmp, returndatasize())
                }
                // if the return value is not true, then the call is only successful if:
                // - the token address has code
                // - the returndata is empty
                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))
            }
            mstore(0x40, fmp)
            mstore(0x60, 0)
        }
    }

    /**
     * @dev Imitates a Solidity `token.approve(spender, value)` call, 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 spender The spender of the tokens
     * @param value The amount of token to transfer
     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.
     */
    function _safeApprove(IERC20 token, address spender, uint256 value, bool bubble) private returns (bool success) {
        bytes4 selector = IERC20.approve.selector;

        assembly ("memory-safe") {
            let fmp := mload(0x40)
            mstore(0x00, selector)
            mstore(0x04, and(spender, shr(96, not(0))))
            mstore(0x24, value)
            success := call(gas(), token, 0, 0x00, 0x44, 0x00, 0x20)
            // if call success and return is true, all is good.
            // otherwise (not success or return is not true), we need to perform further checks
            if iszero(and(success, eq(mload(0x00), 1))) {
                // if the call was a failure and bubble is enabled, bubble the error
                if and(iszero(success), bubble) {
                    returndatacopy(fmp, 0x00, returndatasize())
                    revert(fmp, returndatasize())
                }
                // if the return value is not true, then the call is only successful if:
                // - the token address has code
                // - the returndata is empty
                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))
            }
            mstore(0x40, fmp)
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.

pragma solidity ^0.8.20;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC-1967 implementation slot:
 * ```solidity
 * contract ERC1967 {
 *     // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(newImplementation.code.length > 0);
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * TIP: Consider using this library along with {SlotDerivation}.
 */
library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct Int256Slot {
        int256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `Int256Slot` with member `value` located at `slot`.
     */
    function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns a `StringSlot` with member `value` located at `slot`.
     */
    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
     */
    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
        assembly ("memory-safe") {
            r.slot := store.slot
        }
    }

    /**
     * @dev Returns a `BytesSlot` with member `value` located at `slot`.
     */
    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
        assembly ("memory-safe") {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
     */
    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
        assembly ("memory-safe") {
            r.slot := store.slot
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)

pragma solidity >=0.6.2;

import {IERC20} from "./IERC20.sol";
import {IERC165} from "./IERC165.sol";

/**
 * @title IERC1363
 * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].
 *
 * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract
 * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.
 */
interface IERC1363 is IERC20, IERC165 {
    /*
     * Note: the ERC-165 identifier for this interface is 0xb0202a11.
     * 0xb0202a11 ===
     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^
     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^
     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^
     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))
     */

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism
     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.
     * @param from The address which you want to send tokens from.
     * @param to The address which you want to transfer to.
     * @param value The amount of tokens to be transferred.
     * @param data Additional data with no specified format, sent in call to `to`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value) external returns (bool);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.
     * @param spender The address which will spend the funds.
     * @param value The amount of tokens to be spent.
     * @param data Additional data with no specified format, sent in call to `spender`.
     * @return A boolean value indicating whether the operation succeeded unless throwing.
     */
    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)

pragma solidity >=0.4.16;

import {IERC20} from "../token/ERC20/IERC20.sol";

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)

pragma solidity >=0.4.16;

import {IERC165} from "../utils/introspection/IERC165.sol";

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)

pragma solidity >=0.4.16;

/**
 * @dev Interface of the ERC-165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[ERC].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

{
  "remappings": [
    "forge-std/=lib/forge-std/src/",
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "shanghai",
  "viaIR": false
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_positionManager","type":"address"},{"internalType":"address","name":"_swapRouter","type":"address"},{"internalType":"address","name":"_weth","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"DeadlineExpired","type":"error"},{"inputs":[],"name":"InsufficientOutput","type":"error"},{"inputs":[],"name":"InvalidSwapRecipient","type":"error"},{"inputs":[],"name":"InvalidSwapSelector","type":"error"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"NotPositionOwner","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[],"name":"SwapFailed","type":"error"},{"inputs":[],"name":"TooManyPositions","type":"error"},{"inputs":[],"name":"TooManySwaps","type":"error"},{"inputs":[],"name":"TransferFailed","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"inputs":[],"name":"MAX_POSITIONS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_SWAPS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"},{"components":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"bytes","name":"swapCalldata","type":"bytes"}],"internalType":"struct BatchClaim.SwapParams[]","name":"swaps","type":"tuple[]"},{"internalType":"address","name":"targetToken","type":"address"},{"internalType":"uint256","name":"minReceived","type":"uint256"},{"internalType":"bool","name":"unwrapWETH","type":"bool"},{"internalType":"uint256","name":"deadline","type":"uint256"}],"name":"batchClaim","outputs":[{"internalType":"uint256","name":"totalReceived","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"isApproved","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"positionManager","outputs":[{"internalType":"contract INonfungiblePositionManager","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"swapRouter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"weth","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

000000000000000000000000ead19ae861c29bbb2101e834922b2feee69b90910000000000000000000000001ebdfc75ffe3ba3de61e7138a3e8706ac841af9b0000000000000000000000005555555555555555555555555555555555555555

-----Decoded View---------------
Arg [0] : _positionManager (address): 0xeaD19AE861c29bBb2101E834922B2FEee69B9091
Arg [1] : _swapRouter (address): 0x1EbDFC75FfE3ba3de61E7138a3E8706aC841Af9B
Arg [2] : _weth (address): 0x5555555555555555555555555555555555555555

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000ead19ae861c29bbb2101e834922b2feee69b9091
Arg [1] : 0000000000000000000000001ebdfc75ffe3ba3de61e7138a3e8706ac841af9b
Arg [2] : 0000000000000000000000005555555555555555555555555555555555555555