remove root as a param

simplify

comment

updated event

explain root

Author: LeoPatOZ

src/libs/LibSignal.sol

@@ -42,7 +42,7 @@ library LibSignal {
 
     /// @dev Signal a `value` at a namespaced slot for the current `block.chainid`.
     function signal(address account, bytes32 value) internal returns (bytes32) {
-        return signal(block.chainid.toUint64(), account, value);
+        return signal(uint64(block.chainid), account, value);
     }
 
     /// @dev Signal a `value` at a namespaced slot. See `deriveSlot`.
@@ -59,25 +59,33 @@ library LibSignal {
 
     /// @dev Returns the storage slot for a signal. Namespaced to the current `block.chainid`.
     function deriveSlot(address account, bytes32 value) internal view returns (bytes32) {
-        return deriveSlot(block.chainid.toUint64(), account, value);
+        return deriveSlot(uint64(block.chainid), account, value);
     }
 
     /// @dev Returns the storage slot for a signal.
     function deriveSlot(uint64 chainId, address account, bytes32 value) internal pure returns (bytes32) {
         return string(abi.encodePacked(chainId, account, value)).erc7201Slot();
     }
 
-    /// @dev Performs a storage proof on the `account`. User must ensure the `root` is trusted for the given `chainId`.
+    /// @dev Performs a storage proof verification for a signal stored on the contract using this library
+    /// @param root The state root from the source chain to verify against
+    /// @param chainId The chain ID of the source chain where the signal was sent
+    /// @param sender The address that originally sent the signal on the source chain
+    /// @param value The signal value to verify
+    /// @param accountProof Merkle proof for the contract's account against the state root
+    /// @param storageProof Merkle proof for the derived storage slot against the account's storage root
+    /// @return valid Boolean indicating whether the signal was successfully verified
+    /// @return storageRoot The storage root of the account from the proof
     function verifySignal(
-        address account,
         bytes32 root,
         uint64 chainId,
+        address sender,
         bytes32 value,
         bytes[] memory accountProof,
         bytes[] memory storageProof
-    ) internal pure returns (bool valid, bytes32 storageRoot) {
+    ) internal view returns (bool valid, bytes32 storageRoot) {
         return LibTrieProof.verifyStorage(
-            account, deriveSlot(chainId, account, value), value, root, accountProof, storageProof
+            address(this), deriveSlot(chainId, sender, value), value, root, accountProof, storageProof
         );
     }
 }

src/protocol/CheckpointSyncer.sol

@@ -6,11 +6,15 @@ import {ICheckpointTracker} from "./ICheckpointTracker.sol";
 
 /// @dev Tracks and synchronizes checkpoints from different chains using their chainId.
 abstract contract CheckpointSyncer is ICheckpointSyncer {
-    address private immutable checkpointTracker;
+    address private immutable _checkpointTracker;
 
     /// @dev Sets the checkpoint tracker.
-    constructor(address _checkpointTracker) {
-        _checkpointTracker = checkpointTracker;
+    constructor(address checkpointTracker_) {
+        checkpointTracker_ = _checkpointTracker;
+    }
+
+    function checkpointTracker() public view returns (address) {
+        return _checkpointTracker;
     }
 
     /// @inheritdoc ICheckpointSyncer
@@ -29,7 +33,7 @@ abstract contract CheckpointSyncer is ICheckpointSyncer {
         virtual
         returns (bytes32 id)
     {
-        require(msg.sender == checkpointTracker, UnauthorizedCheckpointTracker());
+        require(msg.sender == checkpointTracker(), UnauthorizedCheckpointTracker());
         id = getCheckpointId(checkpoint, chainId);
         emit CheckpointSynced(checkpoint, chainId);
     }
@@ -38,9 +42,8 @@ abstract contract CheckpointSyncer is ICheckpointSyncer {
     function verifyCheckpoint(
         ICheckpointTracker.Checkpoint memory checkpoint,
         uint64 chainId,
-        bytes32 root,
         bytes[] memory accountProof,
-        bytes[] memory proof
+        bytes[] memory storageProof
     ) public view virtual returns (bytes32 id);
 
     function _generateId(ICheckpointTracker.Checkpoint memory checkpoint, uint64 chainId)

src/protocol/ETHBridge.sol

@@ -38,12 +38,10 @@ abstract contract ETHBridge is IETHBridge {
     }
 
     /// @inheritdoc IETHBridge
-    function claimDeposit(
-        ETHDeposit memory deposit,
-        bytes32 root,
-        bytes[] memory accountProof,
-        bytes[] memory stateProof
-    ) external virtual returns (bytes32 id);
+    function claimDeposit(ETHDeposit memory deposit, bytes[] memory accountProof, bytes[] memory storageRoot)
+        external
+        virtual
+        returns (bytes32 id);
 
     /// @dev Function to transfer ETH to the receiver but ignoring the returndata.
     /// @param to Address to send the ETH to

src/protocol/ICheckpointSyncer.sol

@@ -27,13 +27,11 @@ interface ICheckpointSyncer {
         external
         returns (bytes32 id);
 
-    /// @dev Verifies that a `checkpoint` is valid for the provided `chainId`, `height` and `root`.
-    /// The `root` MUST be trusted.
+    /// @dev Verifies that a `checkpoint` has been signaled on the destchain.
     function verifyCheckpoint(
         ICheckpointTracker.Checkpoint memory checkpoint,
         uint64 chainId,
-        bytes32 root,
         bytes[] memory accountProof,
-        bytes[] memory proof
+        bytes[] memory storageProof
     ) external view returns (bytes32 id);
 }

src/protocol/IETHBridge.sol

@@ -55,13 +55,9 @@ interface IETHBridge {
     /// @dev Claims an ETH deposit created on `chainId` by the sender (`from`) with `nonce`. The `value` ETH claimed  is
     /// sent to the receiver (`to`) after verifying a storage proof.
     /// @param deposit The ETH deposit
-    /// @param root The state root
-    /// @param accountProof Merkle proof for account state against global stateRoot
-    /// @param stateProof Merkle proof for slot value against account's storageRoot
-    function claimDeposit(
-        ETHDeposit memory deposit,
-        bytes32 root,
-        bytes[] memory accountProof,
-        bytes[] memory stateProof
-    ) external returns (bytes32 id);
+    /// @param accountProof Merkle proof for the contract's account against the state root
+    /// @param storageProof Merkle proof for the derived storage slot against the account's storage root
+    function claimDeposit(ETHDeposit memory deposit, bytes[] memory accountProof, bytes[] memory storageProof)
+        external
+        returns (bytes32 id);
 }

src/protocol/ISignalService.sol

@@ -7,46 +7,43 @@ pragma solidity ^0.8.28;
 /// Signals enable generalized on-chain communication, primarily for data transmission rather than value transfer.
 /// Applications can leverage signals to transfer value through secondary implementations.
 ///
-/// Signals are broadcast without specific recipients, allowing flexible cross-chain data sourcing from any
-/// source chain state (e.g., full transaction logs or contract storage).
+/// Signals are broadcast without specific recipients, allowing flexible cross-chain messaging
 interface ISignalService {
     /// @dev Emitted when a signal is sent.
-    /// @param signal Signal value that was stored
-    event SignalSent(bytes32 signal);
+    /// @param chainId The chain ID of the source chain where the signal was sent
+    /// @param sender The address that sent the signal on the source chain
+    /// @param value The signal value
+    event SignalSent(address sender, uint256 chainId, bytes32 value);
 
     /// @dev Emitted when a signal is verified.
+    /// @param chainId The chain ID of the source chain where the signal was sent
     /// @param value Value that was signaled
-    /// @param chainId Chain ID where the signal was sent to
-    /// @param root TODO: check this
-    event SignalVerified(bytes32 value, uint64 chainId, bytes32 root);
+    event SignalVerified(uint64 chainId, address sender, bytes32 value);
 
     /// @dev Error when a signal fails to be verified.
     /// @param value Value that was not verified
-    error SignalNotReceived(bytes32 value, bytes32 root);
+    error SignalNotReceived(bytes32 value);
 
     /// @dev Stores a data signal and returns its storage location.
     /// @param value Data to be stored (signalled)
     function sendSignal(bytes32 value) external returns (bytes32 slot);
 
     /// @dev Checks if a signal has been stored
-    /// @dev Note: This does not mean it has been 'sent' to destination chain, only that it has been stored on the
-    /// source chain.
+    /// @dev Note: This does not mean it has been 'sent' to destination chain,
+    /// only that it has been stored on the source chain.
     /// @param value Value to be checked is stored
-    // @param sender The address that sent the signal
+    /// @param sender The address that sent the signal
     function isSignalStored(bytes32 value, address sender) external view returns (bool);
 
     /// @dev Verifies if the signal can be proved to be part of a merkle tree
-    /// defined by `root` for the specified signal service storage.
-    /// @param root TODO: check this
-    /// @param chainId Chain ID where the signal was sent to
-    /// @param value Value to be verified
-    /// @param accountProof Merkle proof for account state against global stateRoot
-    /// @param stateProof Merkle proof for slot value against account's storageRoot
+    /// @dev Signals are not deleted when verified, and can be
+    /// verified multiple times by calling this function
+    /// @dev see `LibSignal.verifySignal`
     function verifySignal(
-        bytes32 root,
         uint64 chainId,
+        address sender,
         bytes32 value,
         bytes[] memory accountProof,
-        bytes[] memory stateProof
+        bytes[] memory storageProof
     ) external;
 }

src/protocol/taiko_alethia/SignalService.sol

@@ -12,36 +12,35 @@ import {ISignalService} from "../ISignalService.sol";
 ///
 /// The service defines the minimal logic to broadcast signals through `sendSignal` and verify them with
 /// `verifySignal`. The service is designed to be used in conjunction with the `ETHBridge` contract to
-/// enable cross-chain communication.
+/// enable cross-chain communication and the CheckpointSyncer to retrieve trusted state roots.
 contract SignalService is ISignalService, ETHBridge, CheckpointSyncer {
     using LibSignal for bytes32;
 
     constructor(address _checkpointTracker) CheckpointSyncer(_checkpointTracker) {}
 
     /// @inheritdoc ISignalService
-    function sendSignal(bytes32 value) external returns (bytes32 signal) {
-        signal = value.signal();
-        emit SignalSent(signal);
+    function sendSignal(bytes32 value) external returns (bytes32 slot) {
+        slot = value.signal();
+        emit SignalSent(msg.sender, block.chainid, value);
     }
 
     /// @inheritdoc ISignalService
     function isSignalStored(bytes32 value, address sender) external view returns (bool) {
         // This will return `false` when the signal itself is 0
-        return value.signaled(sender);
+        return LibSignal.signaled(sender, value);
     }
 
     /// @inheritdoc ISignalService
     function verifySignal(
-        bytes32 root,
         uint64 chainId,
+        address sender,
         bytes32 value,
         bytes[] memory accountProof,
         bytes[] memory storageProof
     ) external {
-        // TODO: Get the root from the trusted source
-        _verifySignal(root, chainId, value, accountProof, storageProof);
+        _verifySignal(chainId, sender, value, accountProof, storageProof);
 
-        emit SignalVerified(value, chainId, root);
+        emit SignalVerified(chainId, sender, value);
     }
 
     /// @dev Overrides ETHBridge.depositETH to add signaling functionality.
@@ -53,14 +52,14 @@ contract SignalService is ISignalService, ETHBridge, CheckpointSyncer {
     // CHECK: Should this function be non-reentrant?
     /// @inheritdoc ETHBridge
     /// @dev Overrides ETHBridge.claimDeposit to add signal verification logic.
-    function claimDeposit(ETHDeposit memory deposit, bytes32 root, bytes[] memory accountProof, bytes[] memory proof)
+    function claimDeposit(ETHDeposit memory deposit, bytes[] memory accountProof, bytes[] memory storageProof)
         external
         override
         returns (bytes32 id)
     {
         id = _generateId(deposit);
 
-        _verifySignal(root, deposit.chainId, id, accountProof, proof);
+        _verifySignal(deposit.chainId, deposit.from, id, accountProof, storageProof);
 
         super._processClaimDepositWithId(id, deposit);
     }
@@ -77,22 +76,24 @@ contract SignalService is ISignalService, ETHBridge, CheckpointSyncer {
     function verifyCheckpoint(
         ICheckpointTracker.Checkpoint memory checkpoint,
         uint64 chainId,
-        bytes32 root,
         bytes[] memory accountProof,
-        bytes[] memory proof
+        bytes[] memory storageProof
     ) public view override returns (bytes32 id) {
         id = getCheckpointId(checkpoint, chainId);
-        _verifySignal(root, chainId, id, accountProof, proof);
+
+        _verifySignal(chainId, checkpointTracker(), id, accountProof, storageProof);
     }
 
     function _verifySignal(
-        bytes32 root,
         uint64 chainId,
+        address sender,
         bytes32 value,
         bytes[] memory accountProof,
-        bytes[] memory stateProof
+        bytes[] memory storageProof
     ) internal view {
-        (bool valid,) = LibSignal.verifySignal(address(this), root, chainId, value, accountProof, stateProof);
-        require(valid, SignalNotReceived(value, root));
+        // WARN: THIS IS NOT THE ROOT ITS JUST A PLACE HOLDER
+        bytes32 root = keccak256("root");
+        (bool valid,) = LibSignal.verifySignal(root, chainId, sender, value, accountProof, storageProof);
+        require(valid, SignalNotReceived(value));
     }
 }