Merge pull request #123 from stejbac/clean-dependencies-and-imports

Clean dependencies and imports

Author: ChrisSon15

Cargo.lock

@@ -4,28 +4,28 @@ members = ["protocol", "rpc", "wallet", "testenv"]
 exclude = ["poc"]
 
 [workspace.dependencies]
-anyhow = "1.0.100"
+anyhow = "1.0.101"
+argon2 = { version = "0.5.3", default-features = false }
+base64 = "0.22.1"
 bdk_bitcoind_rpc = "0.22.0"
 bdk_electrum = { version = "0.23.2", default-features = false, features = ["use-rustls-ring"] }
-rustls = { version = "0.23.35", default-features = false, features = ["ring", "std", "tls12", "logging"] }
+bdk_kyoto = "0.15.4"
 # v2.2.0 deprecates `bdk_wallet::wallet::signer` without making it clear what alternative to use & how:
 bdk_wallet = { version = "~2.1.0", features = ["rusqlite", "keys-bip39"] }
-bdk_kyoto = "0.15.3"
 const_format = "0.2.35"
-rusqlite = { version = "0.31.0", features = ["bundled-sqlcipher"] }
-
+hex = "0.4.3"
 musig2 = { version = "0.3.1", features = ["rand"] }
 rand = "0.9.2"
 rand_chacha = "0.9.0"
+rusqlite = { version = "0.31.0", features = ["bundled-sqlcipher"] }
 secp = "0.6.0"
-thiserror = "2.0.16"
-tokio = "1.48.0"
-base64 = "0.22.1"
-hex = "0.4"
-zeroize = "1.8.1"
-argon2 = { version = "0.5.3", default-features = false }
-tracing = "0.1"
-tracing-subscriber = "0.3"
+simple-semaphore = "0.2.0"
+tempfile = "3.25.0"
+thiserror = "2.0.18"
+tokio = "1.49.0"
+tracing = "0.1.44"
+tracing-subscriber = "0.3.22"
+zeroize = "1.8.2"
 
 [workspace.lints.rust]
 rust-2024-compatibility = "warn"

Cargo.toml

@@ -13,9 +13,8 @@ paste = "1.0.15"
 rand = { workspace = true }
 rand_chacha = { workspace = true }
 thiserror = { workspace = true }
-rustls = { workspace = true }
-# this should move to the dev section
-testenv = { path = "../testenv"}
+# TODO move this to dev-dependencies:
+testenv = { path = "../testenv" }
 
 [dev-dependencies]
 bdk_wallet = { workspace = true, features = ["test-utils"] }

protocol/Cargo.toml

@@ -1,18 +1,12 @@
 use std::io::Write as _;
 use std::str::FromStr as _;
 
-use crate::multisig::{KeyCtx, SigCtx};
-use crate::receiver::{Receiver, ReceiverList};
-use crate::transaction::{
-    DepositTxBuilder, ForwardingTxBuilder, RedirectTxBuilder, WarningTxBuilder, WithWitnesses as _,
-};
-use crate::wallet_service::WalletService;
+use bdk_electrum::BdkElectrumClient;
 use bdk_electrum::electrum_client::Client;
-use bdk_electrum::{electrum_client, BdkElectrumClient};
 use bdk_wallet::bitcoin::bip32::Xpriv;
 use bdk_wallet::bitcoin::{
-    relative, Address, Amount, FeeRate, Network, OutPoint, Psbt, ScriptBuf, Transaction, TxOut,
-    Txid,
+    Address, Amount, FeeRate, Network, OutPoint, Psbt, ScriptBuf, Transaction, TxOut, Txid,
+    relative,
 };
 use bdk_wallet::template::{Bip86, DescriptorTemplate as _};
 use bdk_wallet::{AddressInfo, KeychainKind, SignOptions, Wallet};
@@ -21,9 +15,16 @@ use musig2::{PartialSignature, PubNonce};
 use rand::RngCore as _;
 use testenv::TestEnv;
 
