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: AGPL-3.0-only
pragma solidity ^0.8.26;

import {IERC20} from "@openzeppelin/contracts/interfaces/IERC20.sol";
import {
    IStargate, OFTReceipt, MessagingFee, SendParam
} from "@stargatefinance/stg-evm-v2/src/interfaces/IStargate.sol";

/**
 * @notice Middleware designed to call a Stargate contract and bridge tokens using any balance on
 * this contract instead of a fixed amount
 */
contract StargateBridgeSweep {
    error BalanceZero();
    error QuoteAmountTooLow();
    error TransferFailed();

    struct BridgeParams {
        address recipient;
        bytes32 recipientPadded; // Recipient address padded to 32 bytes
        uint32 dstEid;
        bytes extraOptions;
        bytes composeMsg;
        bytes oftCmd; // 0x0 for taxi, 0x1 for bus
    }

    uint256 constant MAX_INT = 2 ** 256 - 1;

    bool internal constant payInLzToken = false;

    /**
     * @notice Call any ERC20 and approve all balance to the recipient. Needed to allow
     * endpointContract to pull the tokens.
     * @dev Do NOT keep balance on this contract between transactions as they can be taken by anyone
     * @param token The token
     * @param spender The spender
     * @return bool if succeeded
     */
    function approveAll(address token, address spender) external returns (bool) {
        // Approve infinite balance to router
        return IERC20(token).approve(address(spender), MAX_INT);
    }

    /**
     * @notice Get stargate bridging quote for sending tokens
     * @param pool the Stargate pool to quote the fee from
     * @param sendParam the OFT parameters for sending tokens
     * @return nativeFee the native fee required to send the tokens
     * @return minAmountLD the minimum amount of token to be received on the destination chain
     */
    function getQuote(IStargate pool, SendParam memory sendParam)
        internal
        view
        returns (uint256 nativeFee, uint256 minAmountLD)
    {
        (,, OFTReceipt memory receipt) = pool.quoteOFT(sendParam);

        if (receipt.amountReceivedLD == 0) revert QuoteAmountTooLow();

        minAmountLD = receipt.amountReceivedLD;
        sendParam.minAmountLD = minAmountLD;

        MessagingFee memory messagingFee = pool.quoteSend(sendParam, payInLzToken);

        nativeFee = messagingFee.nativeFee;
    }

    /**
     * @notice Bridge ETH balance of this sweeper with Stargate.
     * Gets a quote for the entiree balance, and requotes to account for fee. Any leftover balance
     * is refunded to the recipient.
     * @dev Contract balance MUST be > 0 to work. Do NOT keep balance on this contract between
     * transactions as it can be taken by anyone.
     * @param to The Stargate native pool contract
     * @param bridgeParams The parameters from decoding the quote bridge step `data` field
     */
    function bridgeAllETH(address payable to, BridgeParams calldata bridgeParams) external {
        uint256 balance = address(this).balance;
        if (balance == 0) revert BalanceZero();

        IStargate pool = IStargate(to);

        SendParam memory sendParam = SendParam({
            dstEid: bridgeParams.dstEid,
            to: bridgeParams.recipientPadded,
            amountLD: balance,
            minAmountLD: balance,
            extraOptions: bridgeParams.extraOptions,
            composeMsg: bridgeParams.composeMsg,
            oftCmd: bridgeParams.oftCmd
        });

        (uint256 nativeFeeFullAmount,) = getQuote(pool, sendParam);

        uint256 amountFeeRemoved = balance - nativeFeeFullAmount;

        sendParam.amountLD = amountFeeRemoved;
        sendParam.minAmountLD = amountFeeRemoved;

        (uint256 nativeFee, uint256 minAmountLDFeeRemoved) = getQuote(pool, sendParam);

        sendParam.minAmountLD = minAmountLDFeeRemoved;

        MessagingFee memory fee = MessagingFee({nativeFee: nativeFee, lzTokenFee: 0});

        pool.sendToken{value: balance}({_sendParam: sendParam, _fee: fee, _refundAddress: bridgeParams.recipient});

        // Refund user with any excess native tokens
        uint256 leftoverBalance = address(this).balance;
        if (leftoverBalance > 0) {
            payable(bridgeParams.recipient).transfer(leftoverBalance);
        }
    }

    /**
     * @notice Bridge a token balance of this sweeper with Stargate
     * @dev Contract `inputToken` balance MUST be > 0 to work. Do NOT keep balance on this contract
     * between transactions as it can be taken by anyone
     * @param to The Stargate token pool contract
     */
    function bridgeAllToken(address payable to, address inputToken, BridgeParams calldata bridgeParams)
        external
        payable
    {
        uint256 balance = IERC20(inputToken).balanceOf(address(this));
        if (balance == 0) revert BalanceZero();

        IStargate pool = IStargate(to);

        SendParam memory sendParam = SendParam({
            dstEid: bridgeParams.dstEid,
            to: bridgeParams.recipientPadded,
            amountLD: balance,
            minAmountLD: balance,
            extraOptions: bridgeParams.extraOptions,
            composeMsg: bridgeParams.composeMsg,
            oftCmd: bridgeParams.oftCmd
        });

        (uint256 nativeFee, uint256 minAmountLd) = getQuote(pool, sendParam);

        sendParam.minAmountLD = minAmountLd;

        MessagingFee memory fee = MessagingFee({nativeFee: nativeFee, lzTokenFee: 0});

        pool.sendToken{value: nativeFee}({_sendParam: sendParam, _fee: fee, _refundAddress: bridgeParams.recipient});
    }

    receive() external payable {}
}

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

