feat(l2): integrate Phylax Credible Layer into L2 sequencer

cmd/ethrex/l2/options.rs

@@ -8,7 +8,7 @@ use ethrex_l2::sequencer::utils::resolve_aligned_network;
 use ethrex_l2::{
     BasedConfig, BlockFetcherConfig, BlockProducerConfig, CommitterConfig, EthConfig,
     L1WatcherConfig, ProofCoordinatorConfig, SequencerConfig, StateUpdaterConfig,
-    sequencer::configs::{AdminConfig, AlignedConfig, MonitorConfig},
+    sequencer::configs::{AdminConfig, AlignedConfig, CredibleLayerConfig, MonitorConfig},
 };
 use ethrex_l2_prover::{backend::BackendType, config::ProverConfig};
 use ethrex_l2_rpc::signer::{LocalSigner, RemoteSigner, Signer};
@@ -92,6 +92,8 @@ pub struct SequencerOptions {
     pub admin_opts: AdminOptions,
     #[clap(flatten)]
     pub state_updater_opts: StateUpdaterOptions,
+    #[clap(flatten)]
+    pub credible_layer_opts: CredibleLayerOptions,
     #[arg(
         long = "validium",
         default_value = "false",
@@ -263,6 +265,9 @@ impl TryFrom<SequencerOptions> for SequencerConfig {
                 start_at: opts.state_updater_opts.start_at,
                 l2_head_check_rpc_url: opts.state_updater_opts.l2_head_check_rpc_url,
             },
+            credible_layer: CredibleLayerConfig {
+                sidecar_url: opts.credible_layer_opts.credible_layer_url,
+            },
         })
     }
 }
@@ -1066,6 +1071,18 @@ impl Default for AdminOptions {
     }
 }
 
