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: BUSL-1.1
// SPDX-FileCopyrightText: 2024 Kiln <[email protected]>
//
// ██╗  ██╗██╗██╗     ███╗   ██╗
// ██║ ██╔╝██║██║     ████╗  ██║
// █████╔╝ ██║██║     ██╔██╗ ██║
// ██╔═██╗ ██║██║     ██║╚██╗██║
// ██║  ██╗██║███████╗██║ ╚████║
// ╚═╝  ╚═╝╚═╝╚══════╝╚═╝  ╚═══╝
//
pragma solidity 0.8.18;

import {IExitQueueClaimHelper} from "@src/interfaces/integrations/IExitQueueClaimHelper.sol";
import {IFeeDispatcher} from "@src/interfaces/integrations/IFeeDispatcher.sol";
import {IvExitQueue} from "@src/interfaces/IvExitQueue.sol";

/// @title ExitQueueClaimHelper (V1) Contract
/// @author gauthiermyr @ Kiln
/// @notice This contract contains functions to resolve and claim casks on several exit queues.
contract ExitQueueClaimHelper is IExitQueueClaimHelper {
    /// @inheritdoc IExitQueueClaimHelper
    function multiClaim(address[] calldata exitQueues, uint256[][] calldata ticketIds, uint32[][] calldata casksIds)
        external
        override
        returns (IvExitQueue.ClaimStatus[][] memory statuses)
    {
        if (exitQueues.length != ticketIds.length) {
            revert IFeeDispatcher.UnequalLengths(exitQueues.length, ticketIds.length);
        }
        if (exitQueues.length != casksIds.length) {
            revert IFeeDispatcher.UnequalLengths(exitQueues.length, casksIds.length);
        }

        statuses = new IvExitQueue.ClaimStatus[][](exitQueues.length);

        for (uint256 i = 0; i < exitQueues.length;) {
            IvExitQueue exitQueue = IvExitQueue(exitQueues[i]);
            // slither-disable-next-line calls-loop
            statuses[i] = exitQueue.claim(ticketIds[i], casksIds[i], type(uint16).max);

            unchecked {
                ++i;
            }
        }
    }

    /// @inheritdoc IExitQueueClaimHelper
    function multiResolve(address[] calldata exitQueues, uint256[][] calldata ticketIds)
        external
        view
        override
        returns (int64[][] memory caskIdsOrErrors)
    {
        if (exitQueues.length != ticketIds.length) {
            revert IFeeDispatcher.UnequalLengths(exitQueues.length, ticketIds.length);
        }

        caskIdsOrErrors = new int64[][](exitQueues.length);

        for (uint256 i = 0; i < exitQueues.length;) {
            IvExitQueue exitQueue = IvExitQueue(exitQueues[i]);
            // slither-disable-next-line calls-loop
            caskIdsOrErrors[i] = exitQueue.resolve(ticketIds[i]);

            unchecked {
                ++i;
            }
        }
    }
}

// SPDX-License-Identifier: BUSL-1.1
// SPDX-FileCopyrightText: 2024 Kiln <[email protected]>
//
// ██╗  ██╗██╗██╗     ███╗   ██╗
// ██║ ██╔╝██║██║     ████╗  ██║
// █████╔╝ ██║██║     ██╔██╗ ██║
// ██╔═██╗ ██║██║     ██║╚██╗██║
// ██║  ██╗██║███████╗██║ ╚████║
// ╚═╝  ╚═╝╚═╝╚══════╝╚═╝  ╚═══╝
//
pragma solidity 0.8.18;

import {IvExitQueue} from "@src/interfaces/IvExitQueue.sol";

/// @title ExitQueueClaimHelper (V1) Interface
/// @author gauthiermyr @ Kiln
interface IExitQueueClaimHelper {
    /// @notice Claim caskIds for given tickets on each exit queue
    /// @param exitQueues List of exit queues
    /// @param ticketIds List of tickets in each exit queue
    /// @param casksIds List of caskIds to claim with each ticket
    /// @return statuses List of claim statuses for each ticket
    function multiClaim(address[] calldata exitQueues, uint256[][] calldata ticketIds, uint32[][] calldata casksIds)
        external
        returns (IvExitQueue.ClaimStatus[][] memory statuses);

    /// @notice Resolve a list of casksIds for given exitQueues and tickets
    /// @param exitQueues List of exit queues
    /// @param ticketIds List of tickets in each exit queue
    /// @return caskIdsOrErrors List of caskIds or errors for each ticket
    function multiResolve(address[] calldata exitQueues, uint256[][] calldata ticketIds)
        external
        view
        returns (int64[][] memory caskIdsOrErrors);
}

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2024 Kiln <[email protected]>
//
// ██╗  ██╗██╗██╗     ███╗   ██╗
// ██║ ██╔╝██║██║     ████╗  ██║
// █████╔╝ ██║██║     ██╔██╗ ██║
// ██╔═██╗ ██║██║     ██║╚██╗██║
// ██║  ██╗██║███████╗██║ ╚████║
// ╚═╝  ╚═╝╚═╝╚══════╝╚═╝  ╚═══╝
//
pragma solidity 0.8.18;

