Use Flashbots bundle type even in Beaver and Titan types

Author: jmcph4

searcher-api-types/Cargo.toml

@@ -11,3 +11,4 @@ alloy-primitives = "0.8"
 alloy-rlp = "0.3"
 alloy-rpc-types-mev = "0.8"
 eyre = "0.6.12"
+serde_with = "3.12.0"

searcher-api-types/src/beaver.rs

@@ -1,112 +1,43 @@
 //! RPC types that are supported by Beaverbuild
 use alloy_primitives::{hex::FromHex, Address, BlockNumber, Bytes, TxHash};
-use serde::ser::{Serialize, SerializeStruct, Serializer};
+use alloy_rpc_types_mev::EthSendBundle;
+use serde::Serialize;
+use serde_with::{serde_as, skip_serializing_none};
 
 /// Bundle as recognised by Beaverbuild
 ///
 /// Consult <https://beaverbuild.org/docs.html>. Note that the deprecated `replacementUuid` field
 /// has been omitted.
-#[derive(Clone, Debug, Default)]
+#[serde_as]
+#[skip_serializing_none]
+#[derive(Clone, Debug, Default, Serialize)]
 pub struct BeaverBundle {
-    /// List of hex-encoded, raw transactions. Can be empty for cancelling a bundle
-    pub transactions: Vec<Bytes>,
-    /// The block that this bundle will be valid for. 0 means it's valid for the next block (and only this one)
-    pub block_number: BlockNumber,
-    /// If specified and >0, the bundle will only be valid if the block timestamp is greater or equal to `minTimestamp`
-    pub min_timestamp: Option<u64>,
-    /// If specified and >0, the bundle will only be valid if the block timestamp is smaller or equal to `maxTimestamp`
-    pub max_timestamp: Option<u64>,
-    /// A list of transaction hashes contained in the bundle, that can be allowed to revert, or be removed from your bundle if it's deemed useful
-    pub reverting_transaction_hashes: Vec<TxHash>,
+    #[serde(flatten)]
+    pub bundle: EthSendBundle,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
     /// A list of transaction hashes contained in the bundle, that can be allowed to be removed from your bundle if it's deemed useful (but not revert)
     pub dropping_transaction_hashes: Vec<TxHash>,
-    /// An UUID string, which allows you to update/cancel your bundles: if you specify an uuid and we already have a bundle with an identical one, we'll forget about the old bundle. So we can only have a single bundle with a certain `uuid` at all times (and we keep the most recent)
-    pub uuid: Option<String>,
     /// An integer between 1-99. How much of the total priority fee + coinbase payment you want to be refunded for. This will negatively impact your prioritization because this refund is gonna eat into your bundle payment. Example: if a bundle pays 0.2 ETH of priority fee plus 1 ETH to coinbase, a refundPercent set to 50 will result in a transaction being appended after the bundle, paying 0.59 ETH back to the EOA. This is assuming the payout tx will cost beaver 0.01 ETH in fees, which are deduced from the 0.6 ETH payout.
     pub refund_percent: Option<u64>,
     /// You can specify an address that the funds from `refundPercent` will be sent to. If not specified, they will be sent to the `from` address of the first transaction
     pub refund_recipient: Option<Address>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
     /// The hashes of transactions in the bundle that the refund will be based on. If it's empty, we'll use the last transaction
     pub refund_transaction_hashes: Vec<TxHash>,
 }
 
