@layerzerolabs/protocol-v2-oapp-evm-contracts 1.2.95

package/contracts/oft/OFTCore.sol

@@ -0,0 +1,399 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import { OApp, Origin } from "../oapp/OApp.sol";
+import { OAppOptionsType3 } from "../oapp/libs/OAppOptionsType3.sol";
+import { IOAppMsgInspector } from "../oapp/interfaces/IOAppMsgInspector.sol";
+
+import { OAppPreCrimeSimulator } from "../precrime/OAppPreCrimeSimulator.sol";
+
+import { IOFT, SendParam, OFTLimit, OFTReceipt, OFTFeeDetail, MessagingReceipt, MessagingFee } from "./interfaces/IOFT.sol";
+import { OFTMsgCodec } from "./libs/OFTMsgCodec.sol";
+import { OFTComposeMsgCodec } from "./libs/OFTComposeMsgCodec.sol";
+
+/**
+ * @title OFTCore
+ * @dev Abstract contract for the OftChain (OFT) token.
+ */
+abstract contract OFTCore is IOFT, OApp, OAppPreCrimeSimulator, OAppOptionsType3 {
+    using OFTMsgCodec for bytes;
+    using OFTMsgCodec for bytes32;
+
+    // @notice Provides a conversion rate when swapping between denominations of SD and LD
+    //      - shareDecimals == SD == shared Decimals
+    //      - localDecimals == LD == local decimals
+    // @dev Considers that tokens have different decimal amounts on various chains.
+    // @dev eg.
+    //  For a token
+    //      - locally with 4 decimals --> 1.2345 => uint(12345)
+    //      - remotely with 2 decimals --> 1.23 => uint(123)
+    //      - The conversion rate would be 10 ** (4 - 2) = 100
+    //  @dev If you want to send 1.2345 -> (uint 12345), you CANNOT represent that value on the remote,
+    //  you can only display 1.23 -> uint(123).
+    //  @dev To preserve the dust that would otherwise be lost on that conversion,
+    //  we need to unify a denomination that can be represented on ALL chains inside of the OFT mesh
+    uint256 public immutable decimalConversionRate;
+
+    // @notice Msg types that are used to identify the various OFT operations.
+    // @dev This can be extended in child contracts for non-default oft operations
+    // @dev These values are used in things like combineOptions() in OAppOptionsType3.sol.
+    uint16 public constant SEND = 1;
+    uint16 public constant SEND_AND_CALL = 2;
+
+    // Address of an optional contract to inspect both 'message' and 'options'
+    address public msgInspector;
+    event MsgInspectorSet(address inspector);
+
+    /**
+     * @dev Constructor.
+     * @param _localDecimals The decimals of the token on the local chain (this chain).
+     * @param _endpoint The address of the LayerZero endpoint.
+     * @param _delegate The delegate capable of making OApp configurations inside of the endpoint.
+     */
+    constructor(uint8 _localDecimals, address _endpoint, address _delegate) OApp(_endpoint, _delegate) {
+        if (_localDecimals < sharedDecimals()) revert InvalidLocalDecimals();
+        decimalConversionRate = 10 ** (_localDecimals - sharedDecimals());
+    }
+
+    /**
+     * @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 pure virtual returns (bytes4 interfaceId, uint64 version) {
+        return (type(IOFT).interfaceId, 1);
+    }
+
+    /**
+     * @dev Retrieves the shared decimals of the OFT.
+     * @return The shared decimals of the OFT.
+     *
+     * @dev Sets an implicit cap on the amount of tokens, over uint64.max() will need some sort of outbound cap / totalSupply cap
+     * Lowest common decimal denominator between chains.
+     * Defaults to 6 decimal places to provide up to 18,446,744,073,709.551615 units (max uint64).
+     * For tokens exceeding this totalSupply(), they will need to override the sharedDecimals function with something smaller.
+     * ie. 4 sharedDecimals would be 1,844,674,407,370,955.1615
+     */
+    function sharedDecimals() public view virtual returns (uint8) {
+        return 6;
+    }
+
+    /**
+     * @dev Sets the message inspector address for the OFT.
+     * @param _msgInspector The address of the message inspector.
+     *
+     * @dev This is an optional contract that can be used to inspect both 'message' and 'options'.
+     * @dev Set it to address(0) to disable it, or set it to a contract address to enable it.
+     */
+    function setMsgInspector(address _msgInspector) public virtual onlyOwner {
+        msgInspector = _msgInspector;
+        emit MsgInspectorSet(_msgInspector);
+    }
+
+    /**
+     * @notice Provides a quote for OFT-related operations.
+     * @param _sendParam The parameters for the send operation.
+     * @return oftLimit The OFT limit information.
+     * @return oftFeeDetails The details of OFT fees.
+     * @return oftReceipt The OFT receipt information.
+     */
+    function quoteOFT(
+        SendParam calldata _sendParam
+    )
+        external
+        view
+        virtual
+        returns (OFTLimit memory oftLimit, OFTFeeDetail[] memory oftFeeDetails, OFTReceipt memory oftReceipt)
+    {
+        uint256 minAmountLD = 0; // Unused in the default implementation.
+        uint256 maxAmountLD = type(uint64).max; // Unused in the default implementation.
+        oftLimit = OFTLimit(minAmountLD, maxAmountLD);
+
+        // Unused in the default implementation; reserved for future complex fee details.
+        oftFeeDetails = new OFTFeeDetail[](0);
+
+        // @dev This is the same as the send() operation, but without the actual send.
+        // - amountSentLD is the amount in local decimals that would be sent from the sender.
+        // - amountReceivedLD is the amount in local decimals that will be credited to the recipient on the remote OFT instance.
+        // @dev The amountSentLD MIGHT not equal the amount the user actually receives. HOWEVER, the default does.
+        (uint256 amountSentLD, uint256 amountReceivedLD) = _debitView(
+            _sendParam.amountLD,
+            _sendParam.minAmountLD,
+            _sendParam.dstEid
+        );
+        oftReceipt = OFTReceipt(amountSentLD, amountReceivedLD);
+    }
+
+    /**
+     * @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 msgFee 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 virtual returns (MessagingFee memory msgFee) {
+        // @dev mock the amount to receive, this is the same operation used in the send().
+        // The quote is as similar as possible to the actual send() operation.
+        (, uint256 amountReceivedLD) = _debitView(_sendParam.amountLD, _sendParam.minAmountLD, _sendParam.dstEid);
+
+        // @dev Builds the options and OFT message to quote in the endpoint.
+        (bytes memory message, bytes memory options) = _buildMsgAndOptions(_sendParam, amountReceivedLD);
+
+        // @dev Calculates the LayerZero fee for the send() operation.
+        return _quote(_sendParam.dstEid, message, options, _payInLzToken);
+    }
+
+    /**
+     * @dev Executes the send operation.
+     * @param _sendParam The parameters for the send operation.
+     * @param _fee The calculated fee for the send() operation.
+     *      - nativeFee: The native fee.
+     *      - lzTokenFee: The lzToken fee.
+     * @param _refundAddress The address to receive any excess funds.
+     * @return msgReceipt The receipt for 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 virtual returns (MessagingReceipt memory msgReceipt, OFTReceipt memory oftReceipt) {
+        // @dev Applies the token transfers regarding this send() operation.
+        // - amountSentLD is the amount in local decimals that was ACTUALLY sent/debited from the sender.
+        // - amountReceivedLD is the amount in local decimals that will be received/credited to the recipient on the remote OFT instance.
+        (uint256 amountSentLD, uint256 amountReceivedLD) = _debit(
+            msg.sender,
+            _sendParam.amountLD,
+            _sendParam.minAmountLD,
+            _sendParam.dstEid
+        );
+
+        // @dev Builds the options and OFT message to quote in the endpoint.
+        (bytes memory message, bytes memory options) = _buildMsgAndOptions(_sendParam, amountReceivedLD);
+
+        // @dev Sends the message to the LayerZero endpoint and returns the LayerZero msg receipt.
+        msgReceipt = _lzSend(_sendParam.dstEid, message, options, _fee, _refundAddress);
+        // @dev Formulate the OFT receipt.
+        oftReceipt = OFTReceipt(amountSentLD, amountReceivedLD);
+
+        emit OFTSent(msgReceipt.guid, _sendParam.dstEid, msg.sender, amountSentLD, amountReceivedLD);
+    }
+
+    /**
+     * @dev Internal function to build the message and options.
+     * @param _sendParam The parameters for the send() operation.
+     * @param _amountLD The amount in local decimals.
+     * @return message The encoded message.
+     * @return options The encoded options.
+     */
+    function _buildMsgAndOptions(
+        SendParam calldata _sendParam,
+        uint256 _amountLD
+    ) internal view virtual returns (bytes memory message, bytes memory options) {
+        bool hasCompose;
+        // @dev This generated message has the msg.sender encoded into the payload so the remote knows who the caller is.
+        (message, hasCompose) = OFTMsgCodec.encode(
+            _sendParam.to,
+            _toSD(_amountLD),
+            // @dev Must be include a non empty bytes if you want to compose, EVEN if you dont need it on the remote.
+            // EVEN if you dont require an arbitrary payload to be sent... eg. '0x01'
+            _sendParam.composeMsg
+        );
+        // @dev Change the msg type depending if its composed or not.
+        uint16 msgType = hasCompose ? SEND_AND_CALL : SEND;
+        // @dev Combine the callers _extraOptions with the enforced options via the OAppOptionsType3.
+        options = combineOptions(_sendParam.dstEid, msgType, _sendParam.extraOptions);
+
+        // @dev Optionally inspect the message and options depending if the OApp owner has set a msg inspector.
+        // @dev If it fails inspection, needs to revert in the implementation. ie. does not rely on return boolean
+        if (msgInspector != address(0)) IOAppMsgInspector(msgInspector).inspect(message, options);
+    }
+
+    /**
+     * @dev Internal function to handle the receive on the LayerZero endpoint.
+     * @param _origin The origin information.
+     *  - srcEid: The source chain endpoint ID.
+     *  - sender: The sender address from the src chain.
+     *  - nonce: The nonce of the LayerZero message.
+     * @param _guid The unique identifier for the received LayerZero message.
+     * @param _message The encoded message.
+     * @dev _executor The address of the executor.
+     * @dev _extraData Additional data.
+     */
+    function _lzReceive(
+        Origin calldata _origin,
+        bytes32 _guid,
+        bytes calldata _message,
+        address /*_executor*/, // @dev unused in the default implementation.
+        bytes calldata /*_extraData*/ // @dev unused in the default implementation.
+    ) internal virtual override {
+        // @dev The src sending chain doesnt know the address length on this chain (potentially non-evm)
+        // Thus everything is bytes32() encoded in flight.
+        address toAddress = _message.sendTo().bytes32ToAddress();
+        // @dev Credit the amountLD to the recipient and return the ACTUAL amount the recipient received in local decimals
+        uint256 amountReceivedLD = _credit(toAddress, _toLD(_message.amountSD()), _origin.srcEid);
+
+        if (_message.isComposed()) {
+            // @dev Proprietary composeMsg format for the OFT.
+            bytes memory composeMsg = OFTComposeMsgCodec.encode(
+                _origin.nonce,
+                _origin.srcEid,
+                amountReceivedLD,
+                _message.composeMsg()
+            );
+
+            // @dev Stores the lzCompose payload that will be executed in a separate tx.
+            // Standardizes functionality for executing arbitrary contract invocation on some non-evm chains.
+            // @dev The off-chain executor will listen and process the msg based on the src-chain-callers compose options passed.
+            // @dev The index is used when a OApp needs to compose multiple msgs on lzReceive.
+            // For default OFT implementation there is only 1 compose msg per lzReceive, thus its always 0.
+            endpoint.sendCompose(toAddress, _guid, 0 /* the index of the composed message*/, composeMsg);
+        }
+
+        emit OFTReceived(_guid, _origin.srcEid, toAddress, amountReceivedLD);
+    }
+
+    /**
+     * @dev Internal function to handle the OAppPreCrimeSimulator simulated receive.
+     * @param _origin The origin information.
+     *  - srcEid: The source chain endpoint ID.
+     *  - sender: The sender address from the src chain.
+     *  - nonce: The nonce of the LayerZero message.
+     * @param _guid The unique identifier for the received LayerZero message.
+     * @param _message The LayerZero message.
+     * @param _executor The address of the off-chain executor.
+     * @param _extraData Arbitrary data passed by the msg executor.
+     *
+     * @dev Enables the preCrime simulator to mock sending lzReceive() messages,
+     * routes the msg down from the OAppPreCrimeSimulator, and back up to the OAppReceiver.
+     */
+    function _lzReceiveSimulate(
+        Origin calldata _origin,
+        bytes32 _guid,
+        bytes calldata _message,
+        address _executor,
+        bytes calldata _extraData
+    ) internal virtual override {
+        _lzReceive(_origin, _guid, _message, _executor, _extraData);
+    }
+
+    /**
+     * @dev Check if the peer is considered 'trusted' by the OApp.
+     * @param _eid The endpoint ID to check.
+     * @param _peer The peer to check.
+     * @return Whether the peer passed is considered 'trusted' by the OApp.
+     *
+     * @dev Enables OAppPreCrimeSimulator to check whether a potential Inbound Packet is from a trusted source.
+     */
+    function isPeer(uint32 _eid, bytes32 _peer) public view virtual override returns (bool) {
+        return peers[_eid] == _peer;
+    }
+
+    /**
+     * @dev Internal function to remove dust from the given local decimal amount.
+     * @param _amountLD The amount in local decimals.
+     * @return amountLD The amount after removing dust.
+     *
+     * @dev Prevents the loss of dust when moving amounts between chains with different decimals.
+     * @dev eg. uint(123) with a conversion rate of 100 becomes uint(100).
+     */
+    function _removeDust(uint256 _amountLD) internal view virtual returns (uint256 amountLD) {
+        return (_amountLD / decimalConversionRate) * decimalConversionRate;
+    }
+
+    /**
+     * @dev Internal function to convert an amount from shared decimals into local decimals.
+     * @param _amountSD The amount in shared decimals.
+     * @return amountLD The amount in local decimals.
+     */
+    function _toLD(uint64 _amountSD) internal view virtual returns (uint256 amountLD) {
+        return _amountSD * decimalConversionRate;
+    }
+
+    /**
+     * @dev Internal function to convert an amount from local decimals into shared decimals.
+     * @param _amountLD The amount in local decimals.
+     * @return amountSD The amount in shared decimals.
+     */
+    function _toSD(uint256 _amountLD) internal view virtual returns (uint64 amountSD) {
+        return uint64(_amountLD / decimalConversionRate);
+    }
+
+    /**
+     * @dev Internal function to mock the amount mutation from a OFT debit() operation.
+     * @param _amountLD The amount to send in local decimals.
+     * @param _minAmountLD The minimum amount to send in local decimals.
+     * @dev _dstEid The destination endpoint ID.
+     * @return amountSentLD The amount sent, in local decimals.
+     * @return amountReceivedLD The amount to be received on the remote chain, in local decimals.
+     *
+     * @dev This is where things like fees would be calculated and deducted from the amount to be received on the remote.
+     */
+    function _debitView(
+        uint256 _amountLD,
+        uint256 _minAmountLD,
+        uint32 /*_dstEid*/
+    ) internal view virtual returns (uint256 amountSentLD, uint256 amountReceivedLD) {
+        // @dev Remove the dust so nothing is lost on the conversion between chains with different decimals for the token.
+        amountSentLD = _removeDust(_amountLD);
+        // @dev The amount to send is the same as amount received in the default implementation.
+        amountReceivedLD = amountSentLD;
+
+        // @dev Check for slippage.
+        if (amountReceivedLD < _minAmountLD) {
+            revert SlippageExceeded(amountReceivedLD, _minAmountLD);
+        }
+    }
+
+    /**
+     * @dev Internal function to perform a debit operation.
+     * @param _from The address to debit.
+     * @param _amountLD The amount to send in local decimals.
+     * @param _minAmountLD The minimum amount to send in local decimals.
+     * @param _dstEid The destination endpoint ID.
+     * @return amountSentLD The amount sent in local decimals.
+     * @return amountReceivedLD The amount received in local decimals on the remote.
+     *
+     * @dev Defined here but are intended to be overriden depending on the OFT implementation.
+     * @dev Depending on OFT implementation the _amountLD could differ from the amountReceivedLD.
+     */
+    function _debit(
+        address _from,
+        uint256 _amountLD,
+        uint256 _minAmountLD,
+        uint32 _dstEid
+    ) internal virtual returns (uint256 amountSentLD, uint256 amountReceivedLD);
+
+    /**
+     * @dev Internal function to perform a credit operation.
+     * @param _to The address to credit.
+     * @param _amountLD The amount to credit in local decimals.
+     * @param _srcEid The source endpoint ID.
+     * @return amountReceivedLD The amount ACTUALLY received in local decimals.
+     *
+     * @dev Defined here but are intended to be overriden depending on the OFT implementation.
+     * @dev Depending on OFT implementation the _amountLD could differ from the amountReceivedLD.
+     */
+    function _credit(
+        address _to,
+        uint256 _amountLD,
+        uint32 _srcEid
+    ) internal virtual returns (uint256 amountReceivedLD);
+}