/// @title FeeDispatcher (V1) Interface
/// @author 0xvv @ Kiln
/// @notice This contract contains functions to dispatch the ETH in a contract upon withdrawal.
interface IFeeDispatcher {
    /// @notice Emitted when the commission split is changed.
    /// @param recipients The addresses of recipients
    /// @param splits The percentage of each recipient in basis points
    event NewCommissionSplit(address[] recipients, uint256[] splits);

    /// @notice Emitted when the integrator withdraws ETH
    /// @param withdrawer address withdrawing the ETH
    /// @param amountWithdrawn amount of ETH withdrawn
    event CommissionWithdrawn(address indexed withdrawer, uint256 amountWithdrawn);

    /// @notice Thrown when functions are given lists of different length in batch arguments
    /// @param lengthA First argument length
    /// @param lengthB Second argument length
    error UnequalLengths(uint256 lengthA, uint256 lengthB);

    /// @notice Thrown when the recipient reverts when paid.
    /// @param recipient The recipient that reverted
    error NotPayable(address recipient);

    /// @notice Thrown when the recipient reverts when paid.
    /// @param recipient The recipient that reverted
    /// @param returnData The return data from the recipient
    error RecipientReverted(address recipient, bytes returnData);

    /// @notice Thrown when a function is called while the contract is locked
    error Reentrancy();

    /// @notice Allows the integrator to withdraw the ETH in the contract.
    function withdrawCommission() external;
}

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2024 Kiln <[email protected]>
//
// ██╗  ██╗██╗██╗     ███╗   ██╗
// ██║ ██╔╝██║██║     ████╗  ██║
// █████╔╝ ██║██║     ██╔██╗ ██║
// ██╔═██╗ ██║██║     ██║╚██╗██║
// ██║  ██╗██║███████╗██║ ╚████║
// ╚═╝  ╚═╝╚═╝╚══════╝╚═╝  ╚═══╝
//
pragma solidity 0.8.18;

import {IFixable} from "@src/interfaces/utils/IFixable.sol";
import {IvPoolSharesReceiver} from "@src/interfaces/IvPoolSharesReceiver.sol";
import {ctypes} from "@src/ctypes/ctypes.sol";

/// @title Exit Queue Interface
/// @author mortimr @ Kiln
/// @notice The exit queue stores exit requests until they are filled and claimable
interface IvExitQueue is IFixable, IvPoolSharesReceiver {
    enum ClaimStatus {
        CLAIMED,
        PARTIALLY_CLAIMED,
        SKIPPED
    }

    /// @notice Emitted when the stored Pool address is changed
    /// @param pool The new pool address
    event SetPool(address pool);

    /// @notice Emitted when the stored token uri image url is changed
    /// @param tokenUriImageUrl The new token uri image url
    event SetTokenUriImageUrl(string tokenUriImageUrl);

    /// @notice Emitted when the transfer enabled status is changed
    /// @param enabled The new transfer enabled status
    event SetTransferEnabled(bool enabled);

    /// @notice Emitted when the unclaimed funds buffer is changed
    /// @param unclaimedFunds The new unclaimed funds buffer
    event SetUnclaimedFunds(uint256 unclaimedFunds);

    /// @notice Emitted when ether was supplied to the vPool
    /// @param amount The amount of ETH supplied
    event SuppliedEther(uint256 amount);

    /// @notice Emitted when a ticket is created
    /// @param owner The address of the ticket owner
    /// @param idx The index of the ticket
    /// @param id The ID of the ticket
    /// @param ticket The ticket details
    event PrintedTicket(address indexed owner, uint32 idx, uint256 id, ctypes.Ticket ticket);

    /// @notice Emitted when a cask is created
    /// @param id The ID of the cask
    /// @param cask The cask details
    event ReceivedCask(uint32 id, ctypes.Cask cask);

    /// @notice Emitted when a ticket is claimed against a cask, can happen several times for the same ticket but different casks
    /// @param ticketId The ID of the ticket
    /// @param caskId The ID of the cask
    /// @param amountFilled The amount of shares filled
    /// @param amountEthFilled The amount of ETH filled
    /// @param unclaimedEth The amount of ETH that is added to the unclaimed buffer
    event FilledTicket(
        uint256 indexed ticketId, uint32 indexed caskId, uint128 amountFilled, uint256 amountEthFilled, uint256 unclaimedEth
    );

    /// @notice Emitted when a ticket is "reminted" and its external id is modified
    /// @param oldTicketId The old ID of the ticket
    /// @param newTicketId The new ID of the ticket
    /// @param ticketIndex The index of the ticket
    event TicketIdUpdated(uint256 indexed oldTicketId, uint256 indexed newTicketId, uint32 indexed ticketIndex);

    /// @notice Emitted when a payment is made after a user performed a claim
    /// @param recipient The address of the recipient
    /// @param amount The amount of ETH paid
    event Payment(address indexed recipient, uint256 amount);

    /// @notice Transfer of tickets is disabled
    error TransferDisabled();

