@layerzerolabs/lz-evm-oapp-v2 2.0.2

package/contracts/oapp/examples/OmniCounterPreCrime.sol

@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.22;
+
+import { PreCrime, PreCrimePeer } from "../../precrime/PreCrime.sol";
+import { InboundPacket } from "../../precrime/libs/Packet.sol";
+import { OmniCounter } from "./OmniCounter.sol";
+
+contract OmniCounterPreCrime is PreCrime {
+    struct ChainCount {
+        uint32 remoteEid;
+        uint256 inboundCount;
+        uint256 outboundCount;
+    }
+
+    constructor(address _endpoint, address _counter, address _owner) PreCrime(_endpoint, _counter, _owner) {}
+
+    function buildSimulationResult() external view override returns (bytes memory) {
+        address payable payableSimulator = payable(simulator);
+        OmniCounter counter = OmniCounter(payableSimulator);
+        ChainCount[] memory chainCounts = new ChainCount[](preCrimePeers.length);
+        for (uint256 i = 0; i < preCrimePeers.length; i++) {
+            uint32 remoteEid = preCrimePeers[i].eid;
+            chainCounts[i] = ChainCount(remoteEid, counter.inboundCount(remoteEid), counter.outboundCount(remoteEid));
+        }
+        return abi.encode(chainCounts);
+    }
+
+    function _preCrime(
+        InboundPacket[] memory /** _packets */,
+        uint32[] memory _eids,
+        bytes[] memory _simulations
+    ) internal view override {
+        uint32 localEid = _getLocalEid();
+        ChainCount[] memory localChainCounts;
+
+        // find local chain counts
+        for (uint256 i = 0; i < _eids.length; i++) {
+            if (_eids[i] == localEid) {
+                localChainCounts = abi.decode(_simulations[i], (ChainCount[]));
+                break;
+            }
+        }
+
+        // local against remote
+        for (uint256 i = 0; i < _eids.length; i++) {
+            uint32 remoteEid = _eids[i];
+            ChainCount[] memory remoteChainCounts = abi.decode(_simulations[i], (ChainCount[]));
+            (uint256 _inboundCount, ) = _findChainCounts(localChainCounts, remoteEid);
+            (, uint256 _outboundCount) = _findChainCounts(remoteChainCounts, localEid);
+            if (_inboundCount > _outboundCount) {
+                revert CrimeFound("inboundCount > outboundCount");
+            }
+        }
+    }
+
+    function _findChainCounts(
+        ChainCount[] memory _chainCounts,
+        uint32 _remoteEid
+    ) internal pure returns (uint256, uint256) {
+        for (uint256 i = 0; i < _chainCounts.length; i++) {
+            if (_chainCounts[i].remoteEid == _remoteEid) {
+                return (_chainCounts[i].inboundCount, _chainCounts[i].outboundCount);
+            }
+        }
+        return (0, 0);
+    }
+
+    function _getPreCrimePeers(
+        InboundPacket[] memory _packets
+    ) internal view override returns (PreCrimePeer[] memory peers) {
+        PreCrimePeer[] memory allPeers = preCrimePeers;
+        PreCrimePeer[] memory peersTmp = new PreCrimePeer[](_packets.length);
+
+        int256 cursor = -1;
+        for (uint256 i = 0; i < _packets.length; i++) {
+            uint32 srcEid = _packets[i].origin.srcEid;
+
+            // push src eid & peer
+            int256 index = _indexOf(allPeers, srcEid);
+            if (index >= 0 && _indexOf(peersTmp, srcEid) < 0) {
+                cursor++;
+                peersTmp[uint256(cursor)] = allPeers[uint256(index)];
+            }
+        }
+        // copy to return
+        if (cursor >= 0) {
+            uint256 len = uint256(cursor) + 1;
+            peers = new PreCrimePeer[](len);
+            for (uint256 i = 0; i < len; i++) {
+                peers[i] = peersTmp[i];
+            }
+        }
+    }
+
+    function _indexOf(PreCrimePeer[] memory _peers, uint32 _eid) internal pure returns (int256) {
+        for (uint256 i = 0; i < _peers.length; i++) {
+            if (_peers[i].eid == _eid) return int256(i);
+        }
+        return -1;
+    }
+}