-impl BeaverBundle {
-    pub fn from_rlp_hex(txs: Vec<String>, block_number: BlockNumber) -> eyre::Result<Self> {
-        Ok(Self {
-            transactions: txs
-                .iter()
-                .map(Bytes::from_hex)
-                .collect::<Result<Vec<Bytes>, _>>()?,
-            block_number,
-            ..Self::default()
-        })
-    }
-}
-
-impl Serialize for BeaverBundle {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: Serializer,
-    {
-        let mut state = serializer.serialize_struct("BeaverBundle", 2)?;
-        state.serialize_field("txs", &self.transactions)?;
-        state.serialize_field("blockNumber", &format!("0x{:x}", self.block_number))?;
-
-        if let Some(ref t) = self.min_timestamp {
-            state.serialize_field("minTimestamp", t)?;
-        }
-
-        if let Some(ref t) = self.max_timestamp {
-            state.serialize_field("maxTimestamp", t)?;
-        }
-
-        if !self.reverting_transaction_hashes.is_empty() {
-            state.serialize_field(
-                "revertingTxHashes",
-                &self
-                    .reverting_transaction_hashes
-                    .iter()
-                    .map(|hash| hash.to_string())
-                    .collect::<Vec<String>>(),
-            )?;
-        }
-
-        if !self.dropping_transaction_hashes.is_empty() {
-            state.serialize_field(
-                "droppingTxHashes",
-                &self
-                    .dropping_transaction_hashes
-                    .iter()
-                    .map(|hash| hash.to_string())
-                    .collect::<Vec<String>>(),
-            )?;
-        }
-
-        if let Some(ref uuid) = self.uuid {
-            state.serialize_field("uuid", uuid)?;
-        }
-
-        if let Some(ref refund_pct) = self.refund_percent {
-            state.serialize_field("refundPercent", refund_pct)?;
-        }
-
-        if let Some(ref refund_addr) = self.refund_recipient {
-            state.serialize_field("refundRecipient", refund_addr)?;
-        }
-
-        if !self.refund_transaction_hashes.is_empty() {
-            state.serialize_field(
-                "refundTxHashes",
-                &self
-                    .refund_transaction_hashes
-                    .iter()
-                    .map(|hash| hash.to_string())
-                    .collect::<Vec<String>>(),
-            )?;
-        }
-
-        state.end()
-    }
+pub fn bundle_from_rlp_hex(
+    txs: Vec<String>,
+    block_number: BlockNumber,
+) -> eyre::Result<EthSendBundle> {
+    Ok(EthSendBundle {
+        txs: txs
+            .iter()
+            .map(Bytes::from_hex)
+            .collect::<Result<Vec<Bytes>, _>>()?,
+        block_number,
+        ..EthSendBundle::default()
+    })
 }
 
 #[cfg(test)]
@@ -122,28 +53,34 @@ mod test {
         );
 
         assert!(serde_json::to_string(&BeaverBundle {
-            transactions: vec![],
-            block_number: 21862873,
+            bundle: EthSendBundle {
+                txs: vec![],
+                block_number: 21862873,
+                ..Default::default()
+            },
             ..Default::default()
         })
         .is_ok());
         assert_eq!(
             serde_json::to_string(&BeaverBundle {
-                transactions: vec![],
-                block_number: 21862873,
+                bundle: EthSendBundle {
+                    txs: vec![],
+                    block_number: 21862873,
+                    ..Default::default()
+                },
                 ..Default::default()
             })
             .unwrap(),
             "{\"txs\":[],\"blockNumber\":\"0x14d99d9\"}".to_string()
         );
         assert!(
             serde_json::to_string(&
-                BeaverBundle::from_rlp_hex(vec!["0x02f8b20181948449bdee618501dcd6500083016b93942dabcea55a12d73191aece59f508b191fb68adac80b844095ea7b300000000000000000000000054e44dbb92dba848ace27f44c0cb4268981ef1cc00000000000000000000000000000000000000000000000052616e065f6915ebc080a0c497b6e53d7cb78e68c37f6186c8bb9e1b8a55c3e22462163495979b25c2caafa052769811779f438b73159c4cc6a05a889da8c1a16e432c2e37e3415c9a0b9887".to_string()], 21862873).unwrap()
+                bundle_from_rlp_hex(vec!["0x02f8b20181948449bdee618501dcd6500083016b93942dabcea55a12d73191aece59f508b191fb68adac80b844095ea7b300000000000000000000000054e44dbb92dba848ace27f44c0cb4268981ef1cc00000000000000000000000000000000000000000000000052616e065f6915ebc080a0c497b6e53d7cb78e68c37f6186c8bb9e1b8a55c3e22462163495979b25c2caafa052769811779f438b73159c4cc6a05a889da8c1a16e432c2e37e3415c9a0b9887".to_string()], 21862873).unwrap()
         )
         .is_ok());
         assert_eq!(
             serde_json::to_string(&
-                BeaverBundle::from_rlp_hex(vec!["0x02f8b20181948449bdee618501dcd6500083016b93942dabcea55a12d73191aece59f508b191fb68adac80b844095ea7b300000000000000000000000054e44dbb92dba848ace27f44c0cb4268981ef1cc00000000000000000000000000000000000000000000000052616e065f6915ebc080a0c497b6e53d7cb78e68c37f6186c8bb9e1b8a55c3e22462163495979b25c2caafa052769811779f438b73159c4cc6a05a889da8c1a16e432c2e37e3415c9a0b9887".to_string()], 21862873).unwrap()
+                bundle_from_rlp_hex(vec!["0x02f8b20181948449bdee618501dcd6500083016b93942dabcea55a12d73191aece59f508b191fb68adac80b844095ea7b300000000000000000000000054e44dbb92dba848ace27f44c0cb4268981ef1cc00000000000000000000000000000000000000000000000052616e065f6915ebc080a0c497b6e53d7cb78e68c37f6186c8bb9e1b8a55c3e22462163495979b25c2caafa052769811779f438b73159c4cc6a05a889da8c1a16e432c2e37e3415c9a0b9887".to_string()], 21862873).unwrap()
         )
             .unwrap(),
             "{\"txs\":[\"0x02f8b20181948449bdee618501dcd6500083016b93942dabcea55a12d73191aece59f508b191fb68adac80b844095ea7b300000000000000000000000054e44dbb92dba848ace27f44c0cb4268981ef1cc00000000000000000000000000000000000000000000000052616e065f6915ebc080a0c497b6e53d7cb78e68c37f6186c8bb9e1b8a55c3e22462163495979b25c2caafa052769811779f438b73159c4cc6a05a889da8c1a16e432c2e37e3415c9a0b9887\"],\"blockNumber\":\"0x14d99d9\"}".to_string()

searcher-api-types/src/lib.rs

@@ -28,37 +28,39 @@ impl SendBundleRequest {
     pub fn min_timestamp(&self) -> Option<u64> {
         match self {
             SendBundleRequest::Flashbots(bundle) => bundle.min_timestamp,
-            SendBundleRequest::Beaver(bundle) => bundle.min_timestamp,
-            SendBundleRequest::Titan(bundle) => bundle.min_timestamp,
+            SendBundleRequest::Beaver(bundle) => bundle.bundle.min_timestamp,
+            SendBundleRequest::Titan(bundle) => bundle.bundle.min_timestamp,
         }
     }
 
     pub fn max_timestamp(&self) -> Option<u64> {
         match self {
             SendBundleRequest::Flashbots(bundle) => bundle.max_timestamp,
-            SendBundleRequest::Beaver(bundle) => bundle.max_timestamp,
-            SendBundleRequest::Titan(bundle) => bundle.max_timestamp,
+            SendBundleRequest::Beaver(bundle) => bundle.bundle.max_timestamp,
+            SendBundleRequest::Titan(bundle) => bundle.bundle.max_timestamp,
         }
     }
 
     pub fn block_number(&self) -> BlockNumber {
         match self {
             SendBundleRequest::Flashbots(bundle) => bundle.block_number,
-            SendBundleRequest::Beaver(bundle) => bundle.block_number,
-            SendBundleRequest::Titan(bundle) => bundle.block_number,
+            SendBundleRequest::Beaver(bundle) => bundle.bundle.block_number,
+            SendBundleRequest::Titan(bundle) => bundle.bundle.block_number,
         }
     }
 
     pub fn tx_bytes(&self) -> Vec<Bytes> {
         match self {
             SendBundleRequest::Flashbots(bundle) => bundle.txs.clone(),
             SendBundleRequest::Beaver(bundle) => bundle
-                .transactions
+                .bundle
+                .txs
                 .iter()
                 .map(|tx| encode(tx).into())
                 .collect(),
             SendBundleRequest::Titan(bundle) => bundle
-                .transactions
+                .bundle
+                .txs
                 .iter()
                 .map(|tx| encode(tx).into())
                 .collect(),
@@ -68,8 +70,8 @@ impl SendBundleRequest {
     pub fn reverting_tx_hashes(&self) -> Vec<TxHash> {
         match self {
             SendBundleRequest::Flashbots(_) => vec![],
-            SendBundleRequest::Beaver(bundle) => bundle.reverting_transaction_hashes.clone(),
-            SendBundleRequest::Titan(bundle) => bundle.reverting_transaction_hashes.clone(),
+            SendBundleRequest::Beaver(bundle) => bundle.bundle.reverting_tx_hashes.clone(),
+            SendBundleRequest::Titan(bundle) => bundle.bundle.reverting_tx_hashes.clone(),
         }
     }
 }

searcher-client/src/lib.rs

@@ -17,7 +17,8 @@ pub async fn send_bundle(url: Url, bundle: &SendBundleRequest) -> eyre::Result<E
 mod test {
     use super::*;
 
-    use searcher_api_types::{BeaverBundle, SendBundleRequest};
+    use alloy_rpc_types_mev::EthSendBundle;
+    use searcher_api_types::{bundle_from_rlp_hex, BeaverBundle, SendBundleRequest};
 
     const TEST_ENDPOINT: &str = "https://rpc.beaverbuild.org";
 
@@ -28,8 +29,11 @@ mod test {
     #[tokio::test]
     async fn test_send_bundle_beaver_rejects_empty_bundle() {
         let empty_bundle = SendBundleRequest::Beaver(BeaverBundle {
-            transactions: vec![],
-            block_number: 0,
+            bundle: EthSendBundle {
+                txs: vec![],
+                block_number: 0,
+                ..EthSendBundle::default()
+            },
             ..BeaverBundle::default()
         });
         let res = send_bundle(test_endpoint(), &empty_bundle).await;
@@ -38,7 +42,9 @@ mod test {
 
     #[tokio::test]
     async fn test_send_bundle_beaver_success() {
-        let bundle = SendBundleRequest::Beaver(BeaverBundle::from_rlp_hex(vec!["0x02f8b20181948449bdee618501dcd6500083016b93942dabcea55a12d73191aece59f508b191fb68adac80b844095ea7b300000000000000000000000054e44dbb92dba848ace27f44c0cb4268981ef1cc00000000000000000000000000000000000000000000000052616e065f6915ebc080a0c497b6e53d7cb78e68c37f6186c8bb9e1b8a55c3e22462163495979b25c2caafa052769811779f438b73159c4cc6a05a889da8c1a16e432c2e37e3415c9a0b9887".to_string()], 1).expect("illegal RLP bytes for bundle"));
+        let bundle = SendBundleRequest::Beaver(
+            BeaverBundle { bundle: bundle_from_rlp_hex(vec!["0x02f8b20181948449bdee618501dcd6500083016b93942dabcea55a12d73191aece59f508b191fb68adac80b844095ea7b300000000000000000000000054e44dbb92dba848ace27f44c0cb4268981ef1cc00000000000000000000000000000000000000000000000052616e065f6915ebc080a0c497b6e53d7cb78e68c37f6186c8bb9e1b8a55c3e22462163495979b25c2caafa052769811779f438b73159c4cc6a05a889da8c1a16e432c2e37e3415c9a0b9887".to_string()], 1).expect("illegal RLP bytes for bundle"), ..BeaverBundle::default()}
+        );
         let res = send_bundle(test_endpoint(), &bundle).await;
         assert!(res.is_ok());
         let resp = res.unwrap();