+use crate::multisig::{KeyCtx, SigCtx};
+use crate::receiver::{Receiver, ReceiverList};
+use crate::transaction::{
+    DepositTxBuilder, ForwardingTxBuilder, RedirectTxBuilder, WarningTxBuilder, WithWitnesses as _,
+};
+use crate::wallet_service::WalletService;
+
 pub struct MemWallet {
     wallet: Wallet,
-    client: BdkElectrumClient<electrum_client::Client>,
+    client: BdkElectrumClient<Client>,
 }
 
 impl MemWallet {
@@ -43,7 +44,7 @@ impl MemWallet {
     pub fn funded_wallet(env: &TestEnv) -> Self {
         // TODO move this line to TestEnv
         let client =
-            BdkElectrumClient::new(electrum_client::Client::new(&env.electrum_url()).unwrap());
+            BdkElectrumClient::new(Client::new(&env.electrum_url()).unwrap());
         let mut wallet = Self::new(client).unwrap();
         let address = wallet.next_unused_address();
         let txid = env
@@ -207,9 +208,7 @@ pub struct Round4Parameter {
     pub deposit_tx_signed: Psbt,
 }
 
-/**
-this context is for the whole process and need to be persisted by the caller
-*/
+/// this context is for the whole process and need to be persisted by the caller
 pub struct BMPContext {
     // first of all, everything which is general to the protocol itself
     pub funds: MemWallet,
@@ -428,18 +427,16 @@ impl BMPProtocol {
     }
 }
 
-/**
-`RedirectTx` -- this redirects the funds from the `WarningTx` to the DAO.
-This is expected if the traders have some sor of conflict, which they cannot resolve themselves.
-One trader sends the `WarningTx`, the other trader answers by sending the `RedirectTx`.
-If a redirectTx is not send within `t_2`, then the trader which sent the `WarningTx` can
-send the `ClaimTx` and gets the hole funds for himself.
-Since `RedirectTx` sends the funds to the DAO, it needs an anchors for the trader, so he
-can raise the fees with CPFP to get it mined before `ClaimTx` can be broadcast.
-
-`RedirectTx` Bob spends from `WarningTx` Alice, that's important.
-Sending funds to the DAO is done by having a list of addresses (from contributors) and percentages. (must add up to 100%)
-*/
+/// `RedirectTx` -- this redirects the funds from the `WarningTx` to the DAO.
+/// This is expected if the traders have some sor of conflict, which they cannot resolve themselves.
+/// One trader sends the `WarningTx`, the other trader answers by sending the `RedirectTx`.
+/// If a redirectTx is not send within `t_2`, then the trader which sent the `WarningTx` can
+/// send the `ClaimTx` and gets the hole funds for himself.
+/// Since `RedirectTx` sends the funds to the DAO, it needs an anchors for the trader, so he
+/// can raise the fees with CPFP to get it mined before `ClaimTx` can be broadcast.
+///
+/// `RedirectTx` Bob spends from `WarningTx` Alice, that's important.
+/// Sending funds to the DAO is done by having a list of addresses (from contributors) and percentages. (must add up to 100%)
 #[derive(Default)]
 pub struct RedirectTx {
     pub sig: SigCtx,
@@ -496,9 +493,7 @@ impl RedirectTx {
         Ok(me.funds.client.transaction_broadcast(self.builder.signed_tx()?)?)
     }
 
-    /**
-    sum of all f64 must be 1
-     */
+    /// sum of all f64 must be 1
     //noinspection SpellCheckingInspection
     fn get_dao_bm() -> Vec<(Address, f64)> {
         // TODO this needs a real implementation, and check that sum of ratios is 1
@@ -509,11 +504,9 @@ impl RedirectTx {
     }
 }
 
-/**
-`ClaimTx` -- One version for Alice and one for Bob.
-If the other side will not react on the `WarningTx` (by sending the `RedirectTx`)
-then Alice can claim the total amounts for herself.
-*/
+/// `ClaimTx` -- One version for Alice and one for Bob.
+/// If the other side will not react on the `WarningTx` (by sending the `RedirectTx`)
+/// then Alice can claim the total amounts for herself.
 #[derive(Default)]
 pub struct ClaimTx {
     pub sig: SigCtx,
@@ -563,10 +556,8 @@ impl ClaimTx {
     }
 }
 
-/**
-`WarningTx` -- there is one version for Alice and one for Bob.
-That means each party generates both transaction and sign them.
-*/
+/// `WarningTx` -- there is one version for Alice and one for Bob.
+/// That means each party generates both transaction and sign them.
 pub struct WarningTx {
     // is that my WarningTx? (mainly for safety checking):
     role: ProtocolRole,
@@ -663,9 +654,7 @@ impl WarningTx {
     }
 }
 
-/**
-Only the seller gets a `SwapTx`, this is the only asymmetric part of the p3
-*/
+/// Only the seller gets a `SwapTx`, this is the only asymmetric part of the p3
 pub struct SwapTx {
     // this transaction is only for Alice, however even Bob will construct it for signing:
     pub role: ProtocolRole,
@@ -684,10 +673,8 @@ impl SwapTx {
         self.swap_spend.clone()
     }
 
-    /**
-    even though only the seller gets a `SwapTx` transaction, both parties are constructing the transaction
-    and only the buyer will send the seller the signature.
-     */
+    /// even though only the seller gets a `SwapTx` transaction, both parties are constructing the transaction
+    /// and only the buyer will send the seller the signature.
     fn new(role: ProtocolRole) -> Self {
         Self {
             role,
@@ -753,10 +740,8 @@ impl SwapTx {
         }
     }
 
-    /**
-    if Bob finds a `SwapTx` on chain (or in mempool), we can (and should) extract Alice key for
-    unlocking the seller's deposit and fund, which is as adaptive secret in the signature
-     */
+    /// if Bob finds a `SwapTx` on chain (or in mempool), we can (and should) extract Alice key for
+    /// unlocking the seller's deposit and fund, which is as adaptive secret in the signature
     pub fn reveal(&self, swap_tx: &Transaction, p_tik: &mut KeyCtx) -> anyhow::Result<()> {
         let signature = swap_tx.key_spend_signature(0)?;
         // calculate the aggregated secret key as well.

protocol/src/protocol_musig_adaptor.rs

@@ -1,10 +1,9 @@
-use bdk_electrum::bdk_core::bitcoin;
-use bdk_electrum::bdk_core::bitcoin::key::{Keypair, Secp256k1, TweakedKeypair, TweakedPublicKey};
-use bdk_electrum::bdk_core::bitcoin::secp256k1::Message;
-use bdk_electrum::bdk_core::bitcoin::{Amount, TapSighashType};
-use bdk_wallet::bitcoin::key::TapTweak as _;
-use musig2::secp::Point;
+use bdk_wallet::bitcoin;
+use bitcoin::key::{Keypair, Secp256k1, TapTweak as _, TweakedKeypair, TweakedPublicKey};
+use bitcoin::secp256k1::Message;
+use bitcoin::{Amount, TapSighashType};
 use musig2::KeyAggContext;
+use musig2::secp::Point;
 use protocol::protocol_musig_adaptor::{BMPContext, BMPProtocol, MemWallet, ProtocolRole};
 use protocol::transaction::WithWitnesses as _;
 use protocol::wallet_service::WalletService;
@@ -18,7 +17,6 @@ fn test_initial_tx_creation() -> anyhow::Result<()> {
     Ok(())
 }
 
-
 fn initial_tx_creation(env: &TestEnv) -> anyhow::Result<(BMPProtocol, BMPProtocol)> {
     println!("running...");
     let alice_funds = MemWallet::funded_wallet(env);
@@ -66,8 +64,8 @@ fn initial_tx_creation(env: &TestEnv) -> anyhow::Result<(BMPProtocol, BMPProtoco
 
 #[test]
 fn test_swap() -> anyhow::Result<()> {
-    let mut env = TestEnv::new()?;
-    env.start_explorer_in_container()?;
+    let env = TestEnv::new()?;
+    // env.start_explorer_in_container()?;
 
     // create all transaction and Broadcast DepositTx already
     let (mut alice, mut bob) = initial_tx_creation(&env)?;

protocol/tests/protocol_integration_tests.rs

@@ -9,38 +9,37 @@ default-run = "musig-cli"
 bdk_bitcoind_rpc = { workspace = true }
 bdk_wallet = { workspace = true }
 drop-stream = "0.3.2"
-futures-util = { version = "0.3.31", default-features = false, features = ["alloc"] }
+futures-util = { version = "0.3.32", default-features = false, features = ["alloc"] }
 guardian = "1.3.0"
 musig2 = { workspace = true }
-prost = "0.14.1"
+prost = "0.14.3"
 protocol = { path = "../protocol" }
 rand = { workspace = true }
 serde = { version = "1.0.228", features = ["derive"] }
-serde_with = { version = "3.15.1", features = ["base64", "hex"] }
+serde_with = { version = "3.16.1", features = ["base64", "hex"] }
 thiserror = { workspace = true }
-rustls = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread", "time"] }
-tokio-stream = "0.1.17"
-tonic = "0.14.2"
-tonic-prost = "0.14.2"
-tracing = "0.1.41"
+tokio-stream = "0.1.18"
+tonic = "0.14.4"
+tonic-prost = "0.14.4"
+tracing = { workspace = true }
 unimock = { version = "0.6.8", optional = true }
 # Dependencies used only by the binary target(s):
 # TODO: Consider making a workspace of separate packages to avoid pulling these into the library:
-clap = { version = "4.5.51", features = ["derive"] }
-tracing-subscriber = { version = "0.3.20", features = ["env-filter"] }
-# TODO move this to dev-dependencies
+clap = { version = "4.5.59", features = ["derive"] }
+tracing-subscriber = { workspace = true, features = ["env-filter"] }
+# TODO move this to dev-dependencies:
 testenv = { path ="../testenv"}
 
 [build-dependencies]
-tonic-prost-build = "0.14.2"
+tonic-prost-build = "0.14.4"
 
 [dev-dependencies]
 rpc = { path = ".", features = ["unimock"] }
 anyhow = { workspace = true }
-assert_cmd = "2.1.1"
+assert_cmd = "2.1.2"
 const_format = { workspace = true }
-predicates = "3.1.3"
+predicates = "3.1.4"
 
 [lints]
 workspace = true

rpc/Cargo.toml

@@ -1,12 +1,13 @@
+use std::error::Error;
+use std::sync::Arc;
+
 use clap::Parser;
 use rpc::bmp_service::BmpServiceImpl;
 use rpc::bmp_wallet_service::BmpWalletServiceImpl;
 use rpc::pb::bmp_protocol::bmp_protocol_service_server::BmpProtocolServiceServer;
 use rpc::pb::bmp_wallet::wallet_server::WalletServer as BmpWalletServer;
 use rpc::server::{MusigImpl, MusigServer, WalletImpl, WalletServer};
 use rpc::wallet::WalletServiceImpl;
-use std::error::Error;
-use std::sync::Arc;
 use testenv::TestEnv;
 use tonic::transport::Server;
 use tracing::info;

rpc/src/bin/musigd.rs

@@ -1,16 +1,19 @@
 use std::collections::HashMap;
 use std::sync::Mutex;
 
-use crate::pb::bmp_protocol::bmp_protocol_service_server::BmpProtocolService;
-use crate::pb::bmp_protocol::{self, InitializeRequest, InitializeResponse, Role};
-use crate::pb::convert::TryProtoInto as _;
 use bdk_wallet::bitcoin::Amount;
-use protocol::protocol_musig_adaptor::{BMPContext, BMPProtocol, MemWallet, ProtocolRole, Round1Parameter};
+use protocol::protocol_musig_adaptor::{
+    BMPContext, BMPProtocol, MemWallet, ProtocolRole, Round1Parameter,
+};
 use protocol::wallet_service::WalletService;
 use testenv::TestEnv;
 use tonic::{Request, Response, Result, Status};
 use tracing::info;
 
+use crate::pb::bmp_protocol::bmp_protocol_service_server::BmpProtocolService;
+use crate::pb::bmp_protocol::{self, InitializeRequest, InitializeResponse, Role};
+use crate::pb::convert::TryProtoInto as _;
+
 #[derive(Default)]
 pub struct BmpServiceImpl {
     // Each trade protocol is stored against a unique ID.

rpc/src/bmp_service.rs

@@ -64,6 +64,7 @@ fn shrink_amortized<T>(vec: &mut Vec<T>) {
         vec.shrink_to(vec.len() * 2);
     }
 }
+
 #[derive(Debug)]
 pub struct ObservableHashMap<K, V> {
     map: HashMap<K, Observable<Option<V>>>,
@@ -121,7 +122,7 @@ impl<K, V> ObservableHashMap<K, V>
 }
 
 impl<K, V> ObservableHashMap<K, V>
-where
+    where
         K: Clone + Eq + Hash + Debug,
         V: Clone + PartialEq + Debug,
 {
@@ -134,7 +135,7 @@ where
         for key in remaining_keys {
             self.remove(&key);
         }
-        trace!("ObservableHashMap.len {}",self.map.len());
+        trace!("ObservableHashMap.len {}", self.map.len());
         // dbg!(&self.map);
     }
 }