package/contracts/oapp/interfaces/IOAppComposer.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.22;
+
+import { ILayerZeroComposer } from "@layerzerolabs/lz-evm-protocol-v2/contracts/interfaces/ILayerZeroComposer.sol";
+
+/**
+ * @title IOAppComposer
+ * @dev This interface defines the OApp Composer, allowing developers to inherit only the OApp package without the protocol.
+ */
+// solhint-disable-next-line no-empty-blocks
+interface IOAppComposer is ILayerZeroComposer {}

package/contracts/oapp/interfaces/IOAppCore.sol

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.22;
+
+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();
+
+    // 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;
+}

package/contracts/oapp/interfaces/IOAppMsgInspector.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.22;
+
+/**
+ * @title IOAppMsgInspector
+ * @dev Interface for the OApp Message Inspector, allowing examination of message and options contents.
+ */
+interface IOAppMsgInspector {
+    // Custom error message for inspection failure
+    error InspectionFailed(bytes message, bytes options);
+
+    /**
+     * @notice Allows the inspector to examine LayerZero message contents and optionally throw a revert if invalid.
+     * @param _message The message payload to be inspected.
+     * @param _options Additional options or parameters for inspection.
+     * @return valid A boolean indicating whether the inspection passed (true) or failed (false).
+     *
+     * @dev Optionally done as a revert, OR use the boolean provided to handle the failure.
+     */
+    function inspect(bytes calldata _message, bytes calldata _options) external view returns (bool valid);
+}

package/contracts/oapp/interfaces/IOAppOptionsType3.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.22;
+
+/**
+ * @dev Struct representing enforced option parameters.
+ */
+struct EnforcedOptionParam {
+    uint32 eid; // Endpoint ID
+    uint16 msgType; // Message Type
+    bytes options; // Additional options
+}
+
+/**
+ * @title IOAppOptionsType3
+ * @dev Interface for the OApp with Type 3 Options, allowing the setting and combining of enforced options.
+ */
+interface IOAppOptionsType3 {
+    // Custom error message for invalid options
+    error InvalidOptions(bytes options);
+
+    // Event emitted when enforced options are set
+    event EnforcedOptionSet(EnforcedOptionParam[] _enforcedOptions);
+
+    /**
+     * @notice Sets enforced options for specific endpoint and message type combinations.
+     * @param _enforcedOptions An array of EnforcedOptionParam structures specifying enforced options.
+     */
+    function setEnforcedOptions(EnforcedOptionParam[] calldata _enforcedOptions) external;
+
+    /**
+     * @notice Combines options for a given endpoint and message type.
+     * @param _eid The endpoint ID.
+     * @param _msgType The OApp message type.
+     * @param _extraOptions Additional options passed by the caller.
+     * @return options The combination of caller specified options AND enforced options.
+     */
+    function combineOptions(
+        uint32 _eid,
+        uint16 _msgType,
+        bytes calldata _extraOptions
+    ) external view returns (bytes memory options);
+}

