feat(protocol)!: cache cross-chain data in the signal service as signals

packages/protocol/contracts/L1/TaikoL1.sol

@@ -32,14 +32,7 @@ import "./TaikoEvents.sol";
 /// layers"). The contract also handles the deposit and withdrawal of Taiko
 /// tokens and Ether.
 /// This contract doesn't hold any Ether. Ether deposited to L2 are held by the Bridge contract.
-contract TaikoL1 is
-    EssentialContract,
-    ITaikoL1,
-    ICrossChainSync,
-    ITierProvider,
-    TaikoEvents,
-    TaikoErrors
-{
+contract TaikoL1 is EssentialContract, ITaikoL1, ITierProvider, TaikoEvents, TaikoErrors {
     TaikoData.State public state;
     uint256[100] private __gap;
 
@@ -163,19 +156,6 @@ contract TaikoL1 is
         return LibUtils.getTransition(state, getConfig(), blockId, parentHash);
     }
 
-    /// @inheritdoc ICrossChainSync
-    /// @notice Important: as this contract doesn't send each block's state root as a signal when
-    /// the block is verified, bridging developers should subscribe to CrossChainSynced events
-    /// to ensure all synced state roots are verifiable using merkle proofs.
-    function getSyncedSnippet(uint64 blockId)
-        public
-        view
-        override
-        returns (ICrossChainSync.Snippet memory)
-    {
-        return LibUtils.getSyncedSnippet(state, getConfig(), blockId);
-    }
-
     /// @notice Gets the state variables of the TaikoL1 contract.
     function getStateVariables()
         public

packages/protocol/contracts/L1/libs/LibUtils.sol

@@ -14,7 +14,6 @@
 
 pragma solidity 0.8.24;
 
-import "../../common/ICrossChainSync.sol";
 import "../TaikoData.sol";
 
 /// @title LibUtils
@@ -53,34 +52,6 @@ library LibUtils {
         ts = state.transitions[slot][tid];
     }
 
-    function getSyncedSnippet(
-        TaikoData.State storage state,
-        TaikoData.Config memory config,
-        uint64 blockId
-    )
-        external
-        view
-        returns (ICrossChainSync.Snippet memory)
-    {
-        uint64 _blockId = blockId == 0 ? state.slotB.lastVerifiedBlockId : blockId;
-        uint64 slot = _blockId % config.blockRingBufferSize;
-
-        TaikoData.Block storage blk = state.blocks[slot];
-
-        if (blk.blockId != _blockId) revert L1_BLOCK_MISMATCH();
-        if (blk.verifiedTransitionId == 0) revert L1_TRANSITION_NOT_FOUND();
-
-        TaikoData.TransitionState storage transition =
-            state.transitions[slot][blk.verifiedTransitionId];
-
-        return ICrossChainSync.Snippet({
-            remoteBlockId: blockId,
-            syncedInBlock: blk.proposedIn,
-            blockHash: transition.blockHash,
-            stateRoot: transition.stateRoot
-        });
-    }
-
     /// @dev Retrieves a block based on its ID.
     function getBlock(
         TaikoData.State storage state,

packages/protocol/contracts/L1/libs/LibVerifying.sol

@@ -38,10 +38,6 @@ library LibVerifying {
         uint8 contestations
     );
 
-    event CrossChainSynced(
-        uint64 indexed syncedInBlock, uint64 indexed blockId, bytes32 blockHash, bytes32 stateRoot
-    );
-
     // Warning: Any errors defined here must also be defined in TaikoErrors.sol.
     error L1_BLOCK_MISMATCH();
     error L1_INVALID_CONFIG();
@@ -243,10 +239,8 @@ library LibVerifying {
                 // This also means if we verified more than one block, only the last one's stateRoot
                 // is sent as a signal and verifiable with merkle proofs, all other blocks'
                 // stateRoot are not.
-                ISignalService(resolver.resolve("signal_service", false)).sendSignal(stateRoot);
-
-                emit CrossChainSynced(
-                    uint64(block.number), lastVerifiedBlockId, blockHash, stateRoot
+                ISignalService(resolver.resolve("signal_service", false)).relayStateRoot(
+                    config.chainId, stateRoot
                 );
             }
         }

packages/protocol/contracts/L2/TaikoL2.sol

@@ -17,7 +17,6 @@ pragma solidity 0.8.24;
 import "lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
 import "lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol";
 
-import "../common/ICrossChainSync.sol";
 import "../signal/ISignalService.sol";
 import "../libs/LibAddress.sol";
 import "../libs/LibMath.sol";
@@ -30,7 +29,7 @@ import "./CrossChainOwned.sol";
 /// It is used to anchor the latest L1 block details to L2 for cross-layer
 /// communication, manage EIP-1559 parameters for gas pricing, and store
 /// verified L1 block information.
-contract TaikoL2 is CrossChainOwned, ICrossChainSync {
+contract TaikoL2 is CrossChainOwned {
     using LibAddress for address;
     using LibMath for uint256;
     using SafeERC20 for IERC20;
@@ -46,14 +45,13 @@ contract TaikoL2 is CrossChainOwned, ICrossChainSync {
     // Mapping from L2 block numbers to their block hashes.
     // All L2 block hashes will be saved in this mapping.
     mapping(uint256 blockId => bytes32 blockHash) public l2Hashes;
-    mapping(uint256 l1height => ICrossChainSync.Snippet) public snippets;
 
     // A hash to check the integrity of public inputs.
-    bytes32 public publicInputHash; // slot 3
-    uint64 public gasExcess; // slot 4
+    bytes32 public publicInputHash; // slot 2
+    uint64 public gasExcess; // slot 3
     uint64 public latestSyncedL1Height;
 
-    uint256[146] private __gap;
+    uint256[147] private __gap;
 
     event Anchored(bytes32 parentHash, uint64 gasExcess);
 
@@ -137,24 +135,13 @@ contract TaikoL2 is CrossChainOwned, ICrossChainSync {
         // Verify the base fee per gas is correct
         uint256 basefee;
         (basefee, gasExcess) = _calc1559BaseFee(config, l1Height, parentGasUsed);
-        if (!skipFeeCheck() && block.basefee != basefee) {
-            revert L2_BASEFEE_MISMATCH();
-        }
 
-        // Store the L1's state root as a signal to the local signal service to
-        // allow for multi-hop bridging.
-        ISignalService(resolve("signal_service", false)).sendSignal(l1StateRoot);
+        verifyBaseFee(basefee);
 
-        emit CrossChainSynced(uint64(block.number), l1Height, l1BlockHash, l1StateRoot);
+        relayStateRoot(ownerChainId, l1StateRoot);
 
         // Update state variables
         l2Hashes[parentId] = blockhash(parentId);
-        snippets[l1Height] = ICrossChainSync.Snippet({
-            remoteBlockId: l1Height,
-            syncedInBlock: uint64(block.number),
-            blockHash: l1BlockHash,
-            stateRoot: l1StateRoot
-        });
         publicInputHash = publicInputHashNew;
         latestSyncedL1Height = l1Height;
 
@@ -171,17 +158,6 @@ contract TaikoL2 is CrossChainOwned, ICrossChainSync {
         }
     }
 
-    /// @inheritdoc ICrossChainSync
-    function getSyncedSnippet(uint64 blockId)
-        public
-        view
-        override
-        returns (ICrossChainSync.Snippet memory)
-    {
-        uint256 id = blockId == 0 ? latestSyncedL1Height : blockId;
-        return snippets[id];
-    }
-
     /// @notice Gets the basefee and gas excess using EIP-1559 configuration for
     /// the given parameters.
     /// @param l1Height The synced L1 height in the next Taiko block
@@ -220,10 +196,20 @@ contract TaikoL2 is CrossChainOwned, ICrossChainSync {
 
     /// @notice Tells if we need to validate basefee (for simulation).
     /// @return Returns true to skip checking basefee mismatch.
-    function skipFeeCheck() public pure virtual returns (bool) {
+    function skipFeeCheck() internal pure virtual returns (bool) {
         return false;
     }
 
+    function verifyBaseFee(uint256 basefee) internal virtual {
+        if (block.basefee != basefee) revert L2_BASEFEE_MISMATCH();
+    }
+
+    function relayStateRoot(uint64 chainId, bytes32 signalRoot) internal virtual {
+        // Store the L1's state root as a signal to the local signal service to
+        // allow for multi-hop bridging.
+        ISignalService(resolve("signal_service", false)).relayStateRoot(chainId, signalRoot);
+    }
+
     function _calcPublicInputHash(uint256 blockId)
         private
         view

packages/protocol/contracts/L2/TaikoL2EIP1559Configurable.sol

@@ -49,4 +49,8 @@ contract TaikoL2EIP1559Configurable is TaikoL2 {
     function getConfig() public view override returns (Config memory) {
         return _config;
     }
+
+    function relayStateRoot(uint64 chainId, bytes32 signalRoot) internal pure override {
+        // Do nothing
+    }
 }

packages/protocol/contracts/libs/LibTrieProof.sol

@@ -8,54 +8,60 @@ pragma solidity ^0.8.24;
 
 import { RLPReader } from "../thirdparty/optimism/rlp/RLPReader.sol";
 import { SecureMerkleTrie } from "../thirdparty/optimism/trie/SecureMerkleTrie.sol";
-
+import "forge-std/console2.sol";
 /**
  * @title LibTrieProof
  */
+
 library LibTrieProof {
     // The consensus format representing account is RLP encoded in the
     // following order: nonce, balance, storageHash, codeHash.
     uint256 private constant ACCOUNT_FIELD_INDEX_STORAGE_HASH = 2;
 
     error LTP_INVALID_ACCOUNT_PROOF();
-    error LTP_INVALID_INCLUSION_PROOF();
+    error LTP_INVALID_STORAGE_PROOF();
 
     /**
      * Verifies that the value of a slot in the storage of an account is value.
      *
-     * @param stateRoot The merkle root of state tree.
+     * @param rootHash The merkle root of state tree.
      * @param addr The address of contract.
      * @param slot The slot in the contract.
      * @param value The value to be verified.
-     * @param mkproof The proof obtained by encoding storage proof.
+     * @param accountProof The account proof.
+     * @param storageProof The storage proof.
+     * @return storageRoot The storage root.
      */
-    function verifyFullMerkleProof(
-        bytes32 stateRoot,
+    function verifyMerkleProof(
+        bytes32 rootHash,
         address addr,
         bytes32 slot,
         bytes memory value,
-        bytes memory mkproof
+        bytes[] memory accountProof,
+        bytes[] memory storageProof
     )
         internal
         pure
+        returns (bytes32 storageRoot)
     {
-        (bytes[] memory accountProof, bytes[] memory storageProof) =
-            abi.decode(mkproof, (bytes[], bytes[]));
-
-        bytes memory rlpAccount =
-            SecureMerkleTrie.get(abi.encodePacked(addr), accountProof, stateRoot);
+        if (accountProof.length == 0) {
+            storageRoot = rootHash;
+        } else {
+            bytes memory rlpAccount =
+                SecureMerkleTrie.get(abi.encodePacked(addr), accountProof, rootHash);
 
-        if (rlpAccount.length == 0) revert LTP_INVALID_ACCOUNT_PROOF();
+            if (rlpAccount.length == 0) revert LTP_INVALID_ACCOUNT_PROOF();
 
-        RLPReader.RLPItem[] memory accountState = RLPReader.readList(rlpAccount);
+            RLPReader.RLPItem[] memory accountState = RLPReader.readList(rlpAccount);
 
-        bytes memory storageRoot =
-            RLPReader.readBytes(accountState[ACCOUNT_FIELD_INDEX_STORAGE_HASH]);
+            storageRoot =
+                bytes32(RLPReader.readBytes(accountState[ACCOUNT_FIELD_INDEX_STORAGE_HASH]));
+        }
 
         bool verified = SecureMerkleTrie.verifyInclusionProof(
             bytes.concat(slot), value, storageProof, bytes32(storageRoot)
         );
 
-        if (!verified) revert LTP_INVALID_INCLUSION_PROOF();
+        if (!verified) revert LTP_INVALID_STORAGE_PROOF();
     }
 }

packages/protocol/contracts/signal/ISignalService.sol

@@ -19,15 +19,17 @@ interface ISignalService {
     /// @notice Send a signal (message) by setting the storage slot to a value
     /// of 1.
     /// @param signal The signal (message) to send.
-    /// @return storageSlot The location in storage where this signal is stored.
-    function sendSignal(bytes32 signal) external returns (bytes32 storageSlot);
+    /// @return slot The location in storage where this signal is stored.
+    function sendSignal(bytes32 signal) external returns (bytes32 slot);
 
     /// @notice Verifies if a particular signal has already been sent.
     /// @param app The address that initiated the signal.
     /// @param signal The signal (message) to send.
     /// @return True if the signal has been sent, otherwise false.
     function isSignalSent(address app, bytes32 signal) external view returns (bool);
 
+    function relayStateRoot(uint64 chainId, bytes32 stateRoot) external returns (bytes32 slot);
+
     /// @notice Verifies if a signal has been received on the target chain.
     /// @param srcChainId The identifier for the source chain from which the
     /// signal originated.
@@ -43,6 +45,5 @@ interface ISignalService {
         bytes calldata proof
     )
         external
-        view
         returns (bool);
 }