RACE #38 Of The Secureum Bootcamp Epoch∞

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.22;

import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {OApp, MessagingFee, Origin} from "@layerzerolabs/oapp-evm/contracts/oapp/OApp.sol";

interface ILayerZeroComposer {
    /**
     * @notice Composes a LayerZero message from an OApp.
     * @param _from The address initiating the composition, typically the OApp where the lzReceive was called.
     * @param _guid The unique identifier for the corresponding LayerZero src/dst tx.
     * @param _message The composed message payload in bytes. NOT necessarily the same payload passed via lzReceive.
     * @param _executor The address of the executor for the composed message.
     * @param _extraData Additional arbitrary data in bytes passed by the entity who executes the lzCompose.
     */
    function lzCompose(
        address _from,
        bytes32 _guid,
        bytes calldata _message,
        address _executor,
        bytes calldata _extraData
    ) external payable;
}

interface ISwapper {
    function swap(uint256 amountIn, uint256 minAmountOut, address to, uint256 deadline) external;

}

contract CrossChainToken is OApp, ERC20, ILayerZeroComposer {
    error InvalidLocalDecimals();
    error SlippageExceeded(uint256 amountLD, uint256 minAmountLD);

    uint256 public immutable decimalConversionRate;

    uint16 private feeNumerator = 115; // Default fee numerator
    uint64 private constant FEE_DENOMINATOR = 10000; // Fee denominator is constant

    constructor(string memory _name, string memory _symbol, address _lzEndpoint, address _delegate)
        OApp(_lzEndpoint, _delegate)
        ERC20(_name, _symbol)
        Ownable(_delegate)
    {
        if (decimals() < sharedDecimals()) revert InvalidLocalDecimals();
        decimalConversionRate = 10 ** (decimals() - sharedDecimals());
    }

    // @notice Sets the fee numerator.
    function setFeeNumerator(uint16 _feeNumerator) external onlyOwner {
        require(_feeNumerator < FEE_DENOMINATOR, "Fee numerator must be less than the denominator");
        feeNumerator = _feeNumerator;
    }

    /**
     * @dev Sends a message to the destination chain.
     * @param to The destination address.
     * @param dstEid The destination endpoint ID.
     * @param refundAddress The address to refund the fee to.
     * @param amount The amount to send.
     * @param minAmountLD The minimum amount to receive.
     * @param composeMsg The composed message.
     * @param options The executor options.
     * @param fee The calculated fee for the send() operation.
     *      - nativeFee: The native fee.
     *      - lzTokenFee: The lzToken fee.
     */
    function send(
        bytes32 to,
        uint32 dstEid,
        address refundAddress,
        uint256 amount,
        uint256 minAmountLD,
        bytes calldata composeMsg,
        bytes calldata options,
        MessagingFee memory fee
    ) external payable {
        // @dev Remove the dust so nothing is lost on the conversion between chains with different decimals for the token.
        uint256 amountSentLD = _removeDust(amount);

        // Calculate the fee amount based on the percentage
        uint256 feeAmount = (amountSentLD * feeNumerator) / (FEE_DENOMINATOR);

        // Deduct the fee amount from the amount to be sent
        uint256 amountReceivedLD = amountSentLD - feeAmount;

        // @dev Check for slippage.
        if (amountReceivedLD < minAmountLD) {
            revert SlippageExceeded(amountReceivedLD, minAmountLD);
        }

        // Transfer the remaining amount to the contract
        if (feeAmount > 0) {
            require(transfer(owner(), feeAmount), "Fee transfer failed");
        }

        _burn(msg.sender, amountReceivedLD);

        bytes memory message = composeMsg.length > 0
            ? abi.encodePacked(to, _toSD(amountReceivedLD), addressToBytes32(msg.sender), composeMsg)
            : abi.encodePacked(to, _toSD(amountReceivedLD));

        _lzSend(dstEid, message, options, fee, refundAddress);
    }

    /**
     * @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,
        bytes calldata _extraData
    ) internal virtual override {
        address toAddress = bytes32ToAddress(bytes32(_message[:32]));
        uint256 amountReceivedLD = _toLD(uint64(bytes8(_message[32:40])));
        _mint(toAddress, amountReceivedLD);

        // message is composed, execute lzCompose in a separate tx
        if (_message.length > 40) {
            bytes memory composeMsg = abi.encodePacked(_origin.nonce, _origin.srcEid, amountReceivedLD, _message[40:]);
            endpoint.sendCompose(toAddress, _guid, 0, /* the index of the composed message*/ composeMsg);
        }
    }

    // @inheritdoc ILayerZeroComposer
    function lzCompose(
        address _from,
        bytes32 _guid,
        bytes calldata _message,
        address _executor,
        bytes calldata _extraData
    ) external payable {
        require(msg.sender == address(endpoint), "!endpoint");

        uint256 amountReceived = uint256(bytes32(_message[12:20]));

        address recipient;
        uint256 minCollateralOut; // minAmountOut
        address swapFacility;

        try this.decodeInput(_message[76:]) returns (address _recipient, uint256 _minCollateralOut, address _swapFacility) {
            recipient = _recipient;
            minCollateralOut = _minCollateralOut;
            swapFacility = _swapFacility;
        } catch {
            address receiver = bytes32ToAddress(bytes32(_message[44:76]));
            transfer(receiver, amountReceived);
            return;
        }

        approve(swapFacility, amountReceived);

        try ISwapper(swapFacility).swap(
            amountReceived, minCollateralOut, recipient, block.timestamp
        ) {} catch {
            // Swap failed - need to revoke approval since it won't be automatically reverted
            approve(address(swapFacility), 0);
            transfer(recipient, amountReceived);
        }
    }

    /**
     * @dev Decodes the input message.
     * @param message The encoded message.
     * @return The decoded values.
     */
    function decodeInput(bytes calldata message) external pure returns (address, uint256, address) {
        (address _recipient, uint256 _minCollateralOut, address _swapFacility) = abi.decode(message, (address, uint256, address));

        return (_recipient, _minCollateralOut, _swapFacility);
    }

    /**
     * @dev Returns the shared decimals.
     * @return The shared decimals.
     */
    function sharedDecimals() public view virtual returns (uint8) {
        return 6;
    }

    /**
     * @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 Converts an address to bytes32.
     * @param _addr The address to convert.
     * @return The bytes32 representation of the address.
     */
    function addressToBytes32(address _addr) internal pure returns (bytes32) {
        return bytes32(uint256(uint160(_addr)));
    }

    /**
     * @dev Converts bytes32 to an address.
     * @param _b The bytes32 value to convert.
     * @return The address representation of bytes32.
     */
    function bytes32ToAddress(bytes32 _b) internal pure returns (address) {
        return address(uint160(uint256(_b)));
    }
}