pragma solidity ^0.8.20;

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

// SPDX-License-Identifier: BUSL-1.1
pragma solidity ^0.8.0;

// Solidity does not support splitting import across multiple lines
// solhint-disable-next-line max-line-length
import { IOFT, SendParam, MessagingFee, MessagingReceipt, OFTReceipt } from "@layerzerolabs/lz-evm-oapp-v2/contracts/oft/interfaces/IOFT.sol";

/// @notice Stargate implementation type.
enum StargateType {
    Pool,
    OFT
}

/// @notice Ticket data for bus ride.
struct Ticket {
    uint72 ticketId;
    bytes passengerBytes;
}

/// @title Interface for Stargate.
/// @notice Defines an API for sending tokens to destination chains.
interface IStargate is IOFT {
    /// @dev This function is same as `send` in OFT interface but returns the ticket data if in the bus ride mode,
    /// which allows the caller to ride and drive the bus in the same transaction.
    function sendToken(
        SendParam calldata _sendParam,
        MessagingFee calldata _fee,
        address _refundAddress
    ) external payable returns (MessagingReceipt memory msgReceipt, OFTReceipt memory oftReceipt, Ticket memory ticket);

    /// @notice Returns the Stargate implementation type.
    function stargateType() external pure returns (StargateType);
}

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

pragma solidity ^0.8.20;

/**
 * @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

pragma solidity ^0.8.20;

import { MessagingReceipt, MessagingFee } from "../../oapp/OAppSender.sol";

/**
 * @dev Struct representing token parameters for the OFT send() operation.
 */
struct SendParam {
    uint32 dstEid; // Destination endpoint ID.
    bytes32 to; // Recipient address.
    uint256 amountLD; // Amount to send in local decimals.
    uint256 minAmountLD; // Minimum amount to send in local decimals.
    bytes extraOptions; // Additional options supplied by the caller to be used in the LayerZero message.
    bytes composeMsg; // The composed message for the send() operation.
    bytes oftCmd; // The OFT command to be executed, unused in default OFT implementations.
}

/**
 * @dev Struct representing OFT limit information.
 * @dev These amounts can change dynamically and are up the the specific oft implementation.
 */
struct OFTLimit {
    uint256 minAmountLD; // Minimum amount in local decimals that can be sent to the recipient.
    uint256 maxAmountLD; // Maximum amount in local decimals that can be sent to the recipient.
}

/**
 * @dev Struct representing OFT receipt information.
 */
struct OFTReceipt {
    uint256 amountSentLD; // Amount of tokens ACTUALLY debited from the sender in local decimals.
    // @dev In non-default implementations, the amountReceivedLD COULD differ from this value.
    uint256 amountReceivedLD; // Amount of tokens to be received on the remote side.
}

/**
 * @dev Struct representing OFT fee details.
 * @dev Future proof mechanism to provide a standardized way to communicate fees to things like a UI.
 */
struct OFTFeeDetail {
    int256 feeAmountLD; // Amount of the fee in local decimals.
    string description; // Description of the fee.
}

/**
 * @title IOFT
 * @dev Interface for the OftChain (OFT) token.
 * @dev Does not inherit ERC20 to accommodate usage by OFTAdapter as well.
 * @dev This specific interface ID is '0x02e49c2c'.
 */
interface IOFT {
    // Custom error messages
    error InvalidLocalDecimals();
    error SlippageExceeded(uint256 amountLD, uint256 minAmountLD);

    // Events
    event OFTSent(
        bytes32 indexed guid, // GUID of the OFT message.
        uint32 dstEid, // Destination Endpoint ID.
        address indexed fromAddress, // Address of the sender on the src chain.
        uint256 amountSentLD, // Amount of tokens sent in local decimals.
        uint256 amountReceivedLD // Amount of tokens received in local decimals.
    );
    event OFTReceived(
        bytes32 indexed guid, // GUID of the OFT message.
        uint32 srcEid, // Source Endpoint ID.
        address indexed toAddress, // Address of the recipient on the dst chain.
        uint256 amountReceivedLD // Amount of tokens received in local decimals.
    );

    /**
     * @notice Retrieves interfaceID and the version of the OFT.
     * @return interfaceId The interface ID.
     * @return version The version.
     *
     * @dev interfaceId: This specific interface ID is '0x02e49c2c'.
     * @dev version: Indicates a cross-chain compatible msg encoding with other OFTs.
     * @dev If a new feature is added to the OFT cross-chain msg encoding, the version will be incremented.
     * ie. localOFT version(x,1) CAN send messages to remoteOFT version(x,1)
     */
    function oftVersion() external view returns (bytes4 interfaceId, uint64 version);

    /**
     * @notice Retrieves the address of the token associated with the OFT.
     * @return token The address of the ERC20 token implementation.
     */
    function token() external view returns (address);