package/contracts/oapp/libs/OAppOptionsType3.sol

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.22;
+
+import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
+import { IOAppOptionsType3, EnforcedOptionParam } from "../interfaces/IOAppOptionsType3.sol";
+
+/**
+ * @title OAppOptionsType3
+ * @dev Abstract contract implementing the IOAppOptionsType3 interface with type 3 options.
+ */
+abstract contract OAppOptionsType3 is IOAppOptionsType3, Ownable {
+    uint16 internal constant OPTION_TYPE_3 = 3;
+
+    // @dev The "msgType" should be defined in the child contract.
+    mapping(uint32 eid => mapping(uint16 msgType => bytes enforcedOption)) public enforcedOptions;
+
+    /**
+     * @dev Sets the enforced options for specific endpoint and message type combinations.
+     * @param _enforcedOptions An array of EnforcedOptionParam structures specifying enforced options.
+     *
+     * @dev Only the owner/admin of the OApp can call this function.
+     * @dev Provides a way for the OApp to enforce things like paying for PreCrime, AND/OR minimum dst lzReceive gas amounts etc.
+     * @dev These enforced options can vary as the potential options/execution on the remote may differ as per the msgType.
+     * eg. Amount of lzReceive() gas necessary to deliver a lzCompose() message adds overhead you dont want to pay
+     * if you are only making a standard LayerZero message ie. lzReceive() WITHOUT sendCompose().
+     */
+    function setEnforcedOptions(EnforcedOptionParam[] calldata _enforcedOptions) public virtual onlyOwner {
+        for (uint256 i = 0; i < _enforcedOptions.length; i++) {
+            // @dev Enforced options are only available for optionType 3, as type 1 and 2 dont support combining.
+            _assertOptionsType3(_enforcedOptions[i].options);
+            enforcedOptions[_enforcedOptions[i].eid][_enforcedOptions[i].msgType] = _enforcedOptions[i].options;
+        }
+
+        emit EnforcedOptionSet(_enforcedOptions);
+    }
+
+    /**
+     * @notice Combines options for a given endpoint and message type.
+     * @param _eid The endpoint ID.
+     * @param _msgType The OAPP message type.
+     * @param _extraOptions Additional options passed by the caller.
+     * @return options The combination of caller specified options AND enforced options.
+     *
+     * @dev If there is an enforced lzReceive option:
+     * - {gasLimit: 200k, msg.value: 1 ether} AND a caller supplies a lzReceive option: {gasLimit: 100k, msg.value: 0.5 ether}
+     * - The resulting options will be {gasLimit: 300k, msg.value: 1.5 ether} when the message is executed on the remote lzReceive() function.
+     * @dev This presence of duplicated options is handled off-chain in the verifier/executor.
+     */
+    function combineOptions(
+        uint32 _eid,
+        uint16 _msgType,
+        bytes calldata _extraOptions
+    ) public view virtual returns (bytes memory) {
+        bytes memory enforced = enforcedOptions[_eid][_msgType];
+
+        // No enforced options, pass whatever the caller supplied, even if it's empty or legacy type 1/2 options.
+        if (enforced.length == 0) return _extraOptions;
+
+        // No caller options, return enforced
+        if (_extraOptions.length == 0) return enforced;
+
+        // @dev If caller provided _extraOptions, must be type 3 as its the ONLY type that can be combined.
+        if (_extraOptions.length >= 2) {
+            _assertOptionsType3(_extraOptions);
+            // @dev Remove the first 2 bytes containing the type from the _extraOptions and combine with enforced.
+            return bytes.concat(enforced, _extraOptions[2:]);
+        }
+
+        // No valid set of options was found.
+        revert InvalidOptions(_extraOptions);
+    }
+
+    /**
+     * @dev Internal function to assert that options are of type 3.
+     * @param _options The options to be checked.
+     */
+    function _assertOptionsType3(bytes calldata _options) internal pure virtual {
+        uint16 optionsType = uint16(bytes2(_options[0:2]));
+        if (optionsType != OPTION_TYPE_3) revert InvalidOptions(_options);
+    }
+}

package/contracts/oapp/libs/OptionsBuilder.sol

