handle intents for native token

Author: lmcorbalan

solidity/src/Base7683.sol

@@ -3,6 +3,7 @@ pragma solidity 0.8.25;
 
 import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import { Address } from "@openzeppelin/contracts/utils/Address.sol";
 import { TypeCasts } from "@hyperlane-xyz/libs/TypeCasts.sol";
 import { IPermit2, ISignatureTransfer } from "@uniswap/permit2/src/interfaces/IPermit2.sol";
 
@@ -76,6 +77,7 @@ abstract contract Base7683 is IOriginSettler, IDestinationSettler {
     error OrderFillNotExpired();
     error InvalidDomain();
     error InvalidSender();
+    error InvalidAmount();
 
     // ============ Constructor ============
 
@@ -120,7 +122,7 @@ abstract contract Base7683 is IOriginSettler, IDestinationSettler {
     /// @dev To be called by the user
     /// @dev This method must emit the Open event
     /// @param order The OnchainCrossChainOrder definition
-    function open(OnchainCrossChainOrder calldata order) external {
+    function open(OnchainCrossChainOrder calldata order) external payable {
         (ResolvedCrossChainOrder memory resolvedOrder, OrderData memory orderData) = _resolvedOrder(
             order.orderDataType,
             msg.sender,
@@ -135,9 +137,13 @@ abstract contract Base7683 is IOriginSettler, IDestinationSettler {
         orderStatus[orderId] = OrderStatus.OPENED;
         senderNonce[msg.sender] += 1;
 
-        IERC20(TypeCasts.bytes32ToAddress(orderData.inputToken)).safeTransferFrom(
-            msg.sender, address(this), orderData.amountIn
-        );
+        if (orderData.inputToken != TypeCasts.addressToBytes32(address(0))) {
+            IERC20(TypeCasts.bytes32ToAddress(orderData.inputToken)).safeTransferFrom(
+                msg.sender, address(this), orderData.amountIn
+            );
+        } else {
+            if (msg.value != orderData.amountIn) revert InvalidAmount();
+        }
 
         emit Open(orderId, resolvedOrder);
     }
@@ -182,7 +188,7 @@ abstract contract Base7683 is IOriginSettler, IDestinationSettler {
     /// @param _originData Data emitted on the origin to parameterize the fill
     /// @param _fillerData Data provided by the filler to inform the fill or express their preferences. It should
     /// contain the bytes32 encoded address of the receiver which is the used at settlement time
-    function fill(bytes32 _orderId, bytes calldata _originData, bytes calldata _fillerData) external virtual {
+    function fill(bytes32 _orderId, bytes calldata _originData, bytes calldata _fillerData) external payable virtual {
         OrderData memory orderData = OrderEncoder.decode(_originData);
 
         if (_orderId != _getOrderId(orderData)) revert InvalidOrderId();
@@ -197,9 +203,14 @@ abstract contract Base7683 is IOriginSettler, IDestinationSettler {
 
         emit Filled(_orderId, _originData, _fillerData);
 
-        IERC20(TypeCasts.bytes32ToAddress(orderData.outputToken)).safeTransferFrom(
-            msg.sender, TypeCasts.bytes32ToAddress(orderData.recipient), orderData.amountOut
-        );
+        if (orderData.outputToken != TypeCasts.addressToBytes32(address(0))) {
+            IERC20(TypeCasts.bytes32ToAddress(orderData.outputToken)).safeTransferFrom(
+                msg.sender, TypeCasts.bytes32ToAddress(orderData.recipient), orderData.amountOut
+            );
+        } else {
+            if (msg.value != orderData.amountOut) revert InvalidAmount();
+            Address.sendValue(payable(TypeCasts.bytes32ToAddress(orderData.recipient)), orderData.amountOut);
+        }
     }
 
     function settle(bytes32[] calldata _orderIds) external payable {
@@ -365,9 +376,13 @@ abstract contract Base7683 is IOriginSettler, IDestinationSettler {
 
         emit Settled(_orderId, receiver);
 
-        IERC20(TypeCasts.bytes32ToAddress(orderData.inputToken)).safeTransfer(
-            receiver, orderData.amountIn
-        );
+        if (orderData.inputToken != TypeCasts.addressToBytes32(address(0))) {
+            IERC20(TypeCasts.bytes32ToAddress(orderData.inputToken)).safeTransfer(
+                receiver, orderData.amountIn
+            );
+        } else {
+            Address.sendValue(payable(receiver), orderData.amountIn);
+        }
     }
 
     /**
@@ -386,9 +401,13 @@ abstract contract Base7683 is IOriginSettler, IDestinationSettler {
 
         emit Refunded(_orderId, orderSender);
 
-        IERC20(TypeCasts.bytes32ToAddress(orderData.inputToken)).safeTransfer(
-            orderSender, orderData.amountIn
-        );
+        if (orderData.inputToken != TypeCasts.addressToBytes32(address(0))) {
+            IERC20(TypeCasts.bytes32ToAddress(orderData.inputToken)).safeTransfer(
+                orderSender, orderData.amountIn
+            );
+        } else {
+            Address.sendValue(payable(orderSender), orderData.amountIn);
+        }
     }
 
     /**

solidity/src/ERC7683/IERC7683.sol

@@ -121,7 +121,7 @@ interface IOriginSettler {
     /// @dev To be called by the user
     /// @dev This method must emit the Open event
     /// @param order The OnchainCrossChainOrder definition
-    function open(OnchainCrossChainOrder calldata order) external;
+    function open(OnchainCrossChainOrder calldata order) external payable;
 
     /// @notice Resolves a specific GaslessCrossChainOrder into a generic ResolvedCrossChainOrder
     /// @dev Intended to improve standardized integration of various order types and settlement contracts
@@ -150,5 +150,5 @@ interface IDestinationSettler {
     /// @param orderId Unique order identifier for this order
     /// @param originData Data emitted on the origin to parameterize the fill
     /// @param fillerData Data provided by the filler to inform the fill or express their preferences
-    function fill(bytes32 orderId, bytes calldata originData, bytes calldata fillerData) external;
+    function fill(bytes32 orderId, bytes calldata originData, bytes calldata fillerData) external payable;
 }

solidity/test/Base7683.t.sol

@@ -255,6 +255,17 @@ contract Base7683Test is Test, DeployPermit2 {
         return _balances;
     }
 
+    function balances() internal view returns (uint256[] memory) {
+        uint256[] memory _balances = new uint256[](5);
+        _balances[0] = kakaroto.balance;
+        _balances[1] = karpincho.balance;
+        _balances[2] = vegeta.balance;
+        _balances[3] = counterpart.balance;
+        _balances[4] = address(base).balance;
+
+        return _balances;
+    }
+
     function orderDataById(bytes32 orderId) internal view returns (OrderData memory orderData) {
         (
             bytes32 _sender,
@@ -348,6 +359,70 @@ contract Base7683Test is Test, DeployPermit2 {
         vm.stopPrank();
     }
 
+    function test_open__native_token_works(uint32 _fillDeadline) public {
+        OrderData memory orderData = prepareOrderData();
+        orderData.inputToken = TypeCasts.addressToBytes32(address(0));
+        orderData.outputToken = TypeCasts.addressToBytes32(address(0));
+
+        OnchainCrossChainOrder memory order =
+            prepareOnchainOrder(orderData, _fillDeadline, OrderEncoder.orderDataType());
+
+        deal(kakaroto, 1_000_000);
+
+        vm.startPrank(kakaroto);
+
+        uint256 nonceBefore = base.senderNonce(kakaroto);
+        uint256[] memory balancesBefore = balances();
+
+        vm.recordLogs();
+        base.open{value: amount}(order);
+
+        (bytes32 orderId, ResolvedCrossChainOrder memory resolvedOrder) = getOrderIDFromLogs();
+
+        // assertResolvedOrder(resolvedOrder, orderData, kakaroto, _fillDeadline, type(uint32).max);
+        assertEq(resolvedOrder.maxSpent.length, 1);
+        assertEq(resolvedOrder.maxSpent[0].token, TypeCasts.addressToBytes32(address(0)));
+        assertEq(resolvedOrder.maxSpent[0].amount, amount);
+        assertEq(resolvedOrder.maxSpent[0].recipient, base.counterpart());
+        assertEq(resolvedOrder.maxSpent[0].chainId, destination);
+
+        assertEq(resolvedOrder.minReceived.length, 1);
+        assertEq(resolvedOrder.minReceived[0].token, TypeCasts.addressToBytes32(address(0)));
+        assertEq(resolvedOrder.minReceived[0].amount, amount);
+        assertEq(resolvedOrder.minReceived[0].recipient, bytes32(0));
+        assertEq(resolvedOrder.minReceived[0].chainId, origin);
+
+        assertEq(resolvedOrder.fillInstructions.length, 1);
+        assertEq(resolvedOrder.fillInstructions[0].destinationChainId, destination);
+        assertEq(resolvedOrder.fillInstructions[0].destinationSettler, base.counterpart());
+
+        orderData.fillDeadline = _fillDeadline;
+        assertEq(resolvedOrder.fillInstructions[0].originData, OrderEncoder.encode(orderData));
+
+        assertEq(resolvedOrder.user, kakaroto);
+        assertEq(resolvedOrder.originChainId, base.localDomain());
+        assertEq(resolvedOrder.openDeadline, type(uint32).max);
+        assertEq(resolvedOrder.fillDeadline, _fillDeadline);
+
+        // assertOpenOrder(orderId, kakaroto, orderData, balancesBefore, kakaroto, nonceBefore);
+        OrderData memory savedOrderData = orderDataById(orderId);
+
+        assertEq(base.senderNonce(kakaroto), nonceBefore + 1);
+        assertEq(OrderEncoder.encode(savedOrderData), OrderEncoder.encode(orderData));
+        // assertOrder(orderId, orderData, balancesBefore, inputToken, user, address(base), Base7683.OrderStatus.OPENED);
+
+        Base7683.OrderStatus status = base.orderStatus(orderId);
+
+        assertEq(OrderEncoder.encode(savedOrderData), OrderEncoder.encode(orderData));
+        assertTrue(status == Base7683.OrderStatus.OPENED);
+
+        uint256[] memory balancesAfter = balances();
+        assertEq(balancesBefore[balanceId[kakaroto]] - amount, balancesAfter[balanceId[kakaroto]]);
+        assertEq(balancesBefore[balanceId[address(base)]] + amount, balancesAfter[balanceId[address(base)]]);
+
+        vm.stopPrank();
+    }
+
     function getPermitWitnessTransferSignature(
         ISignatureTransfer.PermitTransferFrom memory permit,
         uint256 privateKey,
@@ -475,6 +550,45 @@ contract Base7683Test is Test, DeployPermit2 {
         vm.stopPrank();
     }
 
+    function test_fill_native_works() public {
+        OrderData memory orderData = prepareOrderData();
+        orderData.inputToken = TypeCasts.addressToBytes32(address(0));
+        orderData.outputToken = TypeCasts.addressToBytes32(address(0));
+
+        orderData.originDomain = destination;
+        orderData.destinationDomain = origin;
+
+        bytes32 orderId = OrderEncoder.id(orderData);
+
+        deal(vegeta, 1_000_000);
+
+        uint256[] memory balancesBefore = balances();
+
+        vm.startPrank(vegeta);
+
+        bytes memory fillerData = abi.encode(TypeCasts.addressToBytes32(vegeta));
+
+        vm.expectEmit(false, false, false, true);
+        emit Filled(orderId, OrderEncoder.encode(orderData), fillerData);
+
+        base.fill{value: amount}(orderId, OrderEncoder.encode(orderData), fillerData);
+
+        // assertOrder(orderId, orderData, balancesBefore, outputToken, vegeta, karpincho, Base7683.OrderStatus.FILLED);
+        OrderData memory savedOrderData = orderDataById(orderId);
+        Base7683.OrderStatus status = base.orderStatus(orderId);
+
+        assertEq(OrderEncoder.encode(savedOrderData), OrderEncoder.encode(orderData));
+        assertTrue(status == Base7683.OrderStatus.FILLED);
+
+        uint256[] memory balancesAfter = balances();
+        assertEq(balancesBefore[balanceId[vegeta]] - amount, balancesAfter[balanceId[vegeta]]);
+        assertEq(balancesBefore[balanceId[karpincho]] + amount, balancesAfter[balanceId[karpincho]]);
+
+        assertEq(base.orderFillerData(orderId), fillerData);
+
+        vm.stopPrank();
+    }
+
     // settle
     function test_settle_works() public {
         OrderData memory orderData = prepareOrderData();
@@ -562,6 +676,40 @@ contract Base7683Test is Test, DeployPermit2 {
         assertEq(balancesBefore[balanceId[vegeta]] + amount, balancesAfter[balanceId[vegeta]]);
     }
 
+    function test_settleOrder_native_works() public {
+        OrderData memory orderData = prepareOrderData();
+        orderData.inputToken = TypeCasts.addressToBytes32(address(0));
+        orderData.outputToken = TypeCasts.addressToBytes32(address(0));
+
+        OnchainCrossChainOrder memory order =
+            prepareOnchainOrder(orderData, orderData.fillDeadline, OrderEncoder.orderDataType());
+
+        deal(kakaroto, 1_000_000);
+
+        vm.startPrank(kakaroto);
+
+        vm.recordLogs();
+        base.open{value: amount}(order);
+
+        (bytes32 orderId,) = getOrderIDFromLogs();
+
+        vm.stopPrank();
+
+        uint256[] memory balancesBefore = balances();
+
+        vm.expectEmit(false, false, false, true);
+        emit Settled(orderId, vegeta);
+
+        vm.prank(vegeta);
+        base.settleOrder(orderId);
+
+        uint256[] memory balancesAfter = balances();
+
+        assertTrue(base.orderStatus(orderId) == Base7683.OrderStatus.SETTLED);
+        assertEq(balancesBefore[balanceId[address(base)]] - amount, balancesAfter[balanceId[address(base)]]);
+        assertEq(balancesBefore[balanceId[vegeta]] + amount, balancesAfter[balanceId[vegeta]]);
+    }
+
     // _refundOrder
     function test_refundOrder_works() public {
         OrderData memory orderData = prepareOrderData();
@@ -594,4 +742,40 @@ contract Base7683Test is Test, DeployPermit2 {
         assertEq(balancesBefore[balanceId[address(base)]] - amount, balancesAfter[balanceId[address(base)]]);
         assertEq(balancesBefore[balanceId[kakaroto]] + amount, balancesAfter[balanceId[kakaroto]]);
     }
+
+    function test_refundOrder_native_works() public {
+        OrderData memory orderData = prepareOrderData();
+        orderData.inputToken = TypeCasts.addressToBytes32(address(0));
+        orderData.outputToken = TypeCasts.addressToBytes32(address(0));
+
+        OnchainCrossChainOrder memory order =
+            prepareOnchainOrder(orderData, orderData.fillDeadline, OrderEncoder.orderDataType());
+
+        deal(kakaroto, 1_000_000);
+
+        vm.startPrank(kakaroto);
+
+        vm.recordLogs();
+        base.open{value: amount}(order);
+
+        (bytes32 orderId,) = getOrderIDFromLogs();
+
+        vm.stopPrank();
+
+        vm.warp(orderData.fillDeadline + 1);
+
+        uint256[] memory balancesBefore = balances();
+
+        vm.expectEmit(false, false, false, true);
+        emit Refunded(orderId, kakaroto);
+
+        vm.prank(vegeta);
+        base.refundOrder(orderId);
+
+        uint256[] memory balancesAfter = balances();
+
+        assertTrue(base.orderStatus(orderId) == Base7683.OrderStatus.REFUNDED);
+        assertEq(balancesBefore[balanceId[address(base)]] - amount, balancesAfter[balanceId[address(base)]]);
+        assertEq(balancesBefore[balanceId[kakaroto]] + amount, balancesAfter[balanceId[kakaroto]]);
+    }
 }