    /**
     * @notice Indicates whether the OFT contract requires approval of the 'token()' to send.
     * @return requiresApproval Needs approval of the underlying token implementation.
     *
     * @dev Allows things like wallet implementers to determine integration requirements,
     * without understanding the underlying token implementation.
     */
    function approvalRequired() external view returns (bool);

    /**
     * @notice Retrieves the shared decimals of the OFT.
     * @return sharedDecimals The shared decimals of the OFT.
     */
    function sharedDecimals() external view returns (uint8);

    /**
     * @notice Provides a quote for OFT-related operations.
     * @param _sendParam The parameters for the send operation.
     * @return limit The OFT limit information.
     * @return oftFeeDetails The details of OFT fees.
     * @return receipt The OFT receipt information.
     */
    function quoteOFT(
        SendParam calldata _sendParam
    ) external view returns (OFTLimit memory, OFTFeeDetail[] memory oftFeeDetails, OFTReceipt memory);

    /**
     * @notice Provides a quote for the send() operation.
     * @param _sendParam The parameters for the send() operation.
     * @param _payInLzToken Flag indicating whether the caller is paying in the LZ token.
     * @return fee The calculated LayerZero messaging fee from the send() operation.
     *
     * @dev MessagingFee: LayerZero msg fee
     *  - nativeFee: The native fee.
     *  - lzTokenFee: The lzToken fee.
     */
    function quoteSend(SendParam calldata _sendParam, bool _payInLzToken) external view returns (MessagingFee memory);

