@sablier/bob 1.0.1

package/src/SablierEscrow.sol

@@ -0,0 +1,288 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity >=0.8.22;
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import { ud, UD60x18 } from "@prb/math/src/UD60x18.sol";
+import { Comptrollerable } from "@sablier/evm-utils/src/Comptrollerable.sol";
+
+import { SablierEscrowState } from "./abstracts/SablierEscrowState.sol";
+import { ISablierEscrow } from "./interfaces/ISablierEscrow.sol";
+import { Errors } from "./libraries/Errors.sol";
+import { Escrow } from "./types/Escrow.sol";
+
+/*
+
+███████╗ █████╗ ██████╗ ██╗     ██╗███████╗██████╗     ███████╗███████╗ ██████╗██████╗  ██████╗ ██╗    ██╗
+██╔════╝██╔══██╗██╔══██╗██║     ██║██╔════╝██╔══██╗    ██╔════╝██╔════╝██╔════╝██╔══██╗██╔═══██╗██║    ██║
+███████╗███████║██████╔╝██║     ██║█████╗  ██████╔╝    █████╗  ███████╗██║     ██████╔╝██║   ██║██║ █╗ ██║
+╚════██║██╔══██║██╔══██╗██║     ██║██╔══╝  ██╔══██╗    ██╔══╝  ╚════██║██║     ██╔══██╗██║   ██║██║███╗██║
+███████║██║  ██║██████╔╝███████╗██║███████╗██║  ██║    ███████╗███████║╚██████╗██║  ██║╚██████╔╝╚███╔███╔╝
+╚══════╝╚═╝  ╚═╝╚═════╝ ╚══════╝╚═╝╚══════╝╚═╝  ╚═╝    ╚══════╝╚══════╝ ╚═════╝╚═╝  ╚═╝ ╚═════╝  ╚══╝╚══╝
+
+*/
+
+/// @title SablierEscrow
+/// @notice See the documentation in {ISablierEscrow}.
+contract SablierEscrow is
+    Comptrollerable, // 1 inherited component
+    ISablierEscrow, // 2 inherited components
+    SablierEscrowState // 1 inherited component
+{
+    using SafeERC20 for IERC20;
+
+    /*//////////////////////////////////////////////////////////////////////////
+                                    CONSTRUCTOR
+    //////////////////////////////////////////////////////////////////////////*/
+
+    /// @param initialComptroller The address of the initial comptroller contract.
+    /// @param initialTradeFee The initial trade fee percentage.
+    constructor(
+        address initialComptroller,
+        UD60x18 initialTradeFee
+    )
+        Comptrollerable(initialComptroller)
+        SablierEscrowState(initialTradeFee)
+    { }
+
+    /*//////////////////////////////////////////////////////////////////////////
+                        USER-FACING STATE-CHANGING FUNCTIONS
+    //////////////////////////////////////////////////////////////////////////*/
+
+    /// @inheritdoc ISablierEscrow
+    function cancelOrder(uint256 orderId) external override notNull(orderId) {
+        Escrow.Order storage order = _orders[orderId];
+
+        // Check: the caller is the seller.
+        if (msg.sender != order.seller) {
+            revert Errors.SablierEscrow_CallerNotAuthorized(orderId, msg.sender, order.seller);
+        }
+
+        // Check: the order has not been filled.
+        if (order.wasFilled) {
+            revert Errors.SablierEscrow_OrderFilled(orderId);
+        }
+
+        // Check: the order has not been canceled.
+        if (order.wasCanceled) {
+            revert Errors.SablierEscrow_OrderCancelled(orderId);
+        }
+
+        // Effect: mark the order as canceled.
+        order.wasCanceled = true;
+
+        // Cache the sell amount for this order.
+        uint128 sellAmount = order.sellAmount;
+
+        // Interaction: transfer sell tokens to caller.
+        order.sellToken.safeTransfer(msg.sender, sellAmount);
+
+        // Log the event.
+        emit CancelOrder({ orderId: orderId, seller: msg.sender, sellAmount: sellAmount });
+    }
+
+    /// @inheritdoc ISablierEscrow
+    function createOrder(
+        IERC20 sellToken,
+        uint128 sellAmount,
+        IERC20 buyToken,
+        uint128 minBuyAmount,
+        address buyer,
+        uint40 expiryTime
+    )
+        external
+        override
+        returns (uint256 orderId)
+    {
+        // Check: sell token is not the zero address.
+        if (address(sellToken) == address(0)) {
+            revert Errors.SablierEscrow_SellTokenZero();
+        }
+
+        // Check: sell token is not the native token.
+        if (address(sellToken) == nativeToken) {
+            revert Errors.SablierEscrow_ForbidNativeToken(address(sellToken));
+        }
+
+        // Check: buy token is not the zero address.
+        if (address(buyToken) == address(0)) {
+            revert Errors.SablierEscrow_BuyTokenZero();
+        }
+
+        // Check: buy token is not the native token.
+        if (address(buyToken) == nativeToken) {
+            revert Errors.SablierEscrow_ForbidNativeToken(address(buyToken));
+        }
+
+        // Check: sell and buy tokens are not the same.
+        if (sellToken == buyToken) {
+            revert Errors.SablierEscrow_SameToken(sellToken);
+        }
+
+        // Check: sell amount is not zero.
+        if (sellAmount == 0) {
+            revert Errors.SablierEscrow_SellAmountZero();
+        }
+
+        // Check: minimum buy amount is not zero.
+        if (minBuyAmount == 0) {
+            revert Errors.SablierEscrow_MinBuyAmountZero();
+        }
+
+        // Check: expiryTime is in the future. Zero is sentinel for orders that never expire.
+        if (expiryTime > 0 && expiryTime <= block.timestamp) {
+            revert Errors.SablierEscrow_ExpiryTimeInPast(expiryTime, uint40(block.timestamp));
+        }
+
+        // Use the current next order ID as this order's ID.
+        orderId = nextOrderId;
+
+        // Effect: increment the next order ID.
+        unchecked {
+            nextOrderId = orderId + 1;
+        }
+
+        // Effect: create the order.
+        _orders[orderId] = Escrow.Order({
+            seller: msg.sender,
+            buyer: buyer,
+            sellToken: sellToken,
+            buyToken: buyToken,
+            sellAmount: sellAmount,
+            minBuyAmount: minBuyAmount,
+            expiryTime: expiryTime,
+            wasCanceled: false,
+            wasFilled: false
+        });
+
+        // Interaction: transfer sell tokens from caller to this contract.
+        sellToken.safeTransferFrom(msg.sender, address(this), sellAmount);
+
+        // Log the event.
+        emit CreateOrder({
+            orderId: orderId,
+            seller: msg.sender,
+            buyer: buyer,
+            sellToken: sellToken,
+            buyToken: buyToken,
+            sellAmount: sellAmount,
+            minBuyAmount: minBuyAmount,
+            expiryTime: expiryTime
+        });
+    }
+
+    /// @inheritdoc ISablierEscrow
+    function fillOrder(
+        uint256 orderId,
+        uint128 buyAmount
+    )
+        external
+        override
+        notNull(orderId)
+        returns (
+            uint128 amountToTransferToSeller,
+            uint128 amountToTransferToBuyer,
+            uint128 feeDeductedFromBuyerAmount,
+            uint128 feeDeductedFromSellerAmount
+        )
+    {
+        // Check: the order is open.
+        Escrow.Status status = _statusOf(orderId);
+        if (status != Escrow.Status.OPEN) {
+            revert Errors.SablierEscrow_OrderNotOpen(orderId, status);
+        }
+
+        Escrow.Order storage order = _orders[orderId];
+
+        // Check: if the order has buyer specified, the caller must be the buyer.
+        if (order.buyer != address(0) && msg.sender != order.buyer) {
+            revert Errors.SablierEscrow_CallerNotAuthorized(orderId, msg.sender, order.buyer);
+        }
+
+        // Check: the buy amount meets the minimum asked.
+        if (buyAmount < order.minBuyAmount) {
+            revert Errors.SablierEscrow_InsufficientBuyAmount(buyAmount, order.minBuyAmount);
+        }
+
+        // Effect: mark the order as filled.
+        order.wasFilled = true;
+
+        // Get the trade fee from storage.
+        UD60x18 currentTradeFee = tradeFee;
+
+        amountToTransferToSeller = buyAmount;
+        amountToTransferToBuyer = order.sellAmount;
+
+        // If the fee is non-zero, deduct the fee from both sides.
+        if (currentTradeFee.unwrap() > 0) {
+            // Calculate the fee on the sell amount.
+            feeDeductedFromBuyerAmount = ud(amountToTransferToBuyer).mul(currentTradeFee).intoUint128();
+            amountToTransferToBuyer -= feeDeductedFromBuyerAmount;
+
+            // Calculate the fee on the buy amount.
+            feeDeductedFromSellerAmount = ud(buyAmount).mul(currentTradeFee).intoUint128();
+            amountToTransferToSeller -= feeDeductedFromSellerAmount;
+
+            // Set comptroller as the fee recipient.
+            address feeRecipient = address(comptroller);
+
+            // Interaction: transfer fees to the fee recipient.
+            order.buyToken.safeTransferFrom(msg.sender, feeRecipient, feeDeductedFromSellerAmount);
+            order.sellToken.safeTransfer(feeRecipient, feeDeductedFromBuyerAmount);
+        }
+
+        // Cache the seller address.
+        address seller = order.seller;
+
+        // Interaction: transfer buy token to the seller.
+        order.buyToken.safeTransferFrom(msg.sender, seller, amountToTransferToSeller);
+
+        // Interaction: transfer sell tokens to the buyer.
+        order.sellToken.safeTransfer(msg.sender, amountToTransferToBuyer);
+
+        // Log the event.
+        emit FillOrder({
+            orderId: orderId,
+            buyer: msg.sender,
+            seller: seller,
+            sellAmount: amountToTransferToBuyer,
+            buyAmount: amountToTransferToSeller,
+            feeDeductedFromBuyerAmount: feeDeductedFromBuyerAmount,
+            feeDeductedFromSellerAmount: feeDeductedFromSellerAmount
+        });
+    }
+
+    /// @inheritdoc ISablierEscrow
+    function setNativeToken(address newNativeToken) external override onlyComptroller {
+        // Check: provided token is not zero address.
+        if (newNativeToken == address(0)) {
+            revert Errors.SablierEscrow_NativeTokenZeroAddress();
+        }
+
+        // Check: native token is not set.
+        if (nativeToken != address(0)) {
+            revert Errors.SablierEscrow_NativeTokenAlreadySet(nativeToken);
+        }
+
+        // Effect: set the native token.
+        nativeToken = newNativeToken;
+
+        // Log the update.
+        emit SetNativeToken({ comptroller: msg.sender, nativeToken: newNativeToken });
+    }
+
+    /// @inheritdoc ISablierEscrow
+    function setTradeFee(UD60x18 newTradeFee) external override onlyComptroller {
+        // Check: the new trade fee does not exceed the maximum trade fee.
+        _notTooHigh(newTradeFee);
+
+        // Cache the current trade fee for the event.
+        UD60x18 previousTradeFee = tradeFee;
+
+        // Effect: set the new trade fee.
+        tradeFee = newTradeFee;
+
+        // Log the event.
+        emit SetTradeFee({ caller: msg.sender, previousTradeFee: previousTradeFee, newTradeFee: newTradeFee });
+    }
+}