@inco/lightning 0.8.0-devnet-2 → 0.8.0-devnet-3

package/src/test/TestFeeWithdrawal.t.sol

@@ -57,4 +57,3 @@ contract TestFeeWithdrawal is IncoTest {
     }
 
 }
-

package/src/test/TestIncoUtils.t.sol

@@ -239,4 +239,54 @@ contract TestIncoUtils is Test, IncoUtils {
         assertEq(address(this).balance, balanceBefore - spendAmount);
     }
 
+    /// @notice Test reentrancy guard catches direct reentrant call from function body
+    function testRefundUnspentReentrancyFromFunctionBody() public {
+        vm.expectRevert(IncoUtils.ReentrantCall.selector);
+        this.mockFunctionThatReenters{value: 1 ether}();
+    }
+
+    function mockFunctionThatReenters() external payable refundUnspent {
+        // Try to call another protected function while inside the first one
+        this.mockFunctionNoSpend();
+    }
+
+    /// @notice Test refund=0 when msg.value equals spent exactly
+    function testRefundUnspentWhenMsgValueEqualsSpent() public {
+        // This explicitly tests the refund=0 branch when msg.value == spent
+        uint256 msgValue = 1 ether;
+
+        vm.deal(address(this), msgValue);
+        uint256 balanceBefore = address(this).balance;
+
+        // Spend exactly msg.value, so refund = msg.value - spent = 0
+        this.mockFunctionPartialSpend{value: msgValue}(msgValue);
+
+        // All ETH was spent, no refund
+        assertEq(address(this).balance, balanceBefore - msgValue);
+    }
+
+    /// @notice Test when contract receives more ETH during execution than was sent
+    /// This triggers the balanceAfter > balanceBefore branch (spent = 0)
+    function testRefundUnspentWhenReceivingMoreThanSent() public {
+        uint256 msgValue = 0.5 ether;
+        uint256 incomingEth = 1 ether; // More than msg.value
+
+        vm.deal(address(sender), incomingEth);
+        vm.deal(address(this), msgValue);
+        uint256 balanceBefore = address(this).balance;
+
+        // During execution, we receive 1 ETH (more than we sent)
+        this.mockFunctionReceivesEthDuringExecution{value: msgValue}(payable(address(sender)), incomingEth);
+
+        // Execution trace:
+        // 1. balanceBefore (modifier) = 0.5 ETH (self-call doesn't change balance)
+        // 2. Sender sends 1 ETH during execution
+        // 3. balanceAfter (modifier) = 0.5 + 1 = 1.5 ETH
+        // 4. spent = balanceBefore > balanceAfter ? ... : 0 = 0 (since 0.5 < 1.5)
+        // 5. refund = msg.value - spent = 0.5 - 0 = 0.5 ETH
+        // 6. Refund sent to msg.sender (this contract) = self-transfer, no balance change
+        // 7. Final balance = 1.5 ETH = balanceBefore (test) + incomingEth
+        assertEq(address(this).balance, balanceBefore + incomingEth);
+    }
+
 }