    /**
     * @notice Executes the send() operation.
     * @param _sendParam The parameters for the send operation.
     * @param _fee The fee information supplied by the caller.
     *      - nativeFee: The native fee.
     *      - lzTokenFee: The lzToken fee.
     * @param _refundAddress The address to receive any excess funds from fees etc. on the src.
     * @return receipt The LayerZero messaging receipt from the send() operation.
     * @return oftReceipt The OFT receipt information.
     *
     * @dev MessagingReceipt: LayerZero msg receipt
     *  - guid: The unique identifier for the sent message.
     *  - nonce: The nonce of the sent message.
     *  - fee: The LayerZero fee incurred for the message.
     */
    function send(
        SendParam calldata _sendParam,
        MessagingFee calldata _fee,
        address _refundAddress
    ) external payable returns (MessagingReceipt memory, OFTReceipt memory);
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import { SafeERC20, IERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import { MessagingParams, MessagingFee, MessagingReceipt } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";
import { OAppCore } from "./OAppCore.sol";

/**
 * @title OAppSender
 * @dev Abstract contract implementing the OAppSender functionality for sending messages to a LayerZero endpoint.
 */
abstract contract OAppSender is OAppCore {
    using SafeERC20 for IERC20;

    // Custom error messages
    error NotEnoughNative(uint256 msgValue);
    error LzTokenUnavailable();

    // @dev The version of the OAppSender implementation.
    // @dev Version is bumped when changes are made to this contract.
    uint64 internal constant SENDER_VERSION = 1;

    /**
     * @notice Retrieves the OApp version information.
     * @return senderVersion The version of the OAppSender.sol contract.
     * @return receiverVersion The version of the OAppReceiver.sol contract.
     *
     * @dev Providing 0 as the default for OAppReceiver version. Indicates that the OAppReceiver is not implemented.
     * ie. this is a SEND only OApp.
     * @dev If the OApp uses both OAppSender and OAppReceiver, then this needs to be override returning the correct versions
     */
    function oAppVersion() public view virtual returns (uint64 senderVersion, uint64 receiverVersion) {
        return (SENDER_VERSION, 0);
    }

    /**
     * @dev Internal function to interact with the LayerZero EndpointV2.quote() for fee calculation.
     * @param _dstEid The destination endpoint ID.
     * @param _message The message payload.
     * @param _options Additional options for the message.
     * @param _payInLzToken Flag indicating whether to pay the fee in LZ tokens.
     * @return fee The calculated MessagingFee for the message.
     *      - nativeFee: The native fee for the message.
     *      - lzTokenFee: The LZ token fee for the message.
     */
    function _quote(
        uint32 _dstEid,
        bytes memory _message,
        bytes memory _options,
        bool _payInLzToken
    ) internal view virtual returns (MessagingFee memory fee) {
        return
            endpoint.quote(
                MessagingParams(_dstEid, _getPeerOrRevert(_dstEid), _message, _options, _payInLzToken),
                address(this)
            );
    }

    /**
     * @dev Internal function to interact with the LayerZero EndpointV2.send() for sending a message.
     * @param _dstEid The destination endpoint ID.
     * @param _message The message payload.
     * @param _options Additional options for the message.
     * @param _fee The calculated LayerZero fee for the message.
     *      - nativeFee: The native fee.
     *      - lzTokenFee: The lzToken fee.
     * @param _refundAddress The address to receive any excess fee values sent to the endpoint.
     * @return receipt The receipt for the sent message.
     *      - guid: The unique identifier for the sent message.
     *      - nonce: The nonce of the sent message.
     *      - fee: The LayerZero fee incurred for the message.
     */
    function _lzSend(
        uint32 _dstEid,
        bytes memory _message,
        bytes memory _options,
        MessagingFee memory _fee,
        address _refundAddress
    ) internal virtual returns (MessagingReceipt memory receipt) {
        // @dev Push corresponding fees to the endpoint, any excess is sent back to the _refundAddress from the endpoint.
        uint256 messageValue = _payNative(_fee.nativeFee);
        if (_fee.lzTokenFee > 0) _payLzToken(_fee.lzTokenFee);

        return
            // solhint-disable-next-line check-send-result
            endpoint.send{ value: messageValue }(
                MessagingParams(_dstEid, _getPeerOrRevert(_dstEid), _message, _options, _fee.lzTokenFee > 0),
                _refundAddress
            );
    }

    /**
     * @dev Internal function to pay the native fee associated with the message.
     * @param _nativeFee The native fee to be paid.
     * @return nativeFee The amount of native currency paid.
     *
     * @dev If the OApp needs to initiate MULTIPLE LayerZero messages in a single transaction,
     * this will need to be overridden because msg.value would contain multiple lzFees.
     * @dev Should be overridden in the event the LayerZero endpoint requires a different native currency.
     * @dev Some EVMs use an ERC20 as a method for paying transactions/gasFees.
     * @dev The endpoint is EITHER/OR, ie. it will NOT support both types of native payment at a time.
     */
    function _payNative(uint256 _nativeFee) internal virtual returns (uint256 nativeFee) {
        if (msg.value != _nativeFee) revert NotEnoughNative(msg.value);
        return _nativeFee;
    }

    /**
     * @dev Internal function to pay the LZ token fee associated with the message.
     * @param _lzTokenFee The LZ token fee to be paid.
     *
     * @dev If the caller is trying to pay in the specified lzToken, then the lzTokenFee is passed to the endpoint.
     * @dev Any excess sent, is passed back to the specified _refundAddress in the _lzSend().
     */
    function _payLzToken(uint256 _lzTokenFee) internal virtual {
        // @dev Cannot cache the token because it is not immutable in the endpoint.
        address lzToken = endpoint.lzToken();
        if (lzToken == address(0)) revert LzTokenUnavailable();

        // Pay LZ token fee by sending tokens to the endpoint.
        IERC20(lzToken).safeTransferFrom(msg.sender, address(endpoint), _lzTokenFee);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.2.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 {
        _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 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 _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @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 _callOptionalReturnBool(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.
     *
     * 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 {
        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 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 rely 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 rely 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}.
     * Opposedly, 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 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 {_callOptionalReturnBool} that reverts if call fails to meet the requirements.
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        uint256 returnSize;
        uint256 returnValue;
        assembly ("memory-safe") {
            let success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
            // bubble errors
            if iszero(success) {
                let ptr := mload(0x40)
                returndatacopy(ptr, 0, returndatasize())
                revert(ptr, returndatasize())
            }
            returnSize := returndatasize()
            returnValue := mload(0)
        }

        if (returnSize == 0 ? address(token).code.length == 0 : returnValue != 1) {
            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 silently catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        bool success;
        uint256 returnSize;
        uint256 returnValue;
        assembly ("memory-safe") {
            success := call(gas(), token, 0, add(data, 0x20), mload(data), 0, 0x20)
            returnSize := returndatasize()
            returnValue := mload(0)
        }
        return success && (returnSize == 0 ? address(token).code.length > 0 : returnValue == 1);
    }
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0;

import { IMessageLibManager } from "./IMessageLibManager.sol";
import { IMessagingComposer } from "./IMessagingComposer.sol";
import { IMessagingChannel } from "./IMessagingChannel.sol";
import { IMessagingContext } from "./IMessagingContext.sol";

struct MessagingParams {
    uint32 dstEid;
    bytes32 receiver;
    bytes message;
    bytes options;
    bool payInLzToken;
}

struct MessagingReceipt {
    bytes32 guid;
    uint64 nonce;
    MessagingFee fee;
}

struct MessagingFee {
    uint256 nativeFee;
    uint256 lzTokenFee;
}

struct Origin {
    uint32 srcEid;
    bytes32 sender;
    uint64 nonce;
}

interface ILayerZeroEndpointV2 is IMessageLibManager, IMessagingComposer, IMessagingChannel, IMessagingContext {
    event PacketSent(bytes encodedPayload, bytes options, address sendLibrary);

    event PacketVerified(Origin origin, address receiver, bytes32 payloadHash);

    event PacketDelivered(Origin origin, address receiver);

    event LzReceiveAlert(
        address indexed receiver,
        address indexed executor,
        Origin origin,
        bytes32 guid,
        uint256 gas,
        uint256 value,
        bytes message,
        bytes extraData,
        bytes reason
    );

    event LzTokenSet(address token);

    event DelegateSet(address sender, address delegate);

    function quote(MessagingParams calldata _params, address _sender) external view returns (MessagingFee memory);

    function send(
        MessagingParams calldata _params,
        address _refundAddress
    ) external payable returns (MessagingReceipt memory);

    function verify(Origin calldata _origin, address _receiver, bytes32 _payloadHash) external;

    function verifiable(Origin calldata _origin, address _receiver) external view returns (bool);

    function initializable(Origin calldata _origin, address _receiver) external view returns (bool);

    function lzReceive(
        Origin calldata _origin,
        address _receiver,
        bytes32 _guid,
        bytes calldata _message,
        bytes calldata _extraData
    ) external payable;

    // oapp can burn messages partially by calling this function with its own business logic if messages are verified in order
    function clear(address _oapp, Origin calldata _origin, bytes32 _guid, bytes calldata _message) external;

    function setLzToken(address _lzToken) external;

    function lzToken() external view returns (address);

    function nativeToken() external view returns (address);

    function setDelegate(address _delegate) external;
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { IOAppCore, ILayerZeroEndpointV2 } from "./interfaces/IOAppCore.sol";

/**
 * @title OAppCore
 * @dev Abstract contract implementing the IOAppCore interface with basic OApp configurations.
 */
abstract contract OAppCore is IOAppCore, Ownable {
    // The LayerZero endpoint associated with the given OApp
    ILayerZeroEndpointV2 public immutable endpoint;

    // Mapping to store peers associated with corresponding endpoints
    mapping(uint32 eid => bytes32 peer) public peers;

    /**
     * @dev Constructor to initialize the OAppCore with the provided endpoint and delegate.
     * @param _endpoint The address of the LOCAL Layer Zero endpoint.
     * @param _delegate The delegate capable of making OApp configurations inside of the endpoint.
     *
     * @dev The delegate typically should be set as the owner of the contract.
     */
    constructor(address _endpoint, address _delegate) {
        endpoint = ILayerZeroEndpointV2(_endpoint);

        if (_delegate == address(0)) revert InvalidDelegate();
        endpoint.setDelegate(_delegate);
    }

    /**
     * @notice Sets the peer address (OApp instance) for a corresponding endpoint.
     * @param _eid The endpoint ID.
     * @param _peer The address of the peer to be associated with the corresponding endpoint.
     *
     * @dev Only the owner/admin of the OApp can call this function.
     * @dev Indicates that the peer is trusted to send LayerZero messages to this OApp.
     * @dev Set this to bytes32(0) to remove the peer address.
     * @dev Peer is a bytes32 to accommodate non-evm chains.
     */
    function setPeer(uint32 _eid, bytes32 _peer) public virtual onlyOwner {
        _setPeer(_eid, _peer);
    }

    /**
     * @notice Sets the peer address (OApp instance) for a corresponding endpoint.
     * @param _eid The endpoint ID.
     * @param _peer The address of the peer to be associated with the corresponding endpoint.
     *
     * @dev Indicates that the peer is trusted to send LayerZero messages to this OApp.
     * @dev Set this to bytes32(0) to remove the peer address.
     * @dev Peer is a bytes32 to accommodate non-evm chains.
     */
    function _setPeer(uint32 _eid, bytes32 _peer) internal virtual {
        peers[_eid] = _peer;
        emit PeerSet(_eid, _peer);
    }

    /**
     * @notice Internal function to get the peer address associated with a specific endpoint; reverts if NOT set.
     * ie. the peer is set to bytes32(0).
     * @param _eid The endpoint ID.
     * @return peer The address of the peer associated with the specified endpoint.
     */
    function _getPeerOrRevert(uint32 _eid) internal view virtual returns (bytes32) {
        bytes32 peer = peers[_eid];
        if (peer == bytes32(0)) revert NoPeer(_eid);
        return peer;
    }

    /**
     * @notice Sets the delegate address for the OApp.
     * @param _delegate The address of the delegate to be set.
     *
     * @dev Only the owner/admin of the OApp can call this function.
     * @dev Provides the ability for a delegate to set configs, on behalf of the OApp, directly on the Endpoint contract.
     */
    function setDelegate(address _delegate) public onlyOwner {
        endpoint.setDelegate(_delegate);
    }
}

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

pragma solidity ^0.8.20;

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

pragma solidity >=0.8.0;

struct SetConfigParam {
    uint32 eid;
    uint32 configType;
    bytes config;
}

interface IMessageLibManager {
    struct Timeout {
        address lib;
        uint256 expiry;
    }

    event LibraryRegistered(address newLib);
    event DefaultSendLibrarySet(uint32 eid, address newLib);
    event DefaultReceiveLibrarySet(uint32 eid, address newLib);
    event DefaultReceiveLibraryTimeoutSet(uint32 eid, address oldLib, uint256 expiry);
    event SendLibrarySet(address sender, uint32 eid, address newLib);
    event ReceiveLibrarySet(address receiver, uint32 eid, address newLib);
    event ReceiveLibraryTimeoutSet(address receiver, uint32 eid, address oldLib, uint256 timeout);

    function registerLibrary(address _lib) external;

    function isRegisteredLibrary(address _lib) external view returns (bool);

    function getRegisteredLibraries() external view returns (address[] memory);

    function setDefaultSendLibrary(uint32 _eid, address _newLib) external;

    function defaultSendLibrary(uint32 _eid) external view returns (address);

    function setDefaultReceiveLibrary(uint32 _eid, address _newLib, uint256 _gracePeriod) external;

    function defaultReceiveLibrary(uint32 _eid) external view returns (address);

    function setDefaultReceiveLibraryTimeout(uint32 _eid, address _lib, uint256 _expiry) external;

    function defaultReceiveLibraryTimeout(uint32 _eid) external view returns (address lib, uint256 expiry);

    function isSupportedEid(uint32 _eid) external view returns (bool);

    function isValidReceiveLibrary(address _receiver, uint32 _eid, address _lib) external view returns (bool);

    /// ------------------- OApp interfaces -------------------
    function setSendLibrary(address _oapp, uint32 _eid, address _newLib) external;

    function getSendLibrary(address _sender, uint32 _eid) external view returns (address lib);

    function isDefaultSendLibrary(address _sender, uint32 _eid) external view returns (bool);

    function setReceiveLibrary(address _oapp, uint32 _eid, address _newLib, uint256 _gracePeriod) external;

    function getReceiveLibrary(address _receiver, uint32 _eid) external view returns (address lib, bool isDefault);

    function setReceiveLibraryTimeout(address _oapp, uint32 _eid, address _lib, uint256 _expiry) external;

    function receiveLibraryTimeout(address _receiver, uint32 _eid) external view returns (address lib, uint256 expiry);

    function setConfig(address _oapp, address _lib, SetConfigParam[] calldata _params) external;

    function getConfig(
        address _oapp,
        address _lib,
        uint32 _eid,
        uint32 _configType
    ) external view returns (bytes memory config);
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0;

interface IMessagingComposer {
    event ComposeSent(address from, address to, bytes32 guid, uint16 index, bytes message);
    event ComposeDelivered(address from, address to, bytes32 guid, uint16 index);
    event LzComposeAlert(
        address indexed from,
        address indexed to,
        address indexed executor,
        bytes32 guid,
        uint16 index,
        uint256 gas,
        uint256 value,
        bytes message,
        bytes extraData,
        bytes reason
    );

    function composeQueue(
        address _from,
        address _to,
        bytes32 _guid,
        uint16 _index
    ) external view returns (bytes32 messageHash);

    function sendCompose(address _to, bytes32 _guid, uint16 _index, bytes calldata _message) external;

    function lzCompose(
        address _from,
        address _to,
        bytes32 _guid,
        uint16 _index,
        bytes calldata _message,
        bytes calldata _extraData
    ) external payable;
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0;

interface IMessagingChannel {
    event InboundNonceSkipped(uint32 srcEid, bytes32 sender, address receiver, uint64 nonce);
    event PacketNilified(uint32 srcEid, bytes32 sender, address receiver, uint64 nonce, bytes32 payloadHash);
    event PacketBurnt(uint32 srcEid, bytes32 sender, address receiver, uint64 nonce, bytes32 payloadHash);

    function eid() external view returns (uint32);

    // this is an emergency function if a message cannot be verified for some reasons
    // required to provide _nextNonce to avoid race condition
    function skip(address _oapp, uint32 _srcEid, bytes32 _sender, uint64 _nonce) external;

    function nilify(address _oapp, uint32 _srcEid, bytes32 _sender, uint64 _nonce, bytes32 _payloadHash) external;

    function burn(address _oapp, uint32 _srcEid, bytes32 _sender, uint64 _nonce, bytes32 _payloadHash) external;

    function nextGuid(address _sender, uint32 _dstEid, bytes32 _receiver) external view returns (bytes32);

    function inboundNonce(address _receiver, uint32 _srcEid, bytes32 _sender) external view returns (uint64);

    function outboundNonce(address _sender, uint32 _dstEid, bytes32 _receiver) external view returns (uint64);

    function inboundPayloadHash(
        address _receiver,
        uint32 _srcEid,
        bytes32 _sender,
        uint64 _nonce
    ) external view returns (bytes32);

    function lazyInboundNonce(address _receiver, uint32 _srcEid, bytes32 _sender) external view returns (uint64);
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.8.0;

interface IMessagingContext {
    function isSendingMessage() external view returns (bool);

    function getSendContext() external view returns (uint32 dstEid, address sender);
}

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

pragma solidity ^0.8.20;

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

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

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

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.20;

import { ILayerZeroEndpointV2 } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroEndpointV2.sol";

/**
 * @title IOAppCore
 */
interface IOAppCore {
    // Custom error messages
    error OnlyPeer(uint32 eid, bytes32 sender);
    error NoPeer(uint32 eid);
    error InvalidEndpointCall();
    error InvalidDelegate();

    // Event emitted when a peer (OApp) is set for a corresponding endpoint
    event PeerSet(uint32 eid, bytes32 peer);

    /**
     * @notice Retrieves the OApp version information.
     * @return senderVersion The version of the OAppSender.sol contract.
     * @return receiverVersion The version of the OAppReceiver.sol contract.
     */
    function oAppVersion() external view returns (uint64 senderVersion, uint64 receiverVersion);

    /**
     * @notice Retrieves the LayerZero endpoint associated with the OApp.
     * @return iEndpoint The LayerZero endpoint as an interface.
     */
    function endpoint() external view returns (ILayerZeroEndpointV2 iEndpoint);

    /**
     * @notice Retrieves the peer (OApp) associated with a corresponding endpoint.
     * @param _eid The endpoint ID.
     * @return peer The peer address (OApp instance) associated with the corresponding endpoint.
     */
    function peers(uint32 _eid) external view returns (bytes32 peer);

    /**
     * @notice Sets the peer address (OApp instance) for a corresponding endpoint.
     * @param _eid The endpoint ID.
     * @param _peer The address of the peer to be associated with the corresponding endpoint.
     */
    function setPeer(uint32 _eid, bytes32 _peer) external;

    /**
     * @notice Sets the delegate address for the OApp Core.
     * @param _delegate The address of the delegate to be set.
     */
    function setDelegate(address _delegate) external;
}

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

pragma solidity ^0.8.20;

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

// 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.1.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @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": [
    "@uniswap/v2-core/=lib/v2-core/",
    "@uniswap/v3-core/=lib/v3-core/",
    "@uniswap/v3-periphery/=lib/v3-periphery/",
    "@uniswap/v4-core/=lib/v4-core/",
    "@uniswap/v4-periphery/=lib/v4-periphery/",
    "@uniswap/permit2/=lib/permit2/",
    "@uniswap/universal-router/=lib/universal-router/",
    "@openzeppelin/uniswap-hooks/=lib/uniswap-hooks/",
    "@hyperlane-xyz/core/=lib/hyperlane-monorepo/solidity/contracts/",
    "@interop-lib/=lib/interop-lib/src/",
    "@rhinestone/core-modules/=lib/rhinestone-core-modules/src/",
    "@zerodev/kernel/=lib/kernel/src/",
    "@stargatefinance/stg-evm-v2/=node_modules/@stargatefinance/stg-evm-v2/",
    "node_modules/@layerzerolabs/lz-evm-oapp-v2:@layerzerolabs/lz-evm-protocol-v2/=node_modules/@layerzerolabs/lz-evm-protocol-v2/",
    "forge-std/=lib/forge-std/src/",
    "solmate/=lib/permit2/lib/solmate/",
    "permit2/=lib/permit2/",
    "lib/uniswap-hooks:v4-periphery/=lib/v4-periphery/",
    "lib/uniswap-hooks:v4-core/=lib/v4-core/",
    "lib/hyperlane-monorepo/:@arbitrum/=node_modules/@arbitrum/",
    "lib/hyperlane-monorepo/:@eth-optimism/=node_modules/@eth-optimism/",
    "lib/hyperlane-monorepo/:@layerzerolabs/=node_modules/@layerzerolabs/",
    "lib/hyperlane-monorepo/:@openzeppelin/=node_modules/@openzeppelin/",
    "lib/hyperlane-monorepo/:@openzeppelin/contracts/=node_modules/@openzeppelin/contracts/",
    "lib/hyperlane-monorepo/:ds-test/=lib/hyperlane-monorepo/solidity/lib/forge-std/lib/ds-test/src/",
    "lib/hyperlane-monorepo/:forge-std/=lib/hyperlane-monorepo/solidity/lib/forge-std/src/",
    "lib/hyperlane-monorepo/:fx-portal/=lib/hyperlane-monorepo/solidity/lib/fx-portal/",
    "lib/rhinestone-core-modules/:@rhinestone/=lib/rhinestone-core-modules/node_modules/@rhinestone/",
    "sentinellist/=lib/rhinestone-core-modules/node_modules/@rhinestone/sentinellist/src/",
    "lib/rhinestone-core-modules/:erc4337-validation/=lib/rhinestone-core-modules/node_modules/@rhinestone/erc4337-validation/src/",
    "modulekit/=lib/rhinestone-core-modules/node_modules/@rhinestone/modulekit/src/",
    "lib/rhinestone-core-modules/:checknsignatures/=lib/rhinestone-core-modules/node_modules/@rhinestone/checknsignatures/src/",
    "lib/rhinestone-core-modules/:flatbytes/=lib/rhinestone-core-modules/node_modules/@rhinestone/flatbytes/src/",
    "@ERC4337/=lib/rhinestone-core-modules/node_modules/@ERC4337/",
    "lib/rhinestone-core-modules/:account-abstraction/=lib/rhinestone-core-modules/node_modules/@ERC4337/account-abstraction/contracts/",
    "lib/rhinestone-core-modules/:account-abstraction-v0.6/=lib/rhinestone-core-modules/node_modules/@ERC4337/account-abstraction-v0.6/contracts/",
    "lib/rhinestone-core-modules/:@openzeppelin/=lib/rhinestone-core-modules/node_modules/@openzeppelin/",
    "lib/rhinestone-core-modules/:@safe-global/=lib/rhinestone-core-modules/node_modules/@safe-global/",
    "lib/rhinestone-core-modules/:ds-test/=lib/rhinestone-core-modules/node_modules/ds-test/src/",
    "lib/rhinestone-core-modules/:solady/=lib/rhinestone-core-modules/node_modules/solady/src/",
    "lib/rhinestone-core-modules/:solarray/=lib/rhinestone-core-modules/node_modules/solarray/src/",
    "lib/rhinestone-core-modules/:@prb/math/=lib/rhinestone-core-modules/node_modules/@prb/math/src/",
    "lib/rhinestone-core-modules/:solmate/=lib/rhinestone-core-modules/node_modules/solmate/src/",
    "lib/rhinestone-core-modules/:ExcessivelySafeCall/=lib/rhinestone-core-modules/node_modules/excessively-safe-call/src/",
    "node_modules/@stargatefinance/stg-evm-v2:@layerzerolabs/=node_modules/@layerzerolabs/",
    "@arbitrum/=lib/hyperlane-monorepo/node_modules/@arbitrum/nitro-contracts/src/",
    "@ensdomains/=lib/v4-core/node_modules/@ensdomains/",
    "@eth-optimism/=lib/hyperlane-monorepo/node_modules/@eth-optimism/contracts-bedrock/src/",
    "@ethereum-waffle/=lib/hyperlane-monorepo/node_modules/@ethereum-waffle/mock-contract/src/",
    "@gnosis.pm/=lib/rhinestone-core-modules/node_modules/@gnosis.pm/",
    "@layerzerolabs/=lib/hyperlane-monorepo/node_modules/@layerzerolabs/",
    "@offchainlabs/=lib/hyperlane-monorepo/node_modules/@offchainlabs/upgrade-executor/src/",
    "@openzeppelin-3/=lib/hyperlane-monorepo/node_modules/@openzeppelin-3/contracts/",
    "@openzeppelin-contracts/=lib/interop-lib/vendor/openzeppelin-contracts/",
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "@prb/math/=lib/rhinestone-core-modules/node_modules/@prb/math/src/",
    "@safe-global/=lib/rhinestone-core-modules/node_modules/@safe-global/",
    "@solady/=lib/interop-lib/lib/solady/src/",
    "ExcessivelySafeCall/=lib/rhinestone-core-modules/node_modules/excessively-safe-call/src/",
    "account-abstraction-v0.6/=lib/rhinestone-core-modules/node_modules/@ERC4337/account-abstraction-v0.6/contracts/",
    "account-abstraction/=lib/rhinestone-core-modules/node_modules/@ERC4337/account-abstraction/contracts/",
    "checknsignatures/=lib/rhinestone-core-modules/node_modules/@rhinestone/checknsignatures/src/",
    "ds-test/=lib/rhinestone-core-modules/node_modules/ds-test/src/",
    "erc4337-validation/=lib/rhinestone-core-modules/node_modules/@rhinestone/erc4337-validation/src/",
    "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    "erc721a/=lib/hyperlane-monorepo/node_modules/erc721a/contracts/",
    "eth-gas-reporter/=lib/hyperlane-monorepo/node_modules/eth-gas-reporter/",
    "excessively-safe-call/=lib/rhinestone-core-modules/node_modules/excessively-safe-call/",
    "flatbytes/=lib/rhinestone-core-modules/node_modules/@rhinestone/flatbytes/src/",
    "forge-gas-snapshot/=lib/permit2/lib/forge-gas-snapshot/src/",
    "fx-portal/=lib/hyperlane-monorepo/node_modules/fx-portal/contracts/",
    "halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",
    "hardhat-deploy/=lib/rhinestone-core-modules/node_modules/hardhat-deploy/",
    "hardhat/=lib/rhinestone-core-modules/node_modules/hardhat/",
    "hyperlane-monorepo/=lib/hyperlane-monorepo/",
    "interop-lib/=lib/interop-lib/",
    "kernel/=lib/kernel/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/",
    "openzeppelin/=lib/uniswap-hooks/lib/v4-core/lib/openzeppelin-contracts/contracts/",
    "rhinestone-core-modules/=lib/rhinestone-core-modules/src/",
    "solady/=lib/interop-lib/lib/solady/src/",
    "solarray/=lib/rhinestone-core-modules/node_modules/solarray/src/",
    "solidity-bytes-utils/=lib/hyperlane-monorepo/node_modules/solidity-bytes-utils/contracts/",
    "uniswap-hooks/=lib/uniswap-hooks/src/",
    "universal-router/=lib/universal-router/",
    "v2-core/=lib/v2-core/contracts/",
    "v3-core/=lib/v3-core/",
    "v3-periphery/=lib/v3-periphery/contracts/",
    "v4-core/=lib/v4-core/src/",
    "v4-periphery/=lib/v4-periphery/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "none",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "cancun",
  "viaIR": true,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"name":"BalanceZero","type":"error"},{"inputs":[],"name":"QuoteAmountTooLow","type":"error"},{"inputs":[],"name":"TransferFailed","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"approveAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"to","type":"address"},{"components":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"bytes32","name":"recipientPadded","type":"bytes32"},{"internalType":"uint32","name":"dstEid","type":"uint32"},{"internalType":"bytes","name":"extraOptions","type":"bytes"},{"internalType":"bytes","name":"composeMsg","type":"bytes"},{"internalType":"bytes","name":"oftCmd","type":"bytes"}],"internalType":"struct StargateBridgeSweep.BridgeParams","name":"bridgeParams","type":"tuple"}],"name":"bridgeAllETH","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"to","type":"address"},{"internalType":"address","name":"inputToken","type":"address"},{"components":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"bytes32","name":"recipientPadded","type":"bytes32"},{"internalType":"uint32","name":"dstEid","type":"uint32"},{"internalType":"bytes","name":"extraOptions","type":"bytes"},{"internalType":"bytes","name":"composeMsg","type":"bytes"},{"internalType":"bytes","name":"oftCmd","type":"bytes"}],"internalType":"struct StargateBridgeSweep.BridgeParams","name":"bridgeParams","type":"tuple"}],"name":"bridgeAllToken","outputs":[],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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