    /// @notice The provided ticket ID is invalid
    /// @param id The ID of the ticket
    error InvalidTicketId(uint256 id);

    /// @notice The provided cask ID is invalid
    /// @param id The ID of the cask
    error InvalidCaskId(uint32 id);

    /// @notice The provided ticket IDs and cask IDs are not the same length
    error InvalidLengths();

    /// @notice The ticket and cask are not associated
    /// @param ticketId The ID of the ticket
    /// @param caskId The ID of the cask
    error TicketNotMatchingCask(uint256 ticketId, uint32 caskId);

    /// @notice The claim transfer failed
    /// @param recipient The address of the recipient
    /// @param rdata The revert data
    error ClaimTransferFailed(address recipient, bytes rdata);

    /// @notice Initializes the ExitQueue (proxy pattern)
    /// @param vpool The address of the associated vPool
    /// @param newTokenUriImageUrl The token uri image url
    function initialize(address vpool, string calldata newTokenUriImageUrl) external;

    /// @notice Adds eth and creates a new cask
    /// @dev only callbacle by the vPool
    /// @param shares The amount of shares to cover with the provided eth
    function feed(uint256 shares) external payable;

    /// @notice Pulls eth from the unclaimed eth buffer
    /// @dev Only callable by the vPool
    /// @param max The maximum amount of eth to pull
    function pull(uint256 max) external;

    /// @notice Claims the provided tickets against their associated casks
    /// @dev To retrieve the list of casks, an off-chain resolve call should be performed
    /// @param ticketIds The IDs of the tickets to claim
    /// @param caskIds The IDs of the casks to claim against
    /// @param maxClaimDepth The maximum recursion depth for the claim, 0 for unlimited
    function claim(uint256[] calldata ticketIds, uint32[] calldata caskIds, uint16 maxClaimDepth)
        external
        returns (ClaimStatus[] memory statuses);

    /// @notice Sets the token uri image inside the returned token uri
    /// @param newTokenUriImageUrl The new token uri image url
    function setTokenUriImageUrl(string calldata newTokenUriImageUrl) external;

    /// @notice Enables transfers
    /// @dev Transfers cannot be disabled once enabled
    function enableTransfers() external;

    /// @notice Returns the token uri image url
    /// @return The token uri image url
    function tokenUriImageUrl() external view returns (string memory);

    /// @notice Returns the address of the associated vPool
    /// @return The address of the associated vPool
    function pool() external view returns (address);

    /// @notice Returns the transfer enabled status
    /// @return True if transfers are enabled
    function transferEnabled() external view returns (bool);

    /// @notice Returns the unclaimed funds buffer
    /// @return The unclaimed funds buffer
    function unclaimedFunds() external view returns (uint256);

    /// @notice Returns the id of the ticket based on the index
    /// @param idx The index of the ticket
    function ticketIdAtIndex(uint32 idx) external view returns (uint256);

    /// @notice Returns the details about the ticket with the provided ID
    /// @param id The ID of the ticket
    /// @return The ticket details
    function ticket(uint256 id) external view returns (ctypes.Ticket memory);

    /// @notice Returns the number of tickets
    /// @return The number of tickets
    function ticketCount() external view returns (uint256);

    /// @notice Returns the details about the cask with the provided ID
    /// @param id The ID of the cask
    /// @return The cask details
    function cask(uint32 id) external view returns (ctypes.Cask memory);

    /// @notice Returns the number of casks
    /// @return The number of casks
    function caskCount() external view returns (uint256);

    /// @notice Resolves the provided tickets to their associated casks or provide resolution error codes
    /// @dev TICKET_ID_OUT_OF_BOUNDS = -1;
    ///      TICKET_ALREADY_CLAIMED = -2;
    ///      TICKET_PENDING = -3;
    /// @param ticketIds The IDs of the tickets to resolve
    /// @return caskIdsOrErrors The IDs of the casks or error codes
    function resolve(uint256[] memory ticketIds) external view returns (int64[] memory caskIdsOrErrors);
}

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2024 Kiln <[email protected]>
//
// ██╗  ██╗██╗██╗     ███╗   ██╗
// ██║ ██╔╝██║██║     ████╗  ██║
// █████╔╝ ██║██║     ██╔██╗ ██║
// ██╔═██╗ ██║██║     ██║╚██╗██║
// ██║  ██╗██║███████╗██║ ╚████║
// ╚═╝  ╚═╝╚═╝╚══════╝╚═╝  ╚═══╝
//
pragma solidity 0.8.18;

/// @title Fixable Interface
/// @author mortimr @ Kiln
/// @dev Unstructured Storage Friendly
/// @notice The Fixable contract can be used on cubs to expose a safe noop to force a fix.
interface IFixable {
    /// @notice Noop method to force a global fix to be applied.
    function fix() external;
}

// SPDX-License-Identifier: MIT
// SPDX-FileCopyrightText: 2024 Kiln <[email protected]>
//
// ██╗  ██╗██╗██╗     ███╗   ██╗
// ██║ ██╔╝██║██║     ████╗  ██║
// █████╔╝ ██║██║     ██╔██╗ ██║
// ██╔═██╗ ██║██║     ██║╚██╗██║
// ██║  ██╗██║███████╗██║ ╚████║
// ╚═╝  ╚═╝╚═╝╚══════╝╚═╝  ╚═══╝
//
pragma solidity 0.8.18;

