fix(tests): bdk_chain

Author: oleonardolima

crates/chain/tests/test_indexed_tx_graph.rs

@@ -3,10 +3,7 @@
 #[macro_use]
 mod common;
 
-use std::{
-    collections::{BTreeSet, HashMap},
-    sync::Arc,
-};
+use std::{collections::BTreeSet, str::FromStr, sync::Arc};
 
 use bdk_chain::{
     indexed_tx_graph::{self, IndexedTxGraph},
@@ -18,14 +15,15 @@ use bdk_chain::{
 };
 use bdk_testenv::{
     anyhow::{self},
-    bitcoincore_rpc::{json::CreateRawTransactionInput, RpcApi},
-    block_id, hash,
+    block_id,
+    corepc_node::{Input, Output},
+    hash,
     utils::{new_tx, DESCRIPTORS},
     TestEnv,
 };
 use bitcoin::{
-    secp256k1::Secp256k1, Address, Amount, BlockHash, Network, OutPoint, ScriptBuf, Transaction,
-    TxIn, TxOut, Txid,
+    secp256k1::Secp256k1, Address, Amount, BlockHash, Network,
+    OutPoint, ScriptBuf, Transaction, TxIn, TxOut, Txid,
 };
 use miniscript::Descriptor;
 
@@ -67,6 +65,7 @@ fn relevant_conflicts() -> anyhow::Result<()> {
 
             let sender_addr = client
                 .get_new_address(None, None)?
+                .address()?
                 .require_network(Network::Regtest)?;
 
             let recv_spk = gen_spk();
@@ -78,31 +77,39 @@ fn relevant_conflicts() -> anyhow::Result<()> {
             env.mine_blocks(1, Some(sender_addr.clone()))?;
             env.mine_blocks(101, None)?;
 
+            // TODO: (@oleonardolima) remove unwraps
             let tx_input = client
-                .list_unspent(None, None, None, None, None)?
+                .list_unspent()?
+                .0
                 .into_iter()
                 .take(1)
-                .map(|r| CreateRawTransactionInput {
-                    txid: r.txid,
-                    vout: r.vout,
+                .map(|r| Input {
+                    txid: Txid::from_str(&r.txid).unwrap(),
+                    vout: r.vout as u64,
                     sequence: None,
                 })
                 .collect::<Vec<_>>();
             let tx_send = {
-                let outputs =
-                    HashMap::from([(recv_addr.to_string(), Amount::from_btc(49.999_99)?)]);
-                let tx = client.create_raw_transaction(&tx_input, &outputs, None, Some(true))?;
+                let outputs = [Output::new(recv_addr, Amount::from_btc(49.999_99)?)];
+                let tx = client
+                    .create_raw_transaction(&tx_input, &outputs)?
+                    .into_model()?
+                    .0;
                 client
-                    .sign_raw_transaction_with_wallet(&tx, None, None)?
-                    .transaction()?
+                    .sign_raw_transaction_with_wallet(&tx)?
+                    .into_model()?
+                    .tx
             };
             let tx_cancel = {
-                let outputs =
-                    HashMap::from([(sender_addr.to_string(), Amount::from_btc(49.999_98)?)]);
-                let tx = client.create_raw_transaction(&tx_input, &outputs, None, Some(true))?;
+                let outputs = [Output::new(sender_addr, Amount::from_btc(49.999_98)?)];
+                let tx = client
+                    .create_raw_transaction(&tx_input, &outputs)?
+                    .into_model()?
+                    .0;
                 client
-                    .sign_raw_transaction_with_wallet(&tx, None, None)?
-                    .transaction()?
+                    .sign_raw_transaction_with_wallet(&tx)?
+                    .into_model()?
+                    .tx
             };
 
             Ok(Self {
@@ -118,31 +125,53 @@ fn relevant_conflicts() -> anyhow::Result<()> {
         /// Scans through all transactions in the blockchain + mempool.
         fn sync(&mut self) -> anyhow::Result<()> {
             let client = self.env.rpc_client();
-            for height in 0..=client.get_block_count()? {
-                let hash = client.get_block_hash(height)?;
-                let block = client.get_block(&hash)?;
+            for height in 0..=client.get_block_count()?.into_model().0 {
+                let hash = client.get_block_hash(height)?.block_hash()?;
+                let block = client.get_block(hash)?;
                 let _ = self.graph.apply_block_relevant(&block, height as _);
             }
-            let _ = self.graph.batch_insert_relevant_unconfirmed(
-                client
-                    .get_raw_mempool()?
-                    .into_iter()
-                    .map(|txid| client.get_raw_transaction(&txid, None).map(|tx| (tx, 0)))
-                    .collect::<Result<Vec<_>, _>>()?,
-            );
+
+            let mempool_txids = client.get_raw_mempool()?.into_model()?.0;
+            let unconfirmed_txs = mempool_txids
+                .iter()
+                .map(|txid| {
+                    client
+                        .get_raw_transaction(*txid)
+                        .unwrap()
+                        .into_model()
+                        .unwrap()
+                })
+                .map(|get_raw_transaction| (get_raw_transaction.0, 0))
+                .collect::<Vec<_>>();
+            // let unconfirmed_txs = mempool_txids
+            //     .iter()
+            //     // .map(|txid| -> Result<_, _> { client.get_raw_transaction(*txid)?.into_model() })?
+            //     .map(
+            //         |txid| -> Result<
+            //             GetRawTransaction,
+            //             bdk_testenv::corepc_client::client_sync::Error,
+            //         > { client.get_raw_transaction(*txid) },
+            //     )
+            //     .collect::<Vec<Result<_, _>>>()
+            //     .map(|get_raw_tx| get_raw_tx.into_model())
+            //     .map(|tx| (tx.0, 0))
+            //     .collect::<Vec<(Transaction, u64)>>();
+            let _ = self
+                .graph
+                .batch_insert_relevant_unconfirmed(unconfirmed_txs);
             Ok(())
         }
 
         /// Broadcast the original sending transaction.
         fn broadcast_send(&self) -> anyhow::Result<Txid> {
             let client = self.env.rpc_client();
-            Ok(client.send_raw_transaction(&self.tx_send)?)
+            Ok(client.send_raw_transaction(&self.tx_send)?.txid()?)
         }
 
         /// Broadcast the cancellation transaction.
         fn broadcast_cancel(&self) -> anyhow::Result<Txid> {
             let client = self.env.rpc_client();
-            Ok(client.send_raw_transaction(&self.tx_cancel)?)
+            Ok(client.send_raw_transaction(&self.tx_cancel)?.txid()?)
         }
     }