package/contracts/oft/OFTPrecrime.sol

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+// import { IOApp } from "../../interfaces/IOApp.sol";
+// import { IOFT } from "./interfaces/IOFT.sol";
+// import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+// import { OFTAdapter } from "./OFTAdapter.sol";
+
+//contract OFTPreCrime is PreCrime {
+//    address public oft;
+//    uint256 public EXPECTED_GLOBAL_SUPPLY;
+//
+//    constructor(address _endpoint, address _oft) PreCrime(_endpoint) {
+//        oft = _oft;
+//    }
+//
+//    struct SimulationResult {
+//        uint256 totalSupplyLD;
+//        bool isAdapter;
+//    }
+//
+//    // @dev only necessary when its exclusive 'OFT', NOT 'OFTAdapter' type
+//    // sum of all tokens in the oft network, it can change, but this will need to be updated for pre-Crime to pass
+//    function setGlobalSupply(uint256 _globalSupply) public onlyPreCrimeAdmin {
+//        EXPECTED_GLOBAL_SUPPLY = _globalSupply;
+//    }
+//
+//    // -------------------------------
+//    // PreCrime
+//    function _receiver() internal view override returns (address) {
+//        return address(oft);
+//    }
+//
+//    function _preCrime(bytes[] memory _simulation) internal view override returns (uint16 code, bytes memory reason) {
+//        uint256 globalSupply;
+//        uint256 expectedGlobalSupply = EXPECTED_GLOBAL_SUPPLY;
+//
+//        // @dev indicates that there is an 'OFTAdapter' on one of the chains, not necessarily this local chain
+//        bool isOFTAdapter;
+//
+//        for (uint256 i = 0; i < _simulation.length; i++) {
+//            SimulationResult memory result = abi.decode(_simulation[i], (SimulationResult));
+//
+//            if (result.isAdapter) {
+//                // @dev does not support multiple' 'OFTAdapter' contracts for a given oft mesh
+//                if (isOFTAdapter) return (CODE_PRECRIME_FAILURE, "OFTPreCrime: multiple OFTAdapters found");
+//                isOFTAdapter = true;
+//
+//                expectedGlobalSupply = result.totalSupplyLD;
+//            } else {
+//                globalSupply += result.totalSupplyLD;
+//            }
+//        }
+//
+//        if (isOFTAdapter && globalSupply > expectedGlobalSupply) {
+//            // @dev expectedGlobal supply for an 'OFTAdapter' can be slightly higher due to users sending tokens direct
+//            // to the OFTAdapter contract, cant check explicitly "=="
+//            return (CODE_PRECRIME_FAILURE, "OFTPreCrime: globalSupply > expectedGlobalSupply");
+//        } else if (globalSupply != expectedGlobalSupply) {
+//            // @dev exclusively 'OFT', NOT 'OFTAdapter' instances, balances should be exactly "=="
+//            return (CODE_PRECRIME_FAILURE, "OFTPreCrime: globalSupply != expectedGlobalSupply");
+//        } else {
+//            return (CODE_SUCCESS, "");
+//        }
+//    }
+//
+//    function simulationCallback() external view override returns (bytes memory result) {
+//        address token = IOFT(oft).token();
+//
+//        // @dev checks if the corresponding _oft on this chain is an adapter version, or returns false if its regular 'OFT'
+//        // eg. 'OFTAdapter' lock/unlock tokens from an external token contract, vs. regular 'OFT' mints/burns
+//        bool isAdapter = token != oft;
+//
+//        // @dev for 'OFTAdapter' the total supply is the total amount locked, otherwise its the totalSupply of oft tokens on the chain
+//        uint256 totalSupply = isAdapter ? IERC20(token).balanceOf(oft) : IERC20(oft).totalSupply();
+//
+//        return abi.encode(SimulationResult(totalSupply, isAdapter));
+//    }
+//
+//    function _simulate(Packet[] calldata _packets) internal override returns (uint16 code, bytes memory simulation) {
+//        (bool success, bytes memory result) = oft.call{value: msg.value}(
+//            abi.encodeWithSelector(IOApp.lzReceiveAndRevert.selector, _packets)
+//        );
+//        require(!success, "OFTPreCrime: simulationCallback should be called via revert");
+//
+//        (, result) = _parseRevertResult(result, LzReceiveRevert.selector);
+//        return (CODE_SUCCESS, result);
+//    }
+//
+//    // @dev need to ensure that all preCrimePeers are present inside of the results passed into _checkResultsCompleteness()
+//    // when checking oft preCrime we always want every simulation/result from the remote peers
+//    function _getPreCrimePeers(
+//        Packet[] calldata /*_packets*/
+//    ) internal view override returns (uint32[] memory eids, bytes32[] memory peers) {
+//        // @dev assumes that the preCrimeEids is the full list of oft eids for this oft mesh
+//        return (preCrimeEids, preCrimePeers);
+//    }
+//}

package/contracts/oft/interfaces/IOFT.sol

@@ -0,0 +1,149 @@
+// 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);
+}