/// @title Pool Shares Receiver Interface
/// @author mortimr @ Kiln
/// @notice Interface that needs to be implemented for a contract to be able to receive shares
interface IvPoolSharesReceiver {
    /// @notice Callback used by the vPool to notify contracts of shares being transferred
    /// @param operator The address of the operator of the transfer
    /// @param from The address sending the funds
    /// @param amount The amount of shares received
    /// @param data The attached data
    /// @return selector Should return its own selector if everything went well
    function onvPoolSharesReceived(address operator, address from, uint256 amount, bytes memory data) external returns (bytes4 selector);
}

// SPDX-License-Identifier: BUSL-1.1
// SPDX-FileCopyrightText: 2024 Kiln <[email protected]>
//
// ██╗  ██╗██╗██╗     ███╗   ██╗
// ██║ ██╔╝██║██║     ████╗  ██║
// █████╔╝ ██║██║     ██╔██╗ ██║
// ██╔═██╗ ██║██║     ██║╚██╗██║
// ██║  ██╗██║███████╗██║ ╚████║
// ╚═╝  ╚═╝╚═╝╚══════╝╚═╝  ╚═══╝
//
pragma solidity 0.8.18;

/// @title Custom Types
library ctypes {
    /// @notice Structure representing the validation key registry
    /// @dev The keys are stored inside a Merkle Tree whose root is stored in the contracts
    /// @dev Alonside the root, the ipfs hash of the complete Merkle Tree is also stored
    /// @dev The tree format is composed of the concatenation of [publicKey + signature + withdrawalChannel]
    ///      separated by a newline
    /// @param root The root of the Merkle Tree
    /// @param ipfsHash The ipfs hash of the Merkle Tree content
    struct ValidationKeyRegistry {
        bytes32 root;
        string ipfsHash;
    }

    /// @notice Structure representing a deposit in the factory
    /// @param dedicatedRecipient The dedicated recipient contract of the validator. Only defined for validators of channel zero
    /// @param owner The owner of the deposited validator
    /// @param feeRecipient The fee recipient of the validator
    /// @param thresholdGwei The threshold of the deposit in gwei
    struct Deposit {
        address dedicatedRecipient;
        address owner;
        address feeRecipient;
        uint96 thresholdGwei;
    }

    /// @notice Structure representing the operator metadata in the factory
    /// @param name The name of the operator
    /// @param url The url of the operator
    /// @param iconUrl The icon url of the operator
    struct Metadata {
        string name;
        string url;
        string iconUrl;
    }

    /// @notice Structure representing the global consensus layer spec held in the global consensus layer spec holder
    /// @param genesisTimestamp The timestamp of the genesis of the consensus layer (slot 0 timestamp)
    /// @param epochsUntilFinal The number of epochs until a block is considered final by the vsuite
    /// @param slotsPerEpoch The number of slots per epoch (32 on mainnet)
    /// @param secondsPerSlot The number of seconds per slot (12 on mainnet)
    struct ConsensusLayerSpec {
        uint64 genesisTimestamp;
        uint64 epochsUntilFinal;
        uint64 slotsPerEpoch;
        uint64 secondsPerSlot;
    }

    /// @notice Structure representing the report bounds held in the pools
    /// @param maxAPRUpperBound The maximum APR upper bound, representing the maximum increase in underlying balance checked at each oracle report
    /// @param maxAPRUpperCoverageBoost The maximum APR upper coverage boost, representing the additional increase allowed when pulling coverage funds
    /// @param maxRelativeLowerBound The maximum relative lower bound, representing the maximum decrease in underlying balance checked at each oracle report
    struct ReportBounds {
        uint64 maxAPRUpperBound;
        uint64 maxAPRUpperCoverageBoost;
        uint64 maxRelativeLowerBound;
    }

    /// @notice The mode selected when constructing the vNFT contract
    /// @dev The mode defines the reward flow behavior
    /// @dev Static mode: rewards are never moved without the user triggering a withdrawal. vNFTs change their ID whenever they are claimed
    /// @dev Dynamic mode: rewards can be received automatically if enabled. vNFTs keep their ID when they are claimed. vNFTs are claimed when they are transferred
    enum vNFTMode {
        Static,
        Dynamic
    }

    /// @notice Structure representing the vNFT contract configuration
    /// @param mode The mode selected when constructing the vNFT contract
    /// @param commissionBps The commission in basis points taken by the vNFT operator
    /// @param defaultThreshold The default threshold for the vNFTs (threshold in gwei at which auto claim will happen, only in Dynamic mode)
    /// @param defaultExtraData The default extra data for the vNFTs
    /// @param metadataURIBase The base URI for the metadata of the vNFTs
    struct vNFTConfiguration {
        vNFTMode mode;
        uint16 commissionBps;
        uint96 defaultThreshold;
        string defaultExtraData;
        string metadataURIBase;
    }

    /// @notice Structure representing a vNFT validator in storage
    /// @dev Used to map the id of a token to a validator id & its exit status
    /// @param exited Whether the validator has exited
    /// @param id The validator id, given by the vFactory
    struct vNFTValidator {
        bool exited;
        uint248 id;
    }

    /// @notice Structure representing the consensus layer report submitted by oracle members
    /// @param balanceSum sum of all the balances of all validators that have been activated by the vPool
    ///        this means that as long as the validator was activated, no matter its current status, its balance is taken
    ///        into account
    ///        this value can increase and decrease based on the current state of the validators
    /// @param exitedSum sum of all the ether that has been exited by the validators that have been activated by the vPool
    ///        to compute this value, we look for withdrawal events inside the block bodies that have happened at an epoch
    ///        that is greater or equal to the withdrawable epoch of a validator purchased by the pool
    ///        when we detect any, we take min(amount,32 eth) into account as exited balance
    ///        this value can only increase over time
    /// @param skimmedSum sum of all the ether that has been skimmed by the validators that have been activated by the vPool
    ///        similar to the exitedSum, we look for withdrawal events. If the epochs is lower than the withdrawable epoch
    ///        we take into account the full withdrawal amount, otherwise we take amount - min(amount, 32 eth) into account
    ///        this value can only increase over time
    /// @param slashedSum sum of all the ether that has been slashed by the validators that have been activated by the vPool
    ///        to compute this value, we look for validators that are of have been in the slashed state
    ///        then we take the balance of the validator at the epoch prior to its slashing event
    ///        we then add the delta between this old balance and the current balance (or balance just before withdrawal)
    ///        this value can only increase over time
    /// @param exitingSum amount of currently exiting eth, that will soon hit the withdrawal recipient
    ///        this value is computed by taking the balance of any validator in the exit or slashed state or after
    ///        this value can increase and decrease based on the current state of the exiting validators
    /// @param maxExitable maximum amount that can get requested for exits during report processing
    ///        this value is determined by the oracle. its calculation logic can be updated but all members need to agree and reach
    ///        consensus on the new calculation logic. Its role is to control the rate at which exit requests are performed
    ///        setting its value to 0 will prevent requesting any validator exit and will prevent the pool from feeding the exit queue
    ///        this value can increase and decrease based on the current strategy adopted by the oracle members
    /// @param maxCommittable maximum amount that can get committed for deposits during report processing
    ///        positive value means commit happens before possible exit boosts, negative after
    ///        similar to the mexExitable, this value is determined by the oracle. its calculation logic can be updated but all
    ///        members need to agree and reach consensus on the new calculation logic. Its role is to control the rate at which
    ///        deposits are made. Committed funds are funds that are always a multiple of 32 eth and that cannot be used for
    ///        anything else than purchasing validator, as opposed to the deposited funds that can still be used to fuel the
    ///        exit queue in some cases.
    ///        this value can increase and decrease based on the current strategy adopted by the oracle members
    /// @param epoch epoch at which the report was crafter
    ///        this value can only increase over time
    /// @param activatedCount current count of validators that have been activated by the vPool
    ///        no matter the current state of the validator, if it has been activated, it has to be accounted inside this value
    ///        this value can only increase over time
    /// @param stoppedCount current count of validators that have been stopped (being in the exit queue, exited or slashed)
    ///        this value can only increase over time
    /// @param invalidActivationCount current count of validators that have been activated by the vPool but that have been
    ///        detected as invalid by the oracle members. This can happen if the signature is invalid or if there has already
    ///        been an activation for this specific public key.
    ///        this value can only increase over time
    struct ValidatorsReport {
        uint128 balanceSum;
        uint128 exitedSum;
        uint128 skimmedSum;
        uint128 slashedSum;
        uint128 exitingSum;
        uint128 maxExitable;
        int256 maxCommittable;
        uint64 epoch;
        uint32 activatedCount;
        uint32 stoppedCount;
        uint32 invalidActivationCount;
    }

    /// @notice Structure representing the ethers held in the pools
    /// @param deposited The amount of deposited ethers, that can either be used to boost exits or get committed
    /// @param committed The amount of committed ethers, that can only be used to purchase validators
    struct Ethers {
        uint128 deposited;
        uint128 committed;
    }

    /// @notice Structure representing a ticket in the exit queue
    /// @param position The position of the ticket in the exit queue (equal to the position + size of the previous ticket)
    /// @param size The size of the ticket in the exit queue (in pool shares)
    /// @param maxExitable The maximum amount of ethers that can be exited by the ticket owner (no more rewards in the exit queue, losses are still mutualized)
    struct Ticket {
        uint128 position;
        uint128 size;
        uint128 maxExitable;
    }

    /// @notice Structure representing a cask in the exit queue. This entity is created by the pool upon oracle reports, when exit liquidity is available to feed the exit queue
    /// @param position The position of the cask in the exit queue (equal to the position + size of the previous cask)
    /// @param size The size of the cask in the exit queue (in pool shares)
    /// @param value The value of the cask in the exit queue (in ethers)
    struct Cask {
        uint128 position;
        uint128 size;
        uint128 value;
    }

    // vsuite
    type ApprovalsMapping is bytes32;
    type CaskArray is bytes32;
    type ConsensusLayerSpecStruct is bytes32;
    type DepositMapping is bytes32;
    type EthersStruct is bytes32;
    type FactoryDepositorMapping is bytes32;
    type MetadataStruct is bytes32;
    type ReportBoundsStruct is bytes32;
    type TicketArray is bytes32;
    type ValidationKeyRegistryStruct is bytes32;
    type ValidatorsReportStruct is bytes32;
    type OperatorApprovalsMapping is bytes32;

    // integrations
    type BalancePerIdMapping is bytes32;
    type BalanceMapping is bytes32;
    type vNFTConfigurationStruct is bytes32;
    type vNFTValidatorMapping is bytes32;
}

