support for native tokens in depositAndRegister

Author: mgretzke

src/allocators/OnChainAllocator.sol

@@ -86,13 +86,28 @@ contract OnChainAllocator is IOnChainAllocator {
         uint32 expires,
         bytes32 typehash,
         bytes32 witness
-    ) public returns (bytes32 claimHash, uint256[] memory registeredAmounts, uint256 nonce) {
+    ) public payable returns (bytes32 claimHash, uint256[] memory registeredAmounts, uint256 nonce) {
         nonce = _getAndUpdateNonce(msg.sender, recipient);
 
+        if (commitments.length == 0) {
+            revert InvalidCommitments();
+        }
+
         uint256[2][] memory idsAndAmounts = new uint256[2][](commitments.length);
 
         uint256 minResetPeriod = type(uint256).max;
-        for (uint256 i = 0; i < commitments.length; i++) {
+        uint256 i = 0;
+        if (commitments[i].token == address(0)) {
+            minResetPeriod = _checkInput(commitments[i], recipient, expires, minResetPeriod);
+            idsAndAmounts[i][0] = AL.toId(commitments[i].lockTag, commitments[i].token);
+
+            if (commitments[i].amount != 0 && commitments[i].amount != msg.value) {
+                revert InvalidAmount(commitments[i].amount);
+            }
+            idsAndAmounts[i][1] = msg.value;
+            i++;
+        }
+        for (; i < commitments.length; i++) {
             minResetPeriod = _checkInput(commitments[i], recipient, expires, minResetPeriod);
             idsAndAmounts[i][0] = AL.toId(commitments[i].lockTag, commitments[i].token);
             uint224 amount = uint224(commitments[i].amount);
@@ -114,7 +129,7 @@ contract OnChainAllocator is IOnChainAllocator {
         }
 
         // Deposit the tokens and register the claim in the compact
-        (claimHash, registeredAmounts) = ITheCompact(COMPACT_CONTRACT).batchDepositAndRegisterFor(
+        (claimHash, registeredAmounts) = ITheCompact(COMPACT_CONTRACT).batchDepositAndRegisterFor{value: msg.value}(
             recipient, idsAndAmounts, arbiter, nonce, expires, typehash, witness
         );
 

src/interfaces/IOnChainAllocator.sol

@@ -46,6 +46,9 @@ interface IOnChainAllocator is IOnChainAllocation {
     /// @notice Thrown if the provided signature is invalid
     error InvalidSignature(address signer, address expectedSigner);
 
+    /// @notice Thrown if the provided commitments are empty
+    error InvalidCommitments();
+
     /// @notice Registers an allocation for a set of tokens
     /// @param commitments The commitments of the allocations
     /// @param arbiter The arbiter of the allocation
@@ -89,5 +92,5 @@ interface IOnChainAllocator is IOnChainAllocation {
         uint32 expires,
         bytes32 typehash,
         bytes32 witness
-    ) external returns (bytes32 claimHash, uint256[] memory registeredAmounts, uint256 nonce);
+    ) external payable returns (bytes32 claimHash, uint256[] memory registeredAmounts, uint256 nonce);
 }

test/OnChainAllocator.t.sol

@@ -1128,6 +1128,25 @@ contract OnChainAllocatorTest is Test, TestHelper {
         );
     }
 
+    function test_allocateAndRegister_revert_InvalidCommitments() public {
+        Lock[] memory commitments = new Lock[](0);
+
+        vm.expectRevert(abi.encodeWithSelector(IOnChainAllocator.InvalidCommitments.selector));
+        allocator.allocateAndRegister(
+            recipient, commitments, arbiter, defaultExpiration, BATCH_COMPACT_TYPEHASH, bytes32(0)
+        );
+    }
+
+    function test_allocateAndRegister_revert_InvalidAmount_native() public {
+        Lock[] memory commitments = new Lock[](1);
+        commitments[0] = _makeLock(address(0), 1 ether);
+
+        vm.expectRevert(abi.encodeWithSelector(IOnChainAllocator.InvalidAmount.selector, commitments[0].amount));
+        allocator.allocateAndRegister{value: commitments[0].amount + 1}(
+            recipient, commitments, arbiter, defaultExpiration, BATCH_COMPACT_TYPEHASH, bytes32(0)
+        );
+    }
+
     function test_allocateAndRegister_revert_InvalidAmount() public {
         Lock[] memory commitments = new Lock[](1);
         commitments[0] = _makeLock(address(usdc), uint256(type(uint224).max) + 1);
@@ -1274,6 +1293,43 @@ contract OnChainAllocatorTest is Test, TestHelper {
         );
     }
 
+    function test_allocateAndRegister_success_multiple() public {
+        uint256 amount1 = 1 ether;
+        uint256 amount2 = 2 ether;
+
+        usdc.mint(address(allocator), amount2);
+
+        Lock[] memory commitments = new Lock[](2);
+        commitments[0] = _makeLock(address(0), amount1);
+        commitments[1] = _makeLock(address(usdc), amount2);
+
+        vm.deal(caller, amount1);
+        vm.prank(caller);
+        (bytes32 claimHash, uint256[] memory registeredAmounts, uint256 nonce) = allocator.allocateAndRegister{
+            value: amount1
+        }(recipient, commitments, arbiter, defaultExpiration, BATCH_COMPACT_TYPEHASH, bytes32(0));
+
+        uint256 id1 = _toId(Scope.Multichain, ResetPeriod.TenMinutes, address(allocator), address(0));
+        uint256 id2 = _toId(Scope.Multichain, ResetPeriod.TenMinutes, address(allocator), address(usdc));
+
+        assertEq(registeredAmounts.length, 2);
+        assertEq(registeredAmounts[0], amount1);
+        assertEq(registeredAmounts[1], amount2);
+
+        assertEq(ERC6909(address(compact)).balanceOf(recipient, id1), amount1);
+        assertEq(ERC6909(address(compact)).balanceOf(recipient, id2), amount2);
+
+        uint256[2][] memory idsAndAmounts = new uint256[2][](2);
+        idsAndAmounts[0][0] = id1;
+        idsAndAmounts[0][1] = amount1;
+        idsAndAmounts[1][0] = id2;
+        idsAndAmounts[1][1] = amount2;
+
+        assertTrue(
+            allocator.isClaimAuthorized(claimHash, arbiter, recipient, nonce, defaultExpiration, idsAndAmounts, '')
+        );
+    }
+
     function test_allocateAndRegister_tokensImmediatelyAllocated() public {
         uint256 amount1 = 1 ether;
         uint256 amount2 = 2 ether;