Single refund tx (#592)

## 📝 Summary

Only 1 refundTxHashes is allowed.

## ✅ I have completed the following steps:

* [X] Run `make lint`
* [X] Run `make test`
* [ ] Added tests (if applicable)

Author: ZanCorDX

crates/rbuilder/src/building/testing/bundle_tests/mod.rs

@@ -344,7 +344,7 @@ fn test_bundle_ok_refunds() -> eyre::Result<()> {
     test_setup.set_bundle_refund(BundleRefund {
         percent,
         recipient,
-        tx_hashes: vec![profit_tx_hash],
+        tx_hash: profit_tx_hash,
     });
     let result = test_setup.commit_order_ok();
     let recipient_balance_after = test_setup.balance(recipient_named_address)?;

crates/rbuilder/src/primitives/mod.rs

@@ -109,9 +109,9 @@ pub struct BundleRefund {
     pub percent: u8,
     /// Address where to refund to.
     pub recipient: Address,
-    /// A list of transaction hashes to refund.
-    /// This means that part (percent%) of the profit from the execution these txs goes to refund.recipient
-    pub tx_hashes: Vec<TxHash>,
+    /// Transaction hash to refund.
+    /// This means that part (percent%) of the profit from the execution this txs goes to refund.recipient
+    pub tx_hash: TxHash,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -206,10 +206,7 @@ impl Bundle {
     /// Returns `true` if the provided transaction hash is refundable.
     /// This means that part the profit from this execution goes to the self.refund.recipient
     pub fn is_tx_refundable(&self, hash: &B256) -> bool {
-        self.refund
-            .as_ref()
-            .map(|r| r.tx_hashes.contains(hash))
-            .unwrap_or_default()
+        self.refund.as_ref().is_some_and(|r| r.tx_hash == *hash)
     }
 
     fn uuid_v1(&mut self) -> Uuid {
@@ -250,7 +247,11 @@ impl Bundle {
                 + 32
                 + 32 * (self.reverting_tx_hashes.len()
                     + self.dropping_tx_hashes.len()
-                    + self.refund.as_ref().map(|r| r.tx_hashes.len()).unwrap_or(0))
+                    + if self.refund.is_some() {
+                        1usize
+                    } else {
+                        0usize
+                    })
                 + size_of::<char>()
                 + size_of::<Address>(),
         );
@@ -271,11 +272,9 @@ impl Bundle {
         if let Some(refund) = &mut self.refund {
             buff.push(refund.percent);
             buff.extend_from_slice(refund.recipient.as_slice());
-            refund.tx_hashes.sort();
-            buff.append(&mut (refund.tx_hashes.len() as u64).encode_var_vec());
-            for tx_hash in &refund.tx_hashes {
-                buff.extend_from_slice(tx_hash.as_slice());
-            }
+            // We used to allow multiple hashes and encode the len, we keep the 1 to be backwards compatible.
+            buff.append(&mut (1u64).encode_var_vec());
+            buff.extend_from_slice(refund.tx_hash.as_slice());
         }
         Self::uuid_from_buffer(buff)
     }

crates/rbuilder/src/primitives/serialize.rs

@@ -190,6 +190,8 @@ pub enum RawBundleConvertError {
     UnsupportedVersion(String),
     #[error("Field {0} not supported by version {1:?}")]
     FieldNotSupportedByVersion(String, BundleVersion),
+    #[error("More than one refund tx hash not supported")]
+    MoreThanOneRefundTxHash,
 }
 
 /// Since we use the same API (eth_sendBundle) to get new bundles and also to cancel them we need this struct.
@@ -333,13 +335,22 @@ impl RawBundle {
         if let Some(percent) = refund_percent {
             // Refund can be configured only if bundle is not empty.
             // If bundle contains only one transaction, first == last.
+            // If refund_tx_hashes is empty we use the last tx.
             if let Some((first_tx, last_tx)) = txs.first().zip(txs.last()) {
+                let tx_hash = if let Some(refund_tx_hashes) = refund_tx_hashes {
+                    if refund_tx_hashes.len() > 1 {
+                        return Err(RawBundleConvertError::MoreThanOneRefundTxHash);
+                    }
+                    refund_tx_hashes.first().copied()
+                } else {
+                    None
+                }
+                .unwrap_or(last_tx.hash());
+
                 refund = Some(BundleRefund {
                     percent,
                     recipient: refund_recipient.unwrap_or_else(|| first_tx.signer()),
-                    tx_hashes: refund_tx_hashes
-                        .filter(|tx_hashes| !tx_hashes.is_empty())
-                        .unwrap_or_else(|| Vec::from([last_tx.hash()])),
+                    tx_hash,
                 });
             }
         }
@@ -411,7 +422,7 @@ impl RawBundle {
             replacement_nonce,
             refund_percent: value.refund.as_ref().map(|br| br.percent),
             refund_recipient: value.refund.as_ref().map(|br| br.recipient),
-            refund_tx_hashes: value.refund.map(|br| br.tx_hashes),
+            refund_tx_hashes: value.refund.map(|br| vec![br.tx_hash]),
             first_seen_at: None,
             version: Some(Self::encode_version(value.version)),
         }
@@ -1128,21 +1139,100 @@ mod tests {
             .clone()
             .decode_new_bundle(TxEncoding::WithBlobData)
             .expect("failed to convert bundle request to bundle");
-
+        println!("{}", bundle.txs[0].hash());
         assert_eq!(bundle.block, None);
         assert_eq!(
             bundle.refund,
             Some(BundleRefund {
                 percent: 1,
                 recipient: Address::from_str("0x95222290dd7278aa3ddd389cc1e1d165cc4bafe5").unwrap(),
-                tx_hashes: Vec::from([b256!(
+                tx_hash: b256!(
                     "0x75662ab9cb6d1be7334723db5587435616352c7e581a52867959ac24006ac1fe"
-                )]),
+                ),
             })
         );
         assert_eq!(bundle.uuid, uuid!("e2bdb8cd-9473-5a1b-b425-57fa7ecfe2c1"));
     }
 
+    /// If refundTxHashes is missing it should use the last tx and the id should be the same.
+    #[test]
+    fn test_correct_bundle_decoding_refund_hash_missing() {
+        // raw json string
+        let base_bundle_json = r#"
+        {
+            "version": "v2",
+            "txs": [
+                "0x02f86b83aa36a780800982520894f24a01ae29dec4629dfb4170647c4ed4efc392cd861ca62a4c95b880c080a07d37bb5a4da153a6fbe24cf1f346ef35748003d1d0fc59cf6c17fb22d49e42cea02c231ac233220b494b1ad501c440c8b1a34535cdb8ca633992d6f35b14428672"
+            ],
+            "blockNumber": 0,
+            "minTimestamp": 123,
+            "maxTimestamp": 1234,
+            "revertingTxHashes": ["0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"],
+            "droppingTxHashes": ["0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"],
+            "refundPercent": 1,
+            "refundRecipient": "0x95222290dd7278aa3ddd389cc1e1d165cc4bafe5"
+        "#;
+        let bundles = [
+            base_bundle_json.to_owned() + "}",
+            base_bundle_json.to_owned()
+                + r#","refundTxHashes": ["0x84310f7f7860f0cd65407fe340d471ca008d0c58976746a560312d4aebba3f4a"]}"#,
+        ];
+
+        for bundle_json in bundles {
+            let bundle_request: RawBundle =
+                serde_json::from_str(&bundle_json).expect("failed to decode bundle");
+
+            let bundle = bundle_request
+                .clone()
+                .decode_new_bundle(TxEncoding::WithBlobData)
+                .expect("failed to convert bundle request to bundle");
+            assert_eq!(bundle.block, None);
+            assert_eq!(
+                bundle.refund,
+                Some(BundleRefund {
+                    percent: 1,
+                    recipient: Address::from_str("0x95222290dd7278aa3ddd389cc1e1d165cc4bafe5")
+                        .unwrap(),
+                    tx_hash: b256!(
+                        "0x84310f7f7860f0cd65407fe340d471ca008d0c58976746a560312d4aebba3f4a"
+                    ),
+                })
+            );
+            assert_eq!(bundle.uuid, uuid!("ea9954e1-b7be-5af0-9c39-6b11c9d24c05"));
+        }
+    }
+
+    /// More than 1 refundTxHashes should fail.
+    #[test]
+    fn test_fail_bundle_decoding_2_refund_hashes() {
+        // raw json string
+        let bundle_json = r#"
+        {
+            "version": "v2",
+            "txs": [
+                "0x02f86b83aa36a780800982520894f24a01ae29dec4629dfb4170647c4ed4efc392cd861ca62a4c95b880c080a07d37bb5a4da153a6fbe24cf1f346ef35748003d1d0fc59cf6c17fb22d49e42cea02c231ac233220b494b1ad501c440c8b1a34535cdb8ca633992d6f35b14428672"
+            ],
+            "blockNumber": 0,
+            "minTimestamp": 123,
+            "maxTimestamp": 1234,
+            "revertingTxHashes": ["0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"],
+            "droppingTxHashes": ["0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"],
+            "refundPercent": 1,
+            "refundRecipient": "0x95222290dd7278aa3ddd389cc1e1d165cc4bafe5",
+            "refundTxHashes": ["0x84310f7f7860f0cd65407fe340d471ca008d0c58976746a560312d4aebba3f4a","0x84310f7f7860f0cd65407fe340d471ca008d0c58976746a560312d4aebba3f4a"]
+        }
+        "#;
+        let bundle_request: RawBundle =
+            serde_json::from_str(bundle_json).expect("failed to decode bundle");
+
+        assert!(matches!(
+            bundle_request
+                .clone()
+                .decode_new_bundle(TxEncoding::WithBlobData),
+            Err(RawBundleConvertError::MoreThanOneRefundTxHash)
+        ));
+    }
+
     /// Should default to last version.
     #[test]
     fn test_correct_bundle_decoding_no_version() {