Migrate deposit source to maili-common

Cargo.toml

@@ -62,10 +62,10 @@ alloy-sol-types = { version = "0.8.12", default-features = false }
 alloy-primitives = { version = "0.8.12", default-features = false }
 
 # Maili
-maili-provider = { version = "0.1.0", default-features = false }
-maili-protocol = { version = "0.1.0", default-features = false }
-maili-registry = { version = "0.1.0", default-features = false }
-maili-rpc-types-engine = { version = "0.1.0", default-features = false }
+maili-provider = { version = "0.1.3", default-features = false }
+maili-protocol = { version = "0.1.3", default-features = false }
+maili-registry = { version = "0.1.3", default-features = false }
+maili-common = { version = "0.1.3", default-features = false }
 
 # Revm
 revm = "19.0.0"

crates/consensus/src/transaction/mod.rs

@@ -15,12 +15,6 @@ pub use typed::OpTypedTransaction;
 mod pooled;
 pub use pooled::OpPooledTransaction;
 
-mod source;
-pub use source::{
-    DepositSourceDomain, DepositSourceDomainIdentifier, L1InfoDepositSource, UpgradeDepositSource,
-    UserDepositSource,
-};
-
 #[cfg(feature = "serde")]
 pub use deposit::serde_deposit_tx_rpc;
 

crates/rpc-jsonrpsee/Cargo.toml

@@ -0,0 +1,45 @@
+[package]
+name = "op-alloy-rpc-jsonrpsee"
+description = "Optimism RPC Client"
+
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+homepage.workspace = true
+authors.workspace = true
+repository.workspace = true
+exclude.workspace = true
+
+[lints]
+workspace = true
+
+[dependencies]
+# OP-Alloy
+op-alloy-rpc-types.workspace = true
+op-alloy-rpc-types-engine = { workspace = true, features = ["serde"] }
+
+# Alloy
+alloy-eips.workspace = true
+alloy-primitives.workspace = true
+
+# Maili
+maili-protocol.workspace = true
+maili-common = { workspace = true, default-features = false, features = ["serde"] }
+
+# rpc
+jsonrpsee.workspace = true
+
+[features]
+default = ["std"]
+std = [
+    "op-alloy-rpc-types/std",
+    "op-alloy-rpc-types-engine/std",
+    "alloy-eips/std",
+    "alloy-primitives/std",
+    "maili-common/std",
+]
+client = [
+    "jsonrpsee/client",
+    "jsonrpsee/async-client",
+]

crates/rpc-jsonrpsee/src/traits.rs