{
  "remappings": [
    "@script/=script/",
    "@src/=src/",
    "@test_utils/=test/test_utils/",
    "@dependency/openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/",
    "@dependency/prb-math/=lib/prb-math/contracts/",
    "@dev-dependency/deploy.sol/=lib/deploy.sol/src/",
    "@dev-dependency/murky/=lib/utils.sol/lib/murky/src/",
    "@dev-dependency/forge-gas-snapshot/=lib/forge-gas-snapshot/src/",
    "@dev-dependency/forge-std/=lib/forge-std/src/",
    "@dev-dependency/solmate/=lib/solmate/src/",
    "@dev-dependency/vulcan/=lib/vulcan/src/",
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "deploy.sol/=lib/deploy.sol/",
    "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    "forge-gas-snapshot/=lib/forge-gas-snapshot/src/",
    "forge-std/=lib/forge-std/src/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/",
    "prb-math/=lib/prb-math/contracts/",
    "solmate/=lib/solmate/src/",
    "vulcan/=lib/vulcan/src/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "evmVersion": "paris",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"lengthA","type":"uint256"},{"internalType":"uint256","name":"lengthB","type":"uint256"}],"name":"UnequalLengths","type":"error"},{"inputs":[{"internalType":"address[]","name":"exitQueues","type":"address[]"},{"internalType":"uint256[][]","name":"ticketIds","type":"uint256[][]"},{"internalType":"uint32[][]","name":"casksIds","type":"uint32[][]"}],"name":"multiClaim","outputs":[{"internalType":"enum IvExitQueue.ClaimStatus[][]","name":"statuses","type":"uint8[][]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"exitQueues","type":"address[]"},{"internalType":"uint256[][]","name":"ticketIds","type":"uint256[][]"}],"name":"multiResolve","outputs":[{"internalType":"int64[][]","name":"caskIdsOrErrors","type":"int64[][]"}],"stateMutability":"view","type":"function"}]

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

