Optimism RPC Types

Cargo.toml

@@ -12,6 +12,27 @@ homepage = "https://github.com/alloy-rs/op-alloy"
 repository = "https://github.com/alloy-rs/op-alloy"
 exclude = ["benches/", "tests/"]
 
+[workspace.dependencies]
+# Alloy
+alloy-primitives = { version = "0.7.0", default-features = false }
+alloy = { git = "https://github.com/alloy-rs/alloy", rev = "89f14f9", features = [
+    "serde",
+    "rpc-types-eth",
+    "rpc-types","rlp","consensus"
+] }
+op-consensus = { version = "0.1.0", default-features = false, path = "crates/op-consensus" }
+op-rpc-types = { version = "0.1.0", default-features = false, path = "crates/op-rpc-types" }
+
+# Serde
+serde = { version = "1.0", default-features = false, features = ["derive", "alloc"] }
+serde_json = { version = "1.0", default-features = false, features = ["alloc"] }
+
+## misc-testing
+arbitrary = { version = "1.3", features = ["derive"] }
+rand = "0.8"
+proptest = "1.4"
+proptest-derive = "0.4"
+
 [workspace.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]

crates/op-rpc-types/Cargo.toml

@@ -10,3 +10,36 @@ homepage.workspace = true
 authors.workspace = true
 repository.workspace = true
 exclude.workspace = true
+
+[dependencies]
+op-consensus = { workspace = true, features = ["serde"]}
+# alloy-rlp = { workspace = true, features = ["arrayvec", "derive"] }
+alloy-primitives = { workspace = true, features = ["rlp", "serde", "std"] }
+# alloy-serde.workspace = true
+# alloy-genesis.workspace = true
+
+# alloy-consensus = { workspace = true, features = ["std", "serde"] }
+# alloy-eips = { workspace = true, features = ["std", "serde"] }
+
+serde = { workspace = true, features = ["derive"] }
+alloy = { workspace = true , features = ["serde", "rpc-types", "rpc-types-eth", "rlp", "consensus"]}
+serde_json.workspace = true
+
+# arbitrary
+arbitrary = { version = "1.3", features = ["derive"], optional = true }
+proptest = { version = "1.4", optional = true }
+proptest-derive = { version = "0.4", optional = true }
+
+[features]
+arbitrary = [
+    "dep:arbitrary",
+    "dep:proptest-derive",
+    "dep:proptest",
+    "alloy-primitives/arbitrary",
+]
+
+[dev-dependencies]
+arbitrary = { workspace = true, features = ["derive"] }
+proptest.workspace = true
+proptest-derive.workspace = true
+rand.workspace = true

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

@@ -1 +1 @@
-
+mod op;

crates/op-rpc-types/src/op/block.rs

@@ -0,0 +1,51 @@
+//! Block RPC types.
+
+#![allow(unknown_lints, non_local_definitions)]
+
+use crate::op::transaction::Transaction;
+use alloy::rpc::types::eth::{
+    BlockTransactions, Header, Rich, Withdrawal
+};
+use alloy_primitives::{B256, U256};
+use serde::{Deserialize, Serialize};
+
+/// Block representation
+#[derive(Default, Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Block{
+    /// Header of the block.
+    #[serde(flatten)]
+    pub header: Header,
+    /// Uncles' hashes.
+    #[serde(default)]
+    pub uncles: Vec<B256>,
+    /// Block Transactions. In the case of an uncle block, this field is not included in RPC
+    /// responses, and when deserialized, it will be set to [BlockTransactions::Uncle].
+    #[serde(
+        default = "BlockTransactions::uncle",
+        skip_serializing_if = "BlockTransactions::is_uncle"
+    )]
+    pub transactions: BlockTransactions<Transaction>,
+    /// Integer the size of this block in bytes.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub size: Option<U256>,
+    /// Withdrawals in the block.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub withdrawals: Option<Vec<Withdrawal>>,
+}
+
+impl Block {
+    /// Converts a block with Tx hashes into a full block.
+    pub fn into_full_block(self, txs: Vec<Transaction>) -> Self {
+        Self { transactions: BlockTransactions::Full(txs), ..self }
+    }
+}
+
+/// A Block representation that allows to include additional fields
+pub type RichBlock = Rich<Block>;
+
+impl From<Block> for RichBlock {
+    fn from(block: Block) -> Self {
+        Rich { inner: block, extra_info: Default::default() }
+    }
+}

