impl fabric gateway commitments api (#185)

Co-authored-by: Louis Ponet <[email protected]>

Author: gd-0

based/Cargo.lock

@@ -131,4 +131,4 @@ tree_hash_derive = "0.10"
 uuid = { version = "1.12.1", features = ["serde", "v4"] }
 
 backtrace = "0.3.73"
-tabwriter = "1.4.1"
+tabwriter = "1.4.1"

based/Cargo.toml

@@ -63,6 +63,7 @@ fn run(args: GatewayArgs) -> eyre::Result<()> {
     };
     let sequencer_config: SequencerConfig = (&args).into();
     let evm_config = sequencer_config.evm_config.clone();
+    let (tx, _) = tokio::sync::broadcast::channel(10_000);
 
     std::thread::scope(|s| {
         let rt: Arc<Runtime> = tokio::runtime::Builder::new_current_thread()
@@ -74,7 +75,7 @@ fn run(args: GatewayArgs) -> eyre::Result<()> {
 
         s.spawn({
             let rt = rt.clone();
-            start_rpc(&args, &spine, &rt);
+            start_rpc(&args, &spine, &rt, tx.clone());
             move || rt.block_on(wait_for_signal())
         });
 
@@ -103,7 +104,7 @@ fn run(args: GatewayArgs) -> eyre::Result<()> {
         let root_peer_url = args.gossip_root_peer_url.clone();
         let gossip_signer_private_key = args.gossip_signer_private_key.map(|key| ECDSASigner::new(key).unwrap());
         s.spawn(|| {
-            Gossiper::new(root_peer_url, gossip_signer_private_key).run(
+            Gossiper::new(root_peer_url, gossip_signer_private_key, tx).run(
                 spine.to_connections("Gossiper"),
                 ActorConfig::default().with_min_loop_duration(Duration::from_millis(10)),
             );

based/bin/gateway/src/main.rs

@@ -3,13 +3,13 @@ use std::{fmt, net::SocketAddr, sync::Arc, time::Duration};
 use alloy_eips::eip7685::RequestsOrHash;
 use alloy_primitives::{Address, B256, Bytes, U256};
 use alloy_rpc_types::{
-    BlockId, BlockNumberOrTag, 
+    BlockId, BlockNumberOrTag,
     engine::{ExecutionPayloadV3, ForkchoiceState, ForkchoiceUpdated, PayloadId, PayloadStatus},
 };
 use bop_common::{
     api::{
-        EngineApiClient, EngineApiServer, EthApiClient, EthApiServer, OpGethAdminApiClient,
-        OpNodeApiClient, OpNodeP2PApiClient, OpRpcBlock, PORTAL_CAPABILITIES, PortalApiServer, RegistryApiClient,
+        EngineApiClient, EngineApiServer, EthApiClient, EthApiServer, OpGethAdminApiClient, OpNodeApiClient,
+        OpNodeP2PApiClient, OpRpcBlock, PORTAL_CAPABILITIES, PortalApiServer, RegistryApiClient,
     },
     communication::messages::{RpcError, RpcResult},
     utils::{uuid, wait_for_signal},

based/bin/portal/src/server.rs

@@ -9,7 +9,9 @@ use alloy_rpc_types::{
 use jsonrpsee::proc_macros::rpc;
 use op_alloy_consensus::OpTxEnvelope;
 use op_alloy_rpc_types::OpTransactionReceipt;
-use op_alloy_rpc_types_engine::{OpExecutionPayloadEnvelopeV3, OpExecutionPayloadEnvelopeV4, OpExecutionPayloadV4, OpPayloadAttributes};
+use op_alloy_rpc_types_engine::{
+    OpExecutionPayloadEnvelopeV3, OpExecutionPayloadEnvelopeV4, OpExecutionPayloadV4, OpPayloadAttributes,
+};
 use reqwest::Url;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;

based/crates/common/src/api.rs

@@ -3,15 +3,15 @@ use std::{
     sync::Arc,
 };
 
-use alloy_consensus::{constants::EMPTY_WITHDRAWALS, BlockHeader, Transaction as TransactionTrait};
+use alloy_consensus::{BlockHeader, Transaction as TransactionTrait, constants::EMPTY_WITHDRAWALS};
 use alloy_eips::eip2718::Encodable2718;
 use alloy_rpc_types::engine::{
     ExecutionPayloadV1, ExecutionPayloadV2, ExecutionPayloadV3, ForkchoiceState, PayloadAttributes, PayloadError,
     PayloadId,
 };
 use jsonrpsee::types::{ErrorCode, ErrorObject as RpcErrorObject};
 use op_alloy_rpc_types_engine::{OpExecutionPayloadEnvelopeV4, OpExecutionPayloadV4, OpPayloadAttributes};
-use reth_evm::{execute::BlockExecutionError, NextBlockEnvAttributes};
+use reth_evm::{NextBlockEnvAttributes, execute::BlockExecutionError};
 use reth_primitives_traits::transaction::signed::RecoveryError;
 use revm_primitives::{Address, U256};
 use serde::{Deserialize, Serialize};
@@ -258,6 +258,9 @@ pub enum RpcError {
     #[error("response channel closed {0}")]
     ChannelClosed(#[from] oneshot::error::RecvError),
 
+    #[error("broadcast channel closed")]
+    BroadcastChannelClosed,
+
     #[error("invalid transaction bytes")]
     InvalidTransaction(#[from] alloy_rlp::Error),
 
@@ -275,6 +278,12 @@ pub enum RpcError {
 
     #[error("no return")]
     NoReturn,
+
+    #[error("no commitment for request: {0:?}")]
+    NoCommitmentForRequest(B256),
+
+    #[error("serialization error: {0}")]
+    Serialization(#[from] serde_json::Error),
 }
 
 impl From<RpcError> for RpcErrorObject<'static> {
@@ -283,16 +292,23 @@ impl From<RpcError> for RpcErrorObject<'static> {
             RpcError::Internal |
             RpcError::Timeout(_) |
             RpcError::ChannelClosed(_) |
+            RpcError::BroadcastChannelClosed |
             RpcError::Jsonrpsee(_) |
             RpcError::TokioJoin(_) |
             RpcError::Db(_) |
             RpcError::Io(_) |
+            RpcError::Serialization(_) |
             RpcError::NoReturn => internal_error(),
             RpcError::InvalidTransaction(error) => RpcErrorObject::owned(
                 ErrorCode::InvalidParams.code(),
                 ErrorCode::InvalidParams.message(),
                 Some(error.to_string()),
             ),
+            RpcError::NoCommitmentForRequest(slot) => RpcErrorObject::owned(
+                ErrorCode::InvalidParams.code(),
+                ErrorCode::InvalidParams.message(),
+                Some(format!("no commitment for request: {slot}")),
+            ),
         }
     }
 }

based/crates/common/src/communication/messages.rs

@@ -33,6 +33,8 @@ pub struct GatewayArgs {
     /// The port to run the engine_ and eth_ RPC
     #[arg(long = "rpc.port", default_value_t = 9997)]
     pub rpc_port: u16,
+    #[arg(long = "rpc.port_no_auth", default_value_t = 9998)]
+    pub rpc_port_no_auth: u16,
     #[arg(long = "rpc.jwt")]
     pub rpc_jwt: String,
     /// Url to an L2 eth api rpc

based/crates/common/src/config.rs

@@ -0,0 +1,95 @@
+use alloy_primitives::{Address, B256, Bytes};
+use jsonrpsee::proc_macros::rpc;
+use serde::{Deserialize, Serialize};
+use ssz_types::{VariableList, typenum};
+use tree_hash_derive::TreeHash;
+
+use crate::communication::messages::RpcResult;
+
+pub type MaxCommitmentRequestPayloadSize = typenum::U1048576; // 1MB.
+pub type CommitmentRequestPayload = VariableList<u8, MaxCommitmentRequestPayloadSize>;
+
+pub const FRAG_COMMITMENT_TYPE: u64 = 7;
+
+/// A CommitmentRequest message created by a user
+#[derive(Clone, Serialize, Deserialize, Debug, TreeHash)]
+#[serde(rename_all = "camelCase")]
+pub struct CommitmentRequest {
+    pub commitment_type: u64,
+    pub payload: CommitmentRequestPayload,
+    pub slasher: Address,
+}
+
+/// A Commitment message responding to a CommitmentRequest
+#[derive(Clone, Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct Commitment {
+    pub commitment_type: u64,
+    pub payload: Bytes,
+    pub request_hash: B256,
+    pub slasher: Address,
+}
+
+/// A signed Commitment binding to a CommitmentRequest
+#[derive(Clone, Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct SignedCommitment {
+    pub commitment: Commitment,
+    pub signature: Bytes,
+}
+
+/// Specifies which commitments can be made for a specific chain
+#[derive(Clone, Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct Offering {
+    pub chain_id: u64,
+    pub commitment_types: Vec<u64>,
+}
+
+/// Information about a Gateway's offerings at a specific slot
+#[derive(Clone, Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct SlotInfo {
+    pub slot: u64,
+    pub offerings: Vec<Offering>,
+}
+
+/// Response containing multiple SlotInfo
+#[derive(Clone, Serialize, Deserialize, Debug, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct SlotInfoResponse {
+    pub slots: Vec<SlotInfo>,
+}
+
+/// Fee information for a specific commitment request
+#[derive(Clone, Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct FeeInfo {
+    pub payload: Bytes,
+    pub commitment_type: u64,
+}
+
+impl Default for FeeInfo {
+    fn default() -> Self {
+        Self { payload: Bytes::new(), commitment_type: FRAG_COMMITMENT_TYPE }
+    }
+}
+
+#[rpc(client, server, namespace = "gateway")]
+pub trait FabricGatewayApi {
+    /// Request a new SignedCommitment
+    #[method(name = "commitment")]
+    async fn post_commitment(&self, commitment_request: CommitmentRequest) -> RpcResult<SignedCommitment>;
+
+    /// Request an existing SignedCommitment by request hash
+    #[method(name = "getCommitment")]
+    async fn get_commitment(&self, request_hash: B256) -> RpcResult<SignedCommitment>;
+
+    /// Get Gateway information for upcoming slots
+    #[method(name = "slots")]
+    async fn get_slots(&self) -> RpcResult<SlotInfoResponse>;
+
+    /// Get commitment fee information
+    #[method(name = "fee")]
+    async fn get_fee_info(&self, commitment_request: CommitmentRequest) -> RpcResult<FeeInfo>;
+}

based/crates/common/src/fabric.rs

@@ -4,6 +4,7 @@ pub mod communication;
 pub mod config;
 pub mod db;
 pub mod eth;
+pub mod fabric;
 pub mod p2p;
 pub mod shared;
 pub mod signing;

based/crates/common/src/lib.rs

@@ -8,34 +8,6 @@ use tree_hash_derive::TreeHash;
 
 use crate::{signing::ECDSASigner, transaction::Transaction as BuilderTransaction};
 
-#[derive(Debug, Clone, PartialEq, Eq, TreeHash, Serialize, Deserialize, AsRefStr)]
-#[tree_hash(enum_behaviour = "union")]
-#[serde(untagged)]
-#[non_exhaustive]
-pub enum VersionedMessage {
-    FragV0(FragV0),
-    SealV0(SealV0),
-    EnvV0(EnvV0),
-}
-
-impl From<FragV0> for VersionedMessage {
-    fn from(value: FragV0) -> Self {
-        Self::FragV0(value)
-    }
-}
-
-impl From<SealV0> for VersionedMessage {
-    fn from(value: SealV0) -> Self {
-        Self::SealV0(value)
-    }
-}
-
-impl From<EnvV0> for VersionedMessage {
-    fn from(value: EnvV0) -> Self {
-        Self::EnvV0(value)
-    }
-}
-
 pub type MaxExtraDataSize = typenum::U256;
 pub type ExtraData = VariableList<u8, MaxExtraDataSize>;
 
@@ -91,7 +63,7 @@ pub struct FragV0 {
     pub is_last: bool,
     /// Ordered list of EIP-2718 encoded transactions
     #[serde(with = "ssz_types::serde_utils::list_of_hex_var_list")]
-    txs: Transactions,
+    pub txs: Transactions,
 }
 
 impl FragV0 {
@@ -124,13 +96,52 @@ pub struct SealV0 {
     pub block_hash: B256,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, TreeHash, Serialize, Deserialize, AsRefStr)]
+#[tree_hash(enum_behaviour = "union")]
+#[serde(untagged)]
+#[non_exhaustive]
+pub enum VersionedMessage {
+    FragV0(FragV0),
+    SealV0(SealV0),
+    EnvV0(EnvV0),
+}
+
 impl VersionedMessage {
-    pub fn to_json(&self, signer: &ECDSASigner) -> serde_json::Value {
+    pub fn to_signed(self, signer: &ECDSASigner) -> SignedVersionedMessage {
         let hash = self.tree_hash_root();
         let signature = signer.sign_message(hash).expect("couldn't sign message");
         let signature = Bytes::from(signature.as_bytes());
+        SignedVersionedMessage { message: self, signature }
+    }
+}
+
+impl From<FragV0> for VersionedMessage {
+    fn from(value: FragV0) -> Self {
+        Self::FragV0(value)
+    }
+}
+
+impl From<SealV0> for VersionedMessage {
+    fn from(value: SealV0) -> Self {
+        Self::SealV0(value)
+    }
+}
+
+impl From<EnvV0> for VersionedMessage {
+    fn from(value: EnvV0) -> Self {
+        Self::EnvV0(value)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct SignedVersionedMessage {
+    pub message: VersionedMessage,
+    pub signature: Bytes,
+}
 
-        let method = match &self {
+impl SignedVersionedMessage {
+    pub fn to_json(&self) -> serde_json::Value {
+        let method = match &self.message {
             VersionedMessage::FragV0(_) => "based_newFrag",
             VersionedMessage::SealV0(_) => "based_sealFrag",
             VersionedMessage::EnvV0(_) => "based_env",
@@ -139,7 +150,7 @@ impl VersionedMessage {
         serde_json::json!({
             "jsonrpc": "2.0",
             "method": method,
-            "params": [{"signature": signature, "message": self}],
+            "params": [{"signature": self.signature, "message": self.message}],
             "id": 1
         })
     }