feat: Add transaction_broadcast_package method for package relay

Add support for the `blockchain.transaction.broadcast_package` RPC method
introduced in protocol v1.6 for package relay (CPFP) support.

- Add `BroadcastPackageRes` and `BroadcastPackageError` types
- Add `Param::StringVec` variant for array parameters
- Add `transaction_broadcast_package_raw` trait method with generic `AsRef<[u8]>`
- Add `transaction_broadcast_package` convenience method that serializes transactions

Co-Authored-By: Claude Code AI

Author: tnull

src/api.rs

@@ -141,6 +141,13 @@ where
         (**self).transaction_broadcast_raw(raw_tx)
     }
 
+    fn transaction_broadcast_package_raw<T: AsRef<[u8]>>(
+        &self,
+        raw_txs: &[T],
+    ) -> Result<BroadcastPackageRes, Error> {
+        (**self).transaction_broadcast_package_raw(raw_txs)
+    }
+
     fn transaction_get_merkle(&self, txid: &Txid, height: usize) -> Result<GetMerkleRes, Error> {
         (**self).transaction_get_merkle(txid, height)
     }
@@ -253,6 +260,21 @@ pub trait ElectrumApi {
         self.transaction_broadcast_raw(&buffer)
     }
 
+    /// Broadcasts a package of transactions to the network.
+    ///
+    /// The package must consist of a child with its parents, where none of the parents
+    /// depend on one another. The package must be topologically sorted, with the child
+    /// being the last element in the array.
+    ///
+    /// This method was added in protocol v1.6 for package relay support.
+    fn transaction_broadcast_package(
+        &self,
+        txs: &[Transaction],
+    ) -> Result<BroadcastPackageRes, Error> {
+        let raw_txs: Vec<Vec<u8>> = txs.iter().map(serialize).collect();
+        self.transaction_broadcast_package_raw(&raw_txs)
+    }
+
     /// Executes the requested API call returning the raw answer.
     fn raw_call(
         &self,
@@ -385,6 +407,18 @@ pub trait ElectrumApi {
     /// Broadcasts the raw bytes of a transaction to the network.
     fn transaction_broadcast_raw(&self, raw_tx: &[u8]) -> Result<Txid, Error>;
 
+    /// Broadcasts a package of raw transactions to the network.
+    ///
+    /// The package must consist of a child with its parents, where none of the parents
+    /// depend on one another. The package must be topologically sorted, with the child
+    /// being the last element in the array.
+    ///
+    /// This method was added in protocol v1.6 for package relay support.
+    fn transaction_broadcast_package_raw<T: AsRef<[u8]>>(
+        &self,
+        raw_txs: &[T],
+    ) -> Result<BroadcastPackageRes, Error>;
+
     /// Returns the merkle path for the transaction `txid` confirmed in the block at `height`.
     fn transaction_get_merkle(&self, txid: &Txid, height: usize) -> Result<GetMerkleRes, Error>;
 
@@ -612,6 +646,13 @@ mod test {
             unreachable!()
         }
 
+        fn transaction_broadcast_package_raw<T: AsRef<[u8]>>(
+            &self,
+            _: &[T],
+        ) -> Result<super::BroadcastPackageRes, super::Error> {
+            unreachable!()
+        }
+
         fn transaction_get_merkle(
             &self,
             _: &bitcoin::Txid,

src/client.rs

@@ -322,6 +322,14 @@ impl ElectrumApi for Client {
         impl_inner_call!(self, transaction_broadcast_raw, raw_tx)
     }
 
+    #[inline]
+    fn transaction_broadcast_package_raw<T: AsRef<[u8]>>(
+        &self,
+        raw_txs: &[T],
+    ) -> Result<BroadcastPackageRes, Error> {
+        impl_inner_call!(self, transaction_broadcast_package_raw, raw_txs)
+    }
+
     #[inline]
     fn transaction_get_merkle(&self, txid: &Txid, height: usize) -> Result<GetMerkleRes, Error> {
         impl_inner_call!(self, transaction_get_merkle, txid, height)

src/raw_client.rs

@@ -1213,6 +1213,25 @@ impl<T: Read + Write> ElectrumApi for RawClient<T> {
         Ok(serde_json::from_value(result)?)
     }
 
+    fn transaction_broadcast_package_raw<Tx: AsRef<[u8]>>(
+        &self,
+        raw_txs: &[Tx],
+    ) -> Result<BroadcastPackageRes, Error> {
+        let hex_txs: Vec<String> = raw_txs
+            .iter()
+            .map(|tx| tx.as_ref().to_lower_hex_string())
+            .collect();
+        let params = vec![Param::StringVec(hex_txs)];
+        let req = Request::new_id(
+            self.last_id.fetch_add(1, Ordering::SeqCst),
+            "blockchain.transaction.broadcast_package",
+            params,
+        );
+        let result = self.call(req)?;
+
+        Ok(serde_json::from_value(result)?)
+    }
+
     fn transaction_get_merkle(&self, txid: &Txid, height: usize) -> Result<GetMerkleRes, Error> {
         let params = vec![Param::String(format!("{:x}", txid)), Param::Usize(height)];
         let req = Request::new_id(
@@ -1380,6 +1399,17 @@ mod test {
         assert!(resp.incrementalrelayfee >= 0.0);
     }
 
+    #[test]
+    #[ignore = "requires a server supporting protocol v1.6 and valid transactions"]
+    fn test_transaction_broadcast_package() {
+        let client = RawClient::new(get_test_server(), None).unwrap();
+
+        // Empty package should return an error or unsuccessful response
+        let resp = client.transaction_broadcast_package_raw::<Vec<u8>>(&[]);
+        // The server may reject an empty package with a protocol error
+        assert!(resp.is_err() || !resp.unwrap().success);
+    }
+
     #[test]
     #[ignore = "depends on a live server"]
     fn test_batch_response_ordering() {

src/types.rs

@@ -33,6 +33,8 @@ pub enum Param {
     Bool(bool),
     /// Bytes array parameter
     Bytes(Vec<u8>),
+    /// String array parameter
+    StringVec(Vec<String>),
 }
 
 /// Fee estimation mode for [`estimate_fee`](../api/trait.ElectrumApi.html#method.estimate_fee).
@@ -334,6 +336,29 @@ pub struct TxidFromPosRes {
     pub merkle: Vec<[u8; 32]>,
 }
 
+/// Error details for a transaction that failed to broadcast in a package.
+#[derive(Clone, Debug, Deserialize)]
+pub struct BroadcastPackageError {
+    /// The txid of the transaction that failed.
+    pub txid: Txid,
+    /// The error message describing why the transaction was rejected.
+    pub error: String,
+}
+
+/// Response to a [`transaction_broadcast_package`](../client/struct.Client.html#method.transaction_broadcast_package)
+/// request.
+///
+/// This method was added in protocol v1.6 for package relay support.
+#[derive(Clone, Debug, Deserialize)]
+pub struct BroadcastPackageRes {
+    /// Whether the package was successfully accepted by the mempool.
+    pub success: bool,
+    /// List of errors for transactions that were rejected.
+    /// Only present if some transactions failed.
+    #[serde(default)]
+    pub errors: Vec<BroadcastPackageError>,
+}
+
 /// Notification of a new block header
 #[derive(Clone, Debug, Deserialize)]
 pub struct HeaderNotification {