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

package/src/test/TestEventCounter.t.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: No License
+pragma solidity ^0.8;
+
+import {IncoTest} from "./IncoTest.sol";
+import {inco} from "../Lib.sol";
+import {EventCounter} from "../lightning-parts/primitives/EventCounter.sol";
+
+/// @dev Test harness to expose internal getNewEventId() for coverage
+contract EventCounterHarness is EventCounter {
+
+    function exposed_getNewEventId() external returns (uint256) {
+        return getNewEventId();
+    }
+
+}
+
+contract TestEventCounter is IncoTest {
+
+    /// @dev Tests the deprecated getEventCounter() function for coverage.
+    /// getEventCounter() is deprecated in favor of getNextEventId().
+    function testGetEventCounter_Deprecated() public view {
+        // Both functions should return the same value
+        uint256 counter = inco.getEventCounter();
+        uint256 nextId = inco.getNextEventId();
+        assertEq(counter, nextId, "getEventCounter should equal getNextEventId");
+    }
+
+    /// @dev Tests getNewEventId() which increments the counter and returns the new ID.
+    /// This function is used by lightning-preview's EList operations.
+    function testGetNewEventId() public {
+        EventCounterHarness harness = new EventCounterHarness();
+
+        uint256 firstId = harness.exposed_getNewEventId();
+        assertEq(firstId, 0, "First event ID should be 0");
+
+        uint256 secondId = harness.exposed_getNewEventId();
+        assertEq(secondId, 1, "Second event ID should be 1");
+
+        uint256 thirdId = harness.exposed_getNewEventId();
+        assertEq(thirdId, 2, "Third event ID should be 2");
+    }
+
+}

package/src/test/TestFakeInfra.t.sol

@@ -139,9 +139,10 @@ contract TestFakeInfra is IncoTest {
     function testEShr() public {
         euint256 a = e.asEuint256(10);
         euint256 b = e.asEuint256(4);
-        euint256 c = a.xor(b);
+
+        euint256 c = a.shr(b);
         processAllOperations();
-        assertEq(getUint256Value(c), 14);
+        assertEq(getUint256Value(c), 0);
     }
 
     function testERotl() public {
@@ -546,6 +547,12 @@ contract TestFakeInfra is IncoTest {
         a.add(euint256.wrap(randomHandle));
     }
 
+    function testECastAllowed() public {
+        bytes32 invalidHandle = keccak256("invalid handle");
+        vm.expectRevert(abi.encodeWithSelector(SenderNotAllowedForHandle.selector, invalidHandle, address(this)));
+        euint256.wrap(invalidHandle).asEbool();
+    }
+
     function testCreateQuote() public view {
         bytes memory mrtd =
             hex"1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";

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);
+    }
+
 }