@@ -0,0 +1,200 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.22;
+
+import { BytesLib } from "solidity-bytes-utils/contracts/BytesLib.sol";
+import { SafeCast } from "@openzeppelin/contracts/utils/math/SafeCast.sol";
+
+import { ExecutorOptions } from "@layerzerolabs/lz-evm-protocol-v2/contracts/messagelib/libs/ExecutorOptions.sol";
+import { DVNOptions } from "@layerzerolabs/lz-evm-messagelib-v2/contracts/uln/libs/DVNOptions.sol";
+
+/**
+ * @title OptionsBuilder
+ * @dev Library for building and encoding various message options.
+ */
+library OptionsBuilder {
+    using SafeCast for uint256;
+    using BytesLib for bytes;
+
+    // Constants for options types
+    uint16 internal constant TYPE_1 = 1; // legacy options type 1
+    uint16 internal constant TYPE_2 = 2; // legacy options type 2
+    uint16 internal constant TYPE_3 = 3;
+
+    // Custom error message
+    error InvalidSize(uint256 max, uint256 actual);
+    error InvalidOptionType(uint16 optionType);
+
+    // Modifier to ensure only options of type 3 are used
+    modifier onlyType3(bytes memory _options) {
+        if (_options.toUint16(0) != TYPE_3) revert InvalidOptionType(_options.toUint16(0));
+        _;
+    }
+
+    /**
+     * @dev Creates a new options container with type 3.
+     * @return options The newly created options container.
+     */
+    function newOptions() internal pure returns (bytes memory) {
+        return abi.encodePacked(TYPE_3);
+    }
+
+    /**
+     * @dev Adds an executor LZ receive option to the existing options.
+     * @param _options The existing options container.
+     * @param _gas The gasLimit used on the lzReceive() function in the OApp.
+     * @param _value The msg.value passed to the lzReceive() function in the OApp.
+     * @return options The updated options container.
+     *
+     * @dev When multiples of this option are added, they are summed by the executor
+     * eg. if (_gas: 200k, and _value: 1 ether) AND (_gas: 100k, _value: 0.5 ether) are sent in an option to the LayerZeroEndpoint,
+     * that becomes (300k, 1.5 ether) when the message is executed on the remote lzReceive() function.
+     */
+    function addExecutorLzReceiveOption(
+        bytes memory _options,
+        uint128 _gas,
+        uint128 _value
+    ) internal pure onlyType3(_options) returns (bytes memory) {
+        bytes memory option = ExecutorOptions.encodeLzReceiveOption(_gas, _value);
+        return addExecutorOption(_options, ExecutorOptions.OPTION_TYPE_LZRECEIVE, option);
+    }
+
+    /**
+     * @dev Adds an executor native drop option to the existing options.
+     * @param _options The existing options container.
+     * @param _amount The amount for the native value that is airdropped to the 'receiver'.
+     * @param _receiver The receiver address for the native drop option.
+     * @return options The updated options container.
+     *
+     * @dev When multiples of this option are added, they are summed by the executor on the remote chain.
+     */
+    function addExecutorNativeDropOption(
+        bytes memory _options,
+        uint128 _amount,
+        bytes32 _receiver
+    ) internal pure onlyType3(_options) returns (bytes memory) {
+        bytes memory option = ExecutorOptions.encodeNativeDropOption(_amount, _receiver);
+        return addExecutorOption(_options, ExecutorOptions.OPTION_TYPE_NATIVE_DROP, option);
+    }
+
+    /**
+     * @dev Adds an executor LZ compose option to the existing options.
+     * @param _options The existing options container.
+     * @param _index The index for the lzCompose() function call.
+     * @param _gas The gasLimit for the lzCompose() function call.
+     * @param _value The msg.value for the lzCompose() function call.
+     * @return options The updated options container.
+     *
+     * @dev When multiples of this option are added, they are summed PER index by the executor on the remote chain.
+     * @dev If the OApp sends N lzCompose calls on the remote, you must provide N incremented indexes starting with 0.
+     * ie. When your remote OApp composes (N = 3) messages, you must set this option for index 0,1,2
+     */
+    function addExecutorLzComposeOption(
+        bytes memory _options,
+        uint16 _index,
+        uint128 _gas,
+        uint128 _value
+    ) internal pure onlyType3(_options) returns (bytes memory) {
+        bytes memory option = ExecutorOptions.encodeLzComposeOption(_index, _gas, _value);
+        return addExecutorOption(_options, ExecutorOptions.OPTION_TYPE_LZCOMPOSE, option);
+    }
+
+    /**
+     * @dev Adds an executor ordered execution option to the existing options.
+     * @param _options The existing options container.
+     * @return options The updated options container.
+     */
+    function addExecutorOrderedExecutionOption(
+        bytes memory _options
+    ) internal pure onlyType3(_options) returns (bytes memory) {
+        return addExecutorOption(_options, ExecutorOptions.OPTION_TYPE_ORDERED_EXECUTION, bytes(""));
+    }
+
+    /**
+     * @dev Adds a DVN pre-crime option to the existing options.
+     * @param _options The existing options container.
+     * @param _dvnIdx The DVN index for the pre-crime option.
+     * @return options The updated options container.
+     */
+    function addDVNPreCrimeOption(
+        bytes memory _options,
+        uint8 _dvnIdx
+    ) internal pure onlyType3(_options) returns (bytes memory) {
+        return addDVNOption(_options, _dvnIdx, DVNOptions.OPTION_TYPE_PRECRIME, bytes(""));
+    }
+
+    /**
+     * @dev Adds an executor option to the existing options.
+     * @param _options The existing options container.
+     * @param _optionType The type of the executor option.
+     * @param _option The encoded data for the executor option.
+     * @return options The updated options container.
+     */
+    function addExecutorOption(
+        bytes memory _options,
+        uint8 _optionType,
+        bytes memory _option
+    ) internal pure onlyType3(_options) returns (bytes memory) {
+        return
+            abi.encodePacked(
+                _options,
+                ExecutorOptions.WORKER_ID,
+                _option.length.toUint16() + 1, // +1 for optionType
+                _optionType,
+                _option
+            );
+    }
+
+    /**
+     * @dev Adds a DVN option to the existing options.
+     * @param _options The existing options container.
+     * @param _dvnIdx The DVN index for the DVN option.
+     * @param _optionType The type of the DVN option.
+     * @param _option The encoded data for the DVN option.
+     * @return options The updated options container.
+     */
+    function addDVNOption(
+        bytes memory _options,
+        uint8 _dvnIdx,
+        uint8 _optionType,
+        bytes memory _option
+    ) internal pure onlyType3(_options) returns (bytes memory) {
+        return
+            abi.encodePacked(
+                _options,
+                DVNOptions.WORKER_ID,
+                _option.length.toUint16() + 2, // +2 for optionType and dvnIdx
+                _dvnIdx,
+                _optionType,
+                _option
+            );
+    }
+
+    /**
+     * @dev Encodes legacy options of type 1.
+     * @param _executionGas The gasLimit value passed to lzReceive().
+     * @return legacyOptions The encoded legacy options.
+     */
+    function encodeLegacyOptionsType1(uint256 _executionGas) internal pure returns (bytes memory) {
+        if (_executionGas > type(uint128).max) revert InvalidSize(type(uint128).max, _executionGas);
+        return abi.encodePacked(TYPE_1, _executionGas);
+    }
+
+    /**
+     * @dev Encodes legacy options of type 2.
+     * @param _executionGas The gasLimit value passed to lzReceive().
+     * @param _nativeForDst The amount of native air dropped to the receiver.
+     * @param _receiver The _nativeForDst receiver address.
+     * @return legacyOptions The encoded legacy options of type 2.
+     */
+    function encodeLegacyOptionsType2(
+        uint256 _executionGas,
+        uint256 _nativeForDst,
+        bytes memory _receiver // @dev Use bytes instead of bytes32 in legacy type 2 for _receiver.
+    ) internal pure returns (bytes memory) {
+        if (_executionGas > type(uint128).max) revert InvalidSize(type(uint128).max, _executionGas);
+        if (_nativeForDst > type(uint128).max) revert InvalidSize(type(uint128).max, _nativeForDst);
+        if (_receiver.length > 32) revert InvalidSize(32, _receiver.length);
+        return abi.encodePacked(TYPE_2, _executionGas, _nativeForDst, _receiver);
+    }
+}

