feat(protocol)!: re-implement multi-hop bridging with optional caching

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

@@ -18,6 +18,7 @@ import "lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
 import "../../common/AddressResolver.sol";
 import "../../libs/LibMath.sol";
 import "../../signal/ISignalService.sol";
+import "../../signal/LibSignals.sol";
 import "../tiers/ITierProvider.sol";
 import "../TaikoData.sol";
 import "./LibUtils.sol";
@@ -247,7 +248,9 @@ 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);
+                ISignalService(resolver.resolve("signal_service", false)).relayChainData(
+                    config.chainId, LibSignals.STATE_ROOT, stateRoot
+                );
 
                 emit CrossChainSynced(
                     uint64(block.number), lastVerifiedBlockId, blockHash, stateRoot

packages/protocol/contracts/L2/TaikoL2.sol

@@ -19,6 +19,7 @@ import "lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol";
 
 import "../common/ICrossChainSync.sol";
 import "../signal/ISignalService.sol";
+import "../signal/LibSignals.sol";
 import "../libs/LibAddress.sol";
 import "../libs/LibMath.sol";
 import "./Lib1559Math.sol";
@@ -143,7 +144,9 @@ contract TaikoL2 is CrossChainOwned, ICrossChainSync {
 
         // 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);
+        ISignalService(resolve("signal_service", false)).relayChainData(
+            ownerChainId, LibSignals.STATE_ROOT, l1StateRoot
+        );
 
         emit CrossChainSynced(uint64(block.number), l1Height, l1BlockHash, l1StateRoot);
 
@@ -157,7 +160,6 @@ contract TaikoL2 is CrossChainOwned, ICrossChainSync {
         });
         publicInputHash = publicInputHashNew;
         latestSyncedL1Height = l1Height;
-
         emit Anchored(blockhash(parentId), gasExcess);
     }
 

packages/protocol/contracts/bridge/Bridge.sol

@@ -575,7 +575,7 @@ contract Bridge is EssentialContract, IBridge {
     /// @param signal The signal.
     /// @param chainId The ID of the chain the signal is stored on
     /// @param proof The merkle inclusion proof.
-    /// @return True if the message was received.
+    /// @return success True if the message was received.
     function _proveSignalReceived(
         address signalService,
         bytes32 signal,
@@ -584,13 +584,12 @@ contract Bridge is EssentialContract, IBridge {
     )
         private
         view
-        returns (bool)
+        returns (bool success)
     {
         bytes memory data = abi.encodeCall(
             ISignalService.proveSignalReceived,
             (chainId, resolve(chainId, "bridge", false), signal, proof)
         );
-        (bool success, bytes memory ret) = signalService.staticcall(data);
-        return success ? abi.decode(ret, (bool)) : false;
+        (success,) = signalService.staticcall(data);
     }
 }

packages/protocol/contracts/libs/LibTrieProof.sol

@@ -20,37 +20,42 @@ library LibTrieProof {
     error LTP_INVALID_ACCOUNT_PROOF();
     error LTP_INVALID_INCLUSION_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 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.
-     */
-    function verifyFullMerkleProof(
-        bytes32 stateRoot,
+    /// @notice Verifies that the value of a slot in the storage of an account is value.
+    ///
+    /// @param rootHash The merkle root of state tree or the account tree. If accountProof's length
+    /// is zero, it is used as the account's storage root, otherwise it will be used as the state
+    /// root.
+    /// @param addr The address of contract.
+    /// @param slot The slot in the contract.
+    /// @param value The value to be verified.
+    /// @param accountProof The account proof
+    /// @param storageProof The storage proof
+    /// @return storageRoot The account's storage root
+    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[]));
+        if (accountProof.length != 0) {
+            bytes memory rlpAccount =
+                SecureMerkleTrie.get(abi.encodePacked(addr), accountProof, rootHash);
 
-        bytes memory rlpAccount =
-            SecureMerkleTrie.get(abi.encodePacked(addr), accountProof, stateRoot);
+            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]));
+        } else {
+            storageRoot = rootHash;
+        }
 
         bool verified = SecureMerkleTrie.verifyInclusionProof(
             bytes.concat(slot), value, storageProof, bytes32(storageRoot)

packages/protocol/contracts/signal/ISignalService.sol

@@ -16,33 +16,43 @@ pragma solidity 0.8.24;
 /// a merkle proof.
 
 interface ISignalService {
-    /// @notice Send a signal (message) by setting the storage slot to a value
-    /// of 1.
+    /// @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) that was sent.
-    /// @return True if the signal has been sent, otherwise false.
-    function isSignalSent(address app, bytes32 signal) external view returns (bool);
+    /// @notice Relay a data from a remote chain locally as a signal. The signal is calculated
+    /// uniquely from chainId, kind, and data.
+    /// @param chainId The remote chainId.
+    /// @param kind A value to mark the data type.
+    /// @param data The remote data.
+    /// @return slot The location in storage where this signal is stored.
+    function relayChainData(
+        uint64 chainId,
+        bytes32 kind,
+        bytes32 data
+    )
+        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
+    /// @param chainId The identifier for the source chain from which the
     /// signal originated.
     /// @param app The address that initiated the signal.
     /// @param signal The signal (message) to send.
     /// @param proof Merkle proof that the signal was persisted on the
     /// source chain.
-    /// @return True if the signal has been received, otherwise false.
     function proveSignalReceived(
-        uint64 srcChainId,
+        uint64 chainId,
         address app,
         bytes32 signal,
         bytes calldata proof
     )
-        external
-        view
-        returns (bool);
+        external;
+
+    /// @notice Verifies if a particular signal has already been sent.
+    /// @param app The address that initiated the signal.
+    /// @param signal The signal (message) that was sent.
+    /// @return True if the signal has been sent, otherwise false.
+    function isSignalSent(address app, bytes32 signal) external view returns (bool);
 }

packages/protocol/contracts/signal/LibSignals.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+//  _____     _ _         _         _
+// |_   _|_ _(_) |_____  | |   __ _| |__ ___
+//   | |/ _` | | / / _ \ | |__/ _` | '_ (_-<
+//   |_|\__,_|_|_\_\___/ |____\__,_|_.__/__/
+//
+//   Email: [email protected]
+//   Website: https://taiko.xyz
+//   GitHub: https://github.com/taikoxyz
+//   Discord: https://discord.gg/taikoxyz
+//   Twitter: https://twitter.com/taikoxyz
+//   Blog: https://mirror.xyz/labs.taiko.eth
+//   Youtube: https://www.youtube.com/@taikoxyz
+
+pragma solidity 0.8.24;
+
+/// @title LibSignals
+library LibSignals {
+    bytes32 public constant STATE_ROOT = keccak256("STATE_ROOT");
+    bytes32 public constant SIGNAL_ROOT = keccak256("SIGNAL_ROOT");
+}