+#[derive(Parser, Default, Debug)]
+pub struct CredibleLayerOptions {
+    #[arg(
+        long = "credible-layer-url",
+        value_name = "URL",
+        env = "ETHREX_CREDIBLE_LAYER_URL",
+        help = "gRPC endpoint for the Credible Layer Assertion Enforcer sidecar (e.g. http://localhost:50051). Passing this flag enables the integration.",
+        help_heading = "Credible Layer options"
+    )]
+    pub credible_layer_url: Option<String>,
+}
+
 #[derive(Parser)]
 pub struct ProverClientOptions {
     #[arg(

crates/l2/Cargo.toml

@@ -54,13 +54,18 @@ crossterm = { version = "0.29.0", features = ["event-stream"] }
 ratatui = "0.29.0"
 tui-logger.workspace = true
 axum.workspace = true
+tonic = "0.12"
+prost = "0.13"
+tokio-stream = "0.1"
 ethrex-guest-program = { path = "../guest-program", optional = true }
 
 [build-dependencies]
 vergen-git2 = { version = "1.0.7" }
+tonic-build = "0.12"
 
 [dev-dependencies]
 anyhow = "1.0.86"
+hex = { workspace = true }
 
 [lib]
 path = "./l2.rs"

crates/l2/build.rs

@@ -9,10 +9,15 @@ fn main() -> Result<(), Box<dyn Error>> {
     // When building tdx image with nix the commit version is stored as an env var
     if let Ok(sha) = std::env::var("VERGEN_GIT_SHA") {
         println!("cargo:rustc-env=VERGEN_GIT_SHA={}", sha.trim());
-        return Ok(());
+    } else {
+        let git2 = Git2Builder::default().sha(true).build()?;
+        Emitter::default().add_instructions(&git2)?.emit()?;
     }
-    let git2 = Git2Builder::default().sha(true).build()?;
 
-    Emitter::default().add_instructions(&git2)?.emit()?;
+    // Compile Credible Layer protobuf definitions (client only)
+    tonic_build::configure()
+        .build_server(false)
+        .compile_protos(&["proto/sidecar.proto"], &["proto/"])?;
+
     Ok(())
 }

crates/l2/contracts/src/credible_layer/OwnableTarget.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.27;
+
+/// @title OwnableTarget
+/// @notice A simple Ownable contract used as a target for Credible Layer testing.
+/// The TestOwnershipAssertion protects this contract by preventing ownership transfers.
+contract OwnableTarget {
+    address public owner;
+
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+    constructor() {
+        owner = msg.sender;
+    }
+
+    modifier onlyOwner() {
+        require(msg.sender == owner, "OwnableTarget: caller is not the owner");
+        _;
+    }
+
+    /// @notice Transfer ownership to a new address.
+    /// When protected by the TestOwnershipAssertion, this call will be dropped by the sidecar.
+    function transferOwnership(address newOwner) external onlyOwner {
+        require(newOwner != address(0), "OwnableTarget: new owner is the zero address");
+        emit OwnershipTransferred(owner, newOwner);
+        owner = newOwner;
+    }
+
+    /// @notice A harmless function that does not trigger any assertion.
+    function doSomething() external pure returns (uint256) {
+        return 42;
+    }
+}

crates/l2/contracts/src/credible_layer/README.md

@@ -0,0 +1,19 @@
+# Credible Layer Contracts
+
+This directory contains example/demo contracts for the Credible Layer integration:
+
+- `OwnableTarget.sol` — a simple Ownable contract used as a demonstration target
+- `TestOwnershipAssertion.sol` — a test assertion that asserts ownership of `OwnableTarget` cannot change
+
+## State Oracle
+
+The **State Oracle** is the on-chain registry that maps protected contracts to their active
+assertions. It is maintained by Phylax Systems and must be deployed separately using the
+Phylax toolchain before starting the Credible Layer sidecar.
+
+See the [Credible Layer docs](../../../../docs/l2/credible_layer.md) for deployment instructions.
+
+### References
+
+- [Credible Layer Introduction](https://docs.phylax.systems/credible/credible-introduction)
+- [credible-layer-contracts](https://github.com/phylaxsystems/credible-layer-contracts)

crates/l2/contracts/src/credible_layer/TestOwnershipAssertion.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.27;
+
+import {Assertion} from "credible-std/Assertion.sol";
+
+interface IOwnableTarget {
+    function owner() external view returns (address);
+    function transferOwnership(address newOwner) external;
+}
+
+/// @title TestOwnershipAssertion
+/// @notice Protects OwnableTarget by asserting that ownership cannot change.
+/// @dev Compile with `pcl build` (requires credible-std as a dependency).
+///      See docs/l2/credible_layer.md for the full deployment workflow.
+contract TestOwnershipAssertion is Assertion {
+    function triggers() external view override {
+        registerCallTrigger(
+            this.assertOwnerUnchanged.selector,
+            IOwnableTarget.transferOwnership.selector
+        );
+    }
+
+    function assertOwnerUnchanged() external {
+        IOwnableTarget target = IOwnableTarget(ph.getAssertionAdopter());
+        ph.forkPreTx();
+        address ownerBefore = target.owner();
+        ph.forkPostTx();
+        address ownerAfter = target.owner();
+        require(ownerBefore == ownerAfter, "ownership changed");
+    }
+}

crates/l2/l2.rs

@@ -6,7 +6,7 @@ pub mod utils;
 
 pub use based::block_fetcher::BlockFetcher;
 pub use sequencer::configs::{
-    BasedConfig, BlockFetcherConfig, BlockProducerConfig, CommitterConfig, EthConfig,
-    L1WatcherConfig, ProofCoordinatorConfig, SequencerConfig, StateUpdaterConfig,
+    BasedConfig, BlockFetcherConfig, BlockProducerConfig, CommitterConfig, CredibleLayerConfig,
+    EthConfig, L1WatcherConfig, ProofCoordinatorConfig, SequencerConfig, StateUpdaterConfig,
 };
 pub use sequencer::start_l2;

crates/l2/networking/rpc/rpc.rs

@@ -44,7 +44,7 @@ use ethrex_common::Address;
 use ethrex_storage_rollup::StoreRollup;
 use secp256k1::SecretKey;
 
-#[derive(Debug, Clone)]
+#[derive(Clone, Debug)]
 pub struct RpcApiContext {
     pub l1_ctx: ethrex_rpc::RpcApiContext,
     pub valid_delegation_addresses: Vec<Address>,
@@ -72,7 +72,6 @@ pub const FILTER_DURATION: Duration = {
     }
 };
 
-#[expect(clippy::too_many_arguments)]
 pub async fn start_api(
     http_addr: SocketAddr,
     ws: Option<WebSocketConfig>,