@@ -0,0 +1,162 @@
+#![allow(missing_docs)]
+
+//! Rollup Node
+
+use alloc::{boxed::Box, string::String, vec::Vec};
+use core::net::IpAddr;
+
+use alloy_eips::BlockNumberOrTag;
+use alloy_primitives::{B256, U64};
+use jsonrpsee::{core::RpcResult, proc_macros::rpc};
+use maili_common::{ProtocolVersion, SuperchainSignal};
+use maili_protocol::{ExecutingMessage, SafetyLevel};
+use op_alloy_rpc_types::{
+    OutputResponse, PeerDump, PeerInfo, PeerStats, RollupConfig, SafeHeadResponse, SyncStatus,
+};
+
+/// Optimism specified rpc interface.
+///
+/// https://docs.optimism.io/builders/node-operators/json-rpc
+/// https://github.com/ethereum-optimism/optimism/blob/8dd17a7b114a7c25505cd2e15ce4e3d0f7e3f7c1/op-node/node/api.go#L114
+#[cfg_attr(not(feature = "client"), rpc(server, namespace = "optimism"))]
+#[cfg_attr(feature = "client", rpc(server, client, namespace = "optimism"))]
+pub trait RollupNode {
+    /// Get the output root at a specific block.
+    #[method(name = "outputAtBlock")]
+    async fn op_output_at_block(&self, block_number: BlockNumberOrTag)
+        -> RpcResult<OutputResponse>;
+
+    /// Gets the safe head at an L1 block height.
+    #[method(name = "safeHeadAtL1Block")]
+    async fn op_safe_head_at_l1_block(
+        &self,
+        block_number: BlockNumberOrTag,
+    ) -> RpcResult<SafeHeadResponse>;
+
+    /// Get the synchronization status.
+    #[method(name = "syncStatus")]
+    async fn op_sync_status(&self) -> RpcResult<SyncStatus>;
+
+    /// Get the rollup configuration parameters.
+    #[method(name = "rollupConfig")]
+    async fn op_rollup_config(&self) -> RpcResult<RollupConfig>;
+
+    /// Get the software version.
+    #[method(name = "version")]
+    async fn op_version(&self) -> RpcResult<String>;
+}
+
+/// The opp2p namespace handles peer interactions.
+#[cfg_attr(not(feature = "client"), rpc(server, namespace = "opp2p"))]
+#[cfg_attr(feature = "client", rpc(server, client, namespace = "opp2p"))]
+pub trait OpP2PApi {
+    /// Returns information of node
+    #[method(name = "self")]
+    async fn opp2p_self(&self) -> RpcResult<PeerInfo>;
+
+    #[method(name = "peers")]
+    async fn opp2p_peers(&self) -> RpcResult<PeerDump>;
+
+    #[method(name = "peerStats")]
+    async fn opp2p_peer_stats(&self) -> RpcResult<PeerStats>;
+
+    #[method(name = "discoveryTable")]
+    async fn opp2p_discovery_table(&self) -> RpcResult<Vec<String>>;
+
+    #[method(name = "blockPeer")]
+    async fn opp2p_block_peer(&self, peer: String) -> RpcResult<()>;
+
+    #[method(name = "listBlockedPeers")]
+    async fn opp2p_list_blocked_peers(&self) -> RpcResult<Vec<String>>;
+
+    #[method(name = "blocAddr")]
+    async fn opp2p_block_addr(&self, ip: IpAddr) -> RpcResult<()>;
+
+    #[method(name = "unblockAddr")]
+    async fn opp2p_unblock_addr(&self, ip: IpAddr) -> RpcResult<()>;
+
+    #[method(name = "listBlockedAddrs")]
+    async fn opp2p_list_blocked_addrs(&self) -> RpcResult<Vec<IpAddr>>;
+
+    /// todo: should be IPNet?
+    #[method(name = "blockSubnet")]
+    async fn opp2p_block_subnet(&self, subnet: String) -> RpcResult<()>;
+
+    /// todo: should be IPNet?
+    #[method(name = "unblockSubnet")]
+    async fn opp2p_unblock_subnet(&self, subnet: String) -> RpcResult<()>;
+
+    /// todo: should be IPNet?
+    #[method(name = "listBlockedSubnets")]
+    async fn opp2p_list_blocked_subnets(&self) -> RpcResult<Vec<String>>;
+
+    #[method(name = "protectPeer")]
+    async fn opp2p_protect_peer(&self, peer: String) -> RpcResult<()>;
+
+    #[method(name = "unprotectPeer")]
+    async fn opp2p_unprotect_peer(&self, peer: String) -> RpcResult<()>;
+
+    #[method(name = "connectPeer")]
+    async fn opp2p_connect_peer(&self, peer: String) -> RpcResult<()>;
+
+    #[method(name = "disconnectPeer")]
+    async fn opp2p_disconnect_peer(&self, peer: String) -> RpcResult<()>;
+}
+
+/// The admin namespace endpoints
+/// https://github.com/ethereum-optimism/optimism/blob/c7ad0ebae5dca3bf8aa6f219367a95c15a15ae41/op-node/node/api.go#L28-L36
+#[cfg_attr(not(feature = "client"), rpc(server, namespace = "admin"))]
+#[cfg_attr(feature = "client", rpc(server, client, namespace = "admin"))]
+pub trait OpAdminApi {
+    #[method(name = "resetDerivationPipeline")]
+    async fn admin_reset_derivation_pipeline(&self) -> RpcResult<()>;
+
+    #[method(name = "startSequencer")]
+    async fn admin_start_sequencer(&self, block_hash: B256) -> RpcResult<()>;
+
+    #[method(name = "stopSequencer")]
+    async fn admin_stop_sequencer(&self) -> RpcResult<B256>;
+
+    #[method(name = "sequencerActive")]
+    async fn admin_sequencer_active(&self) -> RpcResult<bool>;
+}
+
+/// Engine API extension for Optimism superchain signaling
+#[cfg_attr(not(feature = "client"), rpc(server, namespace = "engine"))]
+#[cfg_attr(feature = "client", rpc(server, client, namespace = "engine"))]
+pub trait EngineApiExt {
+    /// Signal superchain v1 message
+    ///
+    /// The execution engine SHOULD warn when the recommended version is newer than the current
+    /// version. The execution engine SHOULD take safety precautions if it does not meet
+    /// the required version.
+    ///
+    /// # Returns
+    /// The latest supported OP-Stack protocol version of the execution engine.
+    ///
+    /// See: <https://specs.optimism.io/protocol/exec-engine.html#engine_signalsuperchainv1>
+    #[method(name = "signalSuperchainV1")]
+    async fn signal_superchain_v1(&self, signal: SuperchainSignal) -> RpcResult<ProtocolVersion>;
+}
+
+/// Op API extension for controlling the miner.
+#[cfg_attr(not(feature = "client"), rpc(server, namespace = "miner"))]
+#[cfg_attr(feature = "client", rpc(server, client, namespace = "miner"))]
+pub trait MinerApiExt {
+    /// Sets the maximum data availability size of any tx allowed in a block, and the total max l1
+    /// data size of the block. 0 means no maximum.
+    #[method(name = "setMaxDASize")]
+    async fn set_max_da_size(&self, max_tx_size: U64, max_block_size: U64) -> RpcResult<bool>;
+}
+
+/// Supervisor API for interop.
+#[rpc(client, namespace = "supervisor")]
+pub trait SupervisorApi {
+    /// Checks if the given messages meet the given minimum safety level.
+    #[method(name = "checkMessages")]
+    async fn check_messages(
+        &self,
+        messages: Vec<ExecutingMessage>,
+        min_safety: SafetyLevel,
+    ) -> RpcResult<()>;
+}

crates/rpc-types-engine/Cargo.toml

@@ -25,7 +25,7 @@ alloy-rpc-types-engine.workspace = true
 
 # Maili
 maili-protocol.workspace = true
-maili-rpc-types-engine = { workspace = true, default-features = false }
+maili-common = { workspace = true, default-features = false }
 
 # Encoding
 snap = { workspace = true, optional = true }
@@ -55,14 +55,14 @@ std = [
   "alloy-rpc-types-engine/std",
   "op-alloy-consensus/std",
   "maili-protocol/std",
-  "maili-rpc-types-engine/std",
+  "maili-common/std",
 ]
 serde = [
   "dep:serde",
   "dep:alloy-serde",
   "maili-protocol/serde",
   "alloy-rpc-types-engine/serde",
-  "maili-rpc-types-engine/serde",
+  "maili-common/serde",
 ]
 arbitrary = [
   "std",

crates/rpc-types-engine/src/lib.rs

@@ -10,7 +10,6 @@
 extern crate alloc;
 
 pub use alloy_rpc_types_engine::ForkchoiceUpdateVersion;
-pub use maili_rpc_types_engine::*;
 
 mod attributes;
 pub use attributes::{OpAttributesWithParent, OpPayloadAttributes};