chore: update

Author: ypatil12

pkg/bindings/OperatorTableUpdater/binding.go

@@ -86,6 +86,12 @@ contract OperatorTableUpdater is
         uint32 referenceTimestamp,
         uint32 referenceBlockNumber
     ) external onlyWhenNotPaused(PAUSED_GLOBAL_ROOT_UPDATE) nonReentrant {
+        // Silently return if the `globalTableRoot` is already confirmed
+        // We do this to avoid race conditions with the offchain transport of the operator table
+        if (_isRootValid[globalTableRoot]) {
+            return;
+        }
+
         // Table roots can only be updated for current or past timestamps and after the latest reference timestamp
         require(referenceTimestamp <= block.timestamp, GlobalTableRootInFuture());
         require(referenceTimestamp > _latestReferenceTimestamp, GlobalTableRootStale());

src/contracts/multichain/OperatorTableUpdater.sol

@@ -303,6 +303,80 @@ contract OperatorTableUpdaterUnitTests_confirmGlobalTableRoot is OperatorTableUp
         assertEq(operatorTableUpdater.getReferenceBlockNumberByTimestamp(referenceTimestamp), referenceBlockNumber);
         assertEq(operatorTableUpdater.getReferenceTimestampByBlockNumber(referenceBlockNumber), referenceTimestamp);
     }
+
+    function testFuzz_silentReturn_alreadyConfirmed(Randomness r) public rand(r) {
+        uint32 referenceTimestamp = r.Uint32(operatorTableUpdater.getLatestReferenceTimestamp() + 1, type(uint32).max);
+        uint32 referenceBlockNumber = r.Uint32();
+        cheats.warp(uint(referenceTimestamp));
+        bytes32 globalTableRoot = bytes32(r.Uint256(1, type(uint).max));
+        mockCertificate.messageHash =
+            operatorTableUpdater.getGlobalTableUpdateMessageHash(globalTableRoot, referenceTimestamp, referenceBlockNumber);
+        _setIsValidCertificate(mockCertificate, true);
+
+        // First confirmation should succeed and emit event
+        operatorTableUpdater.confirmGlobalTableRoot(mockCertificate, globalTableRoot, referenceTimestamp, referenceBlockNumber);
+
+        // Verify the root is now valid
+        assertTrue(operatorTableUpdater.isRootValid(globalTableRoot), "Global table root should be valid after first confirmation");
+
+        // Store initial state to verify it doesn't change
+        bytes32 initialCurrentRoot = operatorTableUpdater.getCurrentGlobalTableRoot();
+        uint32 initialLatestTimestamp = operatorTableUpdater.getLatestReferenceTimestamp();
+        uint32 initialLatestBlockNumber = operatorTableUpdater.getLatestReferenceBlockNumber();
+
+        // Second confirmation with the same root should silently return without emitting events
+        // We should NOT expect any events to be emitted
+        cheats.recordLogs();
+        operatorTableUpdater.confirmGlobalTableRoot(mockCertificate, globalTableRoot, referenceTimestamp, referenceBlockNumber);
+
+        // Verify no events were emitted on the second call
+        Vm.Log[] memory logs = cheats.getRecordedLogs();
+        assertEq(logs.length, 0, "No events should be emitted when confirming an already valid root");
+
+        // Verify state remains unchanged after silent return
+        assertEq(operatorTableUpdater.getCurrentGlobalTableRoot(), initialCurrentRoot, "Current root should remain unchanged");
+        assertEq(operatorTableUpdater.getLatestReferenceTimestamp(), initialLatestTimestamp, "Latest timestamp should remain unchanged");
+        assertEq(
+            operatorTableUpdater.getLatestReferenceBlockNumber(), initialLatestBlockNumber, "Latest block number should remain unchanged"
+        );
+        assertTrue(operatorTableUpdater.isRootValid(globalTableRoot), "Global table root should still be valid");
+    }
+
+    function test_silentReturn_alreadyConfirmed_differentCertificate() public {
+        uint32 referenceTimestamp = uint32(block.timestamp);
+        uint32 referenceBlockNumber = uint32(block.number);
+        bytes32 globalTableRoot = bytes32(uint(12_345));
+
+        // First certificate
+        BN254Certificate memory firstCertificate;
+        firstCertificate.referenceTimestamp = 1; // GENERATOR_REFERENCE_TIMESTAMP
+        firstCertificate.messageHash =
+            operatorTableUpdater.getGlobalTableUpdateMessageHash(globalTableRoot, referenceTimestamp, referenceBlockNumber);
+        _setIsValidCertificate(firstCertificate, true);
+
+        // Confirm with first certificate
+        cheats.expectEmit(true, true, true, true);
+        emit NewGlobalTableRoot(referenceTimestamp, globalTableRoot);
+        operatorTableUpdater.confirmGlobalTableRoot(firstCertificate, globalTableRoot, referenceTimestamp, referenceBlockNumber);
+
+        // Create a different certificate for the same global table root
+        BN254Certificate memory secondCertificate;
+        secondCertificate.referenceTimestamp = 1; // GENERATOR_REFERENCE_TIMESTAMP
+        secondCertificate.messageHash = firstCertificate.messageHash; // Same message hash
+        secondCertificate.signature = BN254.G1Point({X: 999, Y: 888}); // Different signature to make it a different certificate
+        _setIsValidCertificate(secondCertificate, true);
+
+        // Second confirmation with different certificate but same root should silently return
+        cheats.recordLogs();
+        operatorTableUpdater.confirmGlobalTableRoot(secondCertificate, globalTableRoot, referenceTimestamp, referenceBlockNumber);
+
+        // Verify no events were emitted
+        Vm.Log[] memory logs = cheats.getRecordedLogs();
+        assertEq(logs.length, 0, "No events should be emitted when confirming an already valid root with different certificate");
+
+        // Verify the root is still valid
+        assertTrue(operatorTableUpdater.isRootValid(globalTableRoot), "Global table root should still be valid");
+    }
 }
 
 contract OperatorTableUpdaterUnitTests_updateOperatorTable_BN254 is OperatorTableUpdaterUnitTests {