1002:1784:1:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2072:712;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1105:919;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;2072:712::-;2221:32;2273:37;;;2269:141;;2333:66;;-1:-1:-1;;;2333:66:1;;;;;5328:25:7;;;5369:18;;;5362:34;;;5301:18;;2333:66:1;;;;;;;;2269:141;2452:10;2438:32;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2420:50;;2486:9;2481:297;2501:21;;;2481:297;;;2539:21;2575:10;;2586:1;2575:13;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;2539:50;;2676:9;-1:-1:-1;;;;;2676:17:1;;2694:9;;2704:1;2694:12;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;2676:31;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;2676:31:1;;;;;;;;;;;;:::i;:::-;2655:15;2671:1;2655:18;;;;;;;;:::i;:::-;;;;;;;;;;:52;-1:-1:-1;2750:3:1;;2481:297;;;;2072:712;;;;;;:::o;1105:919::-;1269:43;1332:37;;;1328:141;;1392:66;;-1:-1:-1;;;1392:66:1;;;;;5328:25:7;;;5369:18;;;5362:34;;;5301:18;;1392:66:1;5154:248:7;1328:141:1;1482:36;;;1478:139;;1541:65;;-1:-1:-1;;;1541:65:1;;;;;5328:25:7;;;5369:18;;;5362:34;;;5301:18;;1541:65:1;5154:248:7;1478:139:1;1670:10;1638:50;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1627:61;;1704:9;1699:319;1719:21;;;1699:319;;;1757:21;1793:10;;1804:1;1793:13;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;1757:50;;1887:9;-1:-1:-1;;;;;1887:15:1;;1903:9;;1913:1;1903:12;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;1917:8;;1926:1;1917:11;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;1930:16;1887:60;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;1887:60:1;;;;;;;;;;;;:::i;:::-;1873:8;1882:1;1873:11;;;;;;;;:::i;:::-;;;;;;;;;;:74;-1:-1:-1;1990:3:1;;1699:319;;;;1105:919;;;;;;;;:::o;14:367:7:-;77:8;87:6;141:3;134:4;126:6;122:17;118:27;108:55;;159:1;156;149:12;108:55;-1:-1:-1;182:20:7;;225:18;214:30;;211:50;;;257:1;254;247:12;211:50;294:4;286:6;282:17;270:29;;354:3;347:4;337:6;334:1;330:14;322:6;318:27;314:38;311:47;308:67;;;371:1;368;361:12;308:67;14:367;;;;;:::o;386:800::-;535:6;543;551;559;612:2;600:9;591:7;587:23;583:32;580:52;;;628:1;625;618:12;580:52;668:9;655:23;697:18;738:2;730:6;727:14;724:34;;;754:1;751;744:12;724:34;793:70;855:7;846:6;835:9;831:22;793:70;:::i;:::-;882:8;;-1:-1:-1;767:96:7;-1:-1:-1;970:2:7;955:18;;942:32;;-1:-1:-1;986:16:7;;;983:36;;;1015:1;1012;1005:12;983:36;;1054:72;1118:7;1107:8;1096:9;1092:24;1054:72;:::i;:::-;386:800;;;;-1:-1:-1;1145:8:7;-1:-1:-1;;;;386:800:7:o;1191:1303::-;1379:4;1408:2;1448;1437:9;1433:18;1478:2;1467:9;1460:21;1501:6;1536;1530:13;1567:6;1559;1552:22;1605:2;1594:9;1590:18;1583:25;;1667:2;1657:6;1654:1;1650:14;1639:9;1635:30;1631:39;1617:53;;1705:2;1697:6;1693:15;1726:1;1747;1757:708;1773:6;1768:3;1765:15;1757:708;;;1842:22;;;-1:-1:-1;;1838:36:7;1826:49;;1898:13;;1972:9;;1994:24;;;2084:11;;;;2040:15;;;;2119:1;2133:224;2149:8;2144:3;2141:17;2133:224;;;2240:15;;2237:1;2226:30;2212:45;;2326:17;;;;2283:14;;;;2177:1;2168:11;2133:224;;;-1:-1:-1;2380:5:7;;-1:-1:-1;;;2443:12:7;;;;2408:15;;;;1799:1;1790:11;1757:708;;;-1:-1:-1;2482:6:7;;1191:1303;-1:-1:-1;;;;;;;;1191:1303:7:o;2499:1141::-;2710:6;2718;2726;2734;2742;2750;2803:2;2791:9;2782:7;2778:23;2774:32;2771:52;;;2819:1;2816;2809:12;2771:52;2859:9;2846:23;2888:18;2929:2;2921:6;2918:14;2915:34;;;2945:1;2942;2935:12;2915:34;2984:70;3046:7;3037:6;3026:9;3022:22;2984:70;:::i;:::-;3073:8;;-1:-1:-1;2958:96:7;-1:-1:-1;3161:2:7;3146:18;;3133:32;;-1:-1:-1;3177:16:7;;;3174:36;;;3206:1;3203;3196:12;3174:36;3245:72;3309:7;3298:8;3287:9;3283:24;3245:72;:::i;:::-;3336:8;;-1:-1:-1;3219:98:7;-1:-1:-1;3424:2:7;3409:18;;3396:32;;-1:-1:-1;3440:16:7;;;3437:36;;;3469:1;3466;3459:12;3437:36;;3508:72;3572:7;3561:8;3550:9;3546:24;3508:72;:::i;:::-;2499:1141;;;;-1:-1:-1;2499:1141:7;;-1:-1:-1;2499:1141:7;;3599:8;;2499:1141;-1:-1:-1;;;2499:1141:7:o;3645:1504::-;3850:4;3879:2;3919;3908:9;3904:18;3949:2;3938:9;3931:21;3972:6;4007;4001:13;4038:6;4030;4023:22;4076:2;4065:9;4061:18;4054:25;;4138:2;4128:6;4125:1;4121:14;4110:9;4106:30;4102:39;4088:53;;4176:2;4168:6;4164:15;4197:1;4207:913;4221:6;4218:1;4215:13;4207:913;;;4286:22;;;-1:-1:-1;;4282:36:7;4270:49;;4342:13;;4416:9;;4438:24;;;4528:11;;;;4484:15;;;;4563:1;4577:435;4593:8;4588:3;4585:17;4577:435;;;4672:8;4666:15;4715:1;4711:2;4708:9;4698:180;;4776:10;4771:3;4767:20;4764:1;4757:31;4819:4;4816:1;4809:15;4855:4;4852:1;4845:15;4698:180;4895:17;;4981;;;;4938:14;;;;4621:1;4612:11;4577:435;;;-1:-1:-1;5035:5:7;;-1:-1:-1;;;5098:12:7;;;;5063:15;;;;4243:1;4236:9;4207:913;;;-1:-1:-1;5137:6:7;;3645:1504;-1:-1:-1;;;;;;;3645:1504:7:o;5407:127::-;5468:10;5463:3;5459:20;5456:1;5449:31;5499:4;5496:1;5489:15;5523:4;5520:1;5513:15;5539:127;5600:10;5595:3;5591:20;5588:1;5581:31;5631:4;5628:1;5621:15;5655:4;5652:1;5645:15;5671:286;5730:6;5783:2;5771:9;5762:7;5758:23;5754:32;5751:52;;;5799:1;5796;5789:12;5751:52;5825:23;;-1:-1:-1;;;;;5877:31:7;;5867:42;;5857:70;;5923:1;5920;5913:12;5857:70;5946:5;5671:286;-1:-1:-1;;;5671:286:7:o;5962:545::-;6055:4;6061:6;6121:11;6108:25;6215:2;6211:7;6200:8;6184:14;6180:29;6176:43;6156:18;6152:68;6142:96;;6234:1;6231;6224:12;6142:96;6261:33;;6313:20;;;-1:-1:-1;6356:18:7;6345:30;;6342:50;;;6388:1;6385;6378:12;6342:50;6421:4;6409:17;;-1:-1:-1;6472:1:7;6468:14;;;6452;6448:35;6438:46;;6435:66;;;6497:1;6494;6487:12;6512:311;6600:19;;;6582:3;-1:-1:-1;;;;;6631:31:7;;6628:51;;;6675:1;6672;6665:12;6628:51;6711:6;6708:1;6704:14;6763:8;6756:5;6749:4;6744:3;6740:14;6727:45;6792:18;;;;6812:4;6788:29;;6512:311;-1:-1:-1;;;6512:311:7:o;6828:288::-;7017:2;7006:9;6999:21;6980:4;7037:73;7106:2;7095:9;7091:18;7083:6;7075;7037:73;:::i;:::-;7029:81;6828:288;-1:-1:-1;;;;6828:288:7:o;7121:275::-;7192:2;7186:9;7257:2;7238:13;;-1:-1:-1;;7234:27:7;7222:40;;7292:18;7277:34;;7313:22;;;7274:62;7271:88;;;7339:18;;:::i;:::-;7375:2;7368:22;7121:275;;-1:-1:-1;7121:275:7:o;7401:181::-;7459:4;7492:18;7484:6;7481:30;7478:56;;;7514:18;;:::i;:::-;-1:-1:-1;7559:1:7;7555:14;7571:4;7551:25;;7401:181::o;7587:1050::-;7680:6;7711:2;7754;7742:9;7733:7;7729:23;7725:32;7722:52;;;7770:1;7767;7760:12;7722:52;7803:9;7797:16;7836:18;7828:6;7825:30;7822:50;;;7868:1;7865;7858:12;7822:50;7891:22;;7944:4;7936:13;;7932:27;-1:-1:-1;7922:55:7;;7973:1;7970;7963:12;7922:55;8002:2;7996:9;8025:58;8041:41;8079:2;8041:41;:::i;:::-;8025:58;:::i;:::-;8117:15;;;8199:1;8195:10;;;;8187:19;;8183:28;;;8148:12;;;;8223:19;;;8220:39;;;8255:1;8252;8245:12;8220:39;8279:11;;;;8299:308;8315:6;8310:3;8307:15;8299:308;;;8388:3;8382:10;8439:5;8436:1;8425:20;8418:5;8415:31;8405:129;;8488:1;8517:2;8513;8506:14;8405:129;8547:18;;8332:12;;;;8585;;;;8299:308;;;8626:5;7587:1050;-1:-1:-1;;;;;;;7587:1050:7:o;9191:1037::-;9492:2;9481:9;9474:21;9455:4;9518:73;9587:2;9576:9;9572:18;9564:6;9556;9518:73;:::i;:::-;9648:22;;;9610:2;9628:18;;;9621:50;;;;9706:22;;;9782:6;;9744:15;;9806:1;;9837:309;9853:6;9848:3;9845:15;9837:309;;;9932:6;9919:20;9973:10;9966:5;9962:22;10017:2;10010:5;10007:13;9997:41;;10034:1;10031;10024:12;9997:41;10051:15;;-1:-1:-1;10121:15:7;;;;10086:12;;;;9879:1;9870:11;9837:309;;;9841:3;;10163;10155:11;;;;;10214:6;10206;10202:19;10197:2;10186:9;10182:18;10175:47;9191:1037;;;;;;;;:::o;10233:1048::-;10343:6;10374:2;10417;10405:9;10396:7;10392:23;10388:32;10385:52;;;10433:1;10430;10423:12;10385:52;10466:9;10460:16;10499:18;10491:6;10488:30;10485:50;;;10531:1;10528;10521:12;10485:50;10554:22;;10607:4;10599:13;;10595:27;-1:-1:-1;10585:55:7;;10636:1;10633;10626:12;10585:55;10665:2;10659:9;10688:58;10704:41;10742:2;10704:41;:::i;10688:58::-;10780:15;;;10862:1;10858:10;;;;10850:19;;10846:28;;;10811:12;;;;10886:19;;;10883:39;;;10918:1;10915;10908:12;10883:39;10942:11;;;;10962:289;10978:6;10973:3;10970:15;10962:289;;;11051:3;11045:10;11088:1;11081:5;11078:12;11068:110;;11132:1;11161:2;11157;11150:14;11068:110;11191:18;;10995:12;;;;11229;;;;10962:289;

ipfs://dd88ea472c488ea16f9eceba1b34236d8dcd309ef67edfc6f4bf0d6d77e5d87e