package/contracts/oft/OFT.sol

@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.22;
+
+import { ERC20 } from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import { OFTCore } from "./OFTCore.sol";
+
+/**
+ * @title OFT Contract
+ * @dev OFT is an ERC-20 token that extends the functionality of the OFTCore contract.
+ */
+contract OFT is OFTCore, ERC20 {
+    /**
+     * @dev Constructor for the OFT contract.
+     * @param _name The name of the OFT.
+     * @param _symbol The symbol of the OFT.
+     * @param _lzEndpoint The LayerZero endpoint address.
+     * @param _owner The owner of the contract.
+     */
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _lzEndpoint,
+        address _owner
+    ) ERC20(_name, _symbol) OFTCore(decimals(), _lzEndpoint, _owner) {}
+
+    /**
+     * @dev Retrieves the OFT contract version.
+     * @return major The major version.
+     * @return minor The minor version.
+     *
+     * @dev major version: Indicates a cross-chain compatible msg encoding with other OFTs.
+     * @dev minor version: Indicates a version within the local chains context. eg. OFTAdapter vs. OFT
+     * @dev For example, if a new feature is added to the OFT contract, the minor version will be incremented.
+     * @dev If a new feature is added to the OFT cross-chain msg encoding, the major version will be incremented.
+     * ie. localOFT version(1,1) CAN send messages to remoteOFT version(1,2)
+     */
+    function oftVersion() external pure returns (uint64 major, uint64 minor) {
+        return (1, 1);
+    }
+
+    /**
+     * @dev Retrieves the address of the underlying ERC20 implementation.
+     * @return The address of the OFT token.
+     *
+     * @dev In the case of OFT, address(this) and erc20 are the same contract.
+     */
+    function token() external view returns (address) {
+        return address(this);
+    }
+
+    /**
+     * @dev Burns tokens from the sender's specified balance.
+     * @param _amountToSendLD The amount of tokens to send in local decimals.
+     * @param _minAmountToCreditLD The minimum amount to credit in local decimals.
+     * @param _dstEid The destination chain ID.
+     * @return amountDebitedLD The amount of tokens ACTUALLY debited in local decimals.
+     * @return amountToCreditLD The amount of tokens to credit in local decimals.
+     */
+    function _debitSender(
+        uint256 _amountToSendLD,
+        uint256 _minAmountToCreditLD,
+        uint32 _dstEid
+    ) internal virtual override returns (uint256 amountDebitedLD, uint256 amountToCreditLD) {
+        (amountDebitedLD, amountToCreditLD) = _debitView(_amountToSendLD, _minAmountToCreditLD, _dstEid);
+
+        // @dev In NON-default OFT, amountDebited could be 100, with a 10% fee, the credited amount is 90,
+        // therefore amountDebited CAN differ from amountToCredit.
+
+        // @dev Default OFT burns on src.
+        _burn(msg.sender, amountDebitedLD);
+    }
+
+    /**
+     * @dev Burns tokens that have been sent into this contract.
+     * @param _minAmountToReceiveLD The minimum amount to receive in local decimals.
+     * @param _dstEid The destination chain ID.
+     * @return amountDebitedLD The amount of tokens ACTUALLY debited in local decimals.
+     * @return amountToCreditLD The amount of tokens to credit in local decimals.
+     */
+    function _debitThis(
+        uint256 _minAmountToReceiveLD,
+        uint32 _dstEid
+    ) internal virtual override returns (uint256 amountDebitedLD, uint256 amountToCreditLD) {
+        // @dev This is the push method, where at any point in the transaction, the OFT receives tokens and they can be sent by the caller.
+        // @dev This SHOULD be done atomically, otherwise any caller can spend tokens that are owned by the contract.
+        // @dev In the NON-default case where fees are stored in the contract, there should be a value reserved via a global state.
+        // eg. balanceOf(address(this)) - accruedFees;
+        (amountDebitedLD, amountToCreditLD) = _debitView(balanceOf(address(this)), _minAmountToReceiveLD, _dstEid);
+
+        // @dev Default OFT burns on src.
+        _burn(address(this), amountDebitedLD);
+
+        // @dev When sending tokens direct to the OFT contract,
+        // there is NOT a default mechanism to capture the dust that MIGHT get left in the contract.
+        // If you want to refund this dust, will need to add another function to return it.
+    }
+
+    /**
+     * @dev Credits tokens to the specified address.
+     * @param _to The address to credit the tokens to.
+     * @param _amountToCreditLD The amount of tokens to credit in local decimals.
+     * @dev _srcEid The source chain ID.
+     * @return amountReceivedLD The amount of tokens ACTUALLY received in local decimals.
+     */
+    function _credit(
+        address _to,
+        uint256 _amountToCreditLD,
+        uint32 /*_srcEid*/
+    ) internal virtual override returns (uint256 amountReceivedLD) {
+        // @dev Default OFT mints on dst.
+        _mint(_to, _amountToCreditLD);
+        // @dev In the case of NON-default OFT, the amountToCreditLD MIGHT not == amountReceivedLD.
+        return _amountToCreditLD;
+    }
+}