crates/op-rpc-types/src/op/call.rs

@@ -0,0 +1,13 @@
+use crate::op::transaction::request::TransactionRequest;
+use alloy::rpc::types::eth::BlockOverrides;
+use serde::{Deserialize, Serialize};
+
+/// Bundle of transactions
+#[derive(Debug, Clone, Default, Eq, PartialEq, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct Bundle {
+    /// All transactions to execute
+    pub transactions: Vec<TransactionRequest>,
+    /// Block overrides to apply
+    pub block_override: Option<BlockOverrides>,
+}

crates/op-rpc-types/src/op/filters.rs

@@ -0,0 +1,69 @@
+use crate::op::Transaction;
+use alloy::rpc::types::eth::Log as RpcLog;
+use alloy_primitives::B256;
+use serde::{Deserialize, Deserializer, Serialize};
+
+/// Response of the `eth_getFilterChanges` RPC.
+#[derive(Clone, Debug, Eq, PartialEq, Serialize)]
+#[serde(untagged)]
+pub enum FilterChanges {
+    /// Empty result.
+    #[serde(with = "empty_array")]
+    Empty,
+    /// New logs.
+    Logs(Vec<RpcLog>),
+    /// New hashes (block or transactions).
+    Hashes(Vec<B256>),
+    /// New transactions.
+    Transactions(Vec<Transaction>),
+}
+mod empty_array {
+    use serde::{Serialize, Serializer};
+
+    pub(super) fn serialize<S>(s: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        (&[] as &[()]).serialize(s)
+    }
+}
+impl<'de> Deserialize<'de> for FilterChanges {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        #[serde(untagged)]
+        enum Changes {
+            Hashes(Vec<B256>),
+            Logs(Vec<RpcLog>),
+            Transactions(Vec<Transaction>),
+        }
+
+        let changes = Changes::deserialize(deserializer)?;
+        let changes = match changes {
+            Changes::Logs(vals) => {
+                if vals.is_empty() {
+                    FilterChanges::Empty
+                } else {
+                    FilterChanges::Logs(vals)
+                }
+            }
+            Changes::Hashes(vals) => {
+                if vals.is_empty() {
+                    FilterChanges::Empty
+                } else {
+                    FilterChanges::Hashes(vals)
+                }
+            }
+            Changes::Transactions(vals) => {
+                if vals.is_empty() {
+                    FilterChanges::Empty
+                } else {
+                    FilterChanges::Transactions(vals)
+                }
+            }
+        };
+        Ok(changes)
+    }
+}

crates/op-rpc-types/src/op/mod.rs

@@ -0,0 +1,6 @@
+mod block;
+mod call;
+mod filters;
+mod pubsub;
+mod transaction;
+pub use alloy::rpc::types::eth::*;

crates/op-rpc-types/src/op/pubsub.rs

@@ -0,0 +1,37 @@
+//! Optimism types for pub-sub
+
+use crate::op::transaction::Transaction;
+use alloy::rpc::types::eth::{pubsub::PubSubSyncStatus, Log, RichHeader};
+use alloy_primitives::B256;
+use serde::{Deserialize, Serialize, Serializer};
+
+/// Subscription result.
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
+#[serde(untagged)]
+pub enum SubscriptionResult {
+    /// New block header.
+    Header(Box<RichHeader>),
+    /// Log
+    Log(Box<Log>),
+    /// Transaction hash
+    TransactionHash(B256),
+    /// Full Transaction
+    FullTransaction(Box<Transaction>),
+    /// SyncStatus
+    SyncState(PubSubSyncStatus),
+}
+
+impl Serialize for SubscriptionResult {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match *self {
+            SubscriptionResult::Header(ref header) => header.serialize(serializer),
+            SubscriptionResult::Log(ref log) => log.serialize(serializer),
+            SubscriptionResult::TransactionHash(ref hash) => hash.serialize(serializer),
+            SubscriptionResult::FullTransaction(ref tx) => tx.serialize(serializer),
+            SubscriptionResult::SyncState(ref sync) => sync.serialize(serializer),
+        }
+    }
+}