cleanup

Author: QuantumExplorer

key-wallet-manager/src/lib.rs

@@ -22,7 +22,6 @@ extern crate alloc;
 extern crate std;
 
 pub mod spv_wallet_manager;
-pub mod wallet_info_trait;
 pub mod wallet_interface;
 pub mod wallet_manager;
 

key-wallet-manager/src/spv_wallet_manager.rs

@@ -15,7 +15,6 @@ use dashcore::prelude::CoreBlockHeight;
 use dashcore::{BlockHash, Txid};
 use key_wallet::Network;
 
-use crate::wallet_info_trait::WalletInfoInterface;
 use crate::wallet_interface::WalletInterface;
 use crate::wallet_manager::{WalletId, WalletManager};
 use key_wallet::transaction_checking::TransactionContext;

key-wallet-manager/src/wallet_manager/mod.rs

@@ -15,10 +15,9 @@ use dashcore::Txid;
 use key_wallet::wallet::managed_wallet_info::{ManagedWalletInfo, TransactionRecord};
 use key_wallet::WalletBalance;
 use key_wallet::{Account, AccountType, Address, Mnemonic, Network, Wallet, WalletConfig};
+use std::collections::BTreeSet;
 
-use crate::wallet_info_trait::WalletInfoInterface;
-
-use key_wallet::transaction_checking::{TransactionContext, WalletTransactionChecker};
+use key_wallet::transaction_checking::TransactionContext;
 use key_wallet::wallet::managed_wallet_info::transaction_building::AccountTypePreference;
 use key_wallet::wallet::managed_wallet_info::wallet_info_interface::WalletInfoInterface;
 use key_wallet::{Utxo, UtxoSet};
@@ -301,24 +300,8 @@ impl<T: WalletInfoInterface> WalletManager<T> {
         for wallet_id in wallet_ids {
             // Check the transaction for this wallet
             if let Some(wallet_info) = self.wallet_infos.get_mut(&wallet_id) {
-                // Convert TransactionContext to the expected format
-                let context_tuple = match context {
-                    TransactionContext::InBlock {
-                        height,
-                        ..
-                    }
-                    | TransactionContext::InChainLockedBlock {
-                        height,
-                        ..
-                    } => Some((height, tx.txid())),
-                    TransactionContext::Mempool => None,
-                };
-                let result = wallet_info.check_transaction(
-                    tx,
-                    network,
-                    context_tuple,
-                    update_state_if_found,
-                );
+                let result =
+                    wallet_info.check_transaction(tx, network, context, update_state_if_found);
 
                 // If the transaction is relevant
                 if result.is_relevant {
@@ -776,7 +759,7 @@ impl<T: WalletInfoInterface> WalletManager<T> {
         let managed_info =
             self.wallet_infos.get(wallet_id).ok_or(WalletError::WalletNotFound(*wallet_id))?;
 
-        Ok(managed_info.get_transaction_history())
+        Ok(managed_info.transaction_history())
     }
 
     /// Get UTXOs for all wallets across all networks
@@ -789,13 +772,13 @@ impl<T: WalletInfoInterface> WalletManager<T> {
     }
 
     /// Get UTXOs for a specific wallet
-    pub fn get_wallet_utxos(&self, wallet_id: &WalletId) -> Result<Vec<Utxo>, WalletError> {
+    pub fn wallet_utxos(&self, wallet_id: &WalletId) -> Result<BTreeSet<&Utxo>, WalletError> {
         // Get the wallet info
         let wallet_info =
             self.wallet_infos.get(wallet_id).ok_or(WalletError::WalletNotFound(*wallet_id))?;
 
         // Get UTXOs from the wallet info and clone them
-        let utxos = wallet_info.get_utxos();
+        let utxos = wallet_info.utxos();
 
         Ok(utxos)
     }
@@ -812,7 +795,7 @@ impl<T: WalletInfoInterface> WalletManager<T> {
             self.wallet_infos.get(wallet_id).ok_or(WalletError::WalletNotFound(*wallet_id))?;
 
         // Get balance from the wallet info
-        Ok(wallet_info.get_balance())
+        Ok(wallet_info.balance())
     }
 
     /// Update the cached balance for a specific wallet

key-wallet-manager/src/wallet_manager/process_block.rs

@@ -1,4 +1,3 @@
-use crate::wallet_info_trait::WalletInfoInterface;
 use crate::{Network, WalletManager};
 use dashcore::bip158::BlockFilter;
 use dashcore::prelude::CoreBlockHeight;

key-wallet-manager/src/wallet_manager/transaction_building.rs

@@ -1,7 +1,6 @@
 //! Transaction building functionality for the wallet manager
 
 use super::{WalletError, WalletId, WalletManager};
-use crate::wallet_info_trait::WalletInfoInterface;
 use dashcore::Transaction;
 use key_wallet::wallet::managed_wallet_info::fee::FeeLevel;
 use key_wallet::wallet::managed_wallet_info::transaction_building::{

key-wallet-manager/tests/integration_test.rs

@@ -140,7 +140,7 @@ fn test_utxo_management() {
     // The WalletManager doesn't have an add_utxo method directly
     // Instead, UTXOs are created by processing transactions
 
-    let utxos = manager.get_wallet_utxos(&wallet_id);
+    let utxos = manager.wallet_utxos(&wallet_id);
     assert!(utxos.is_ok());
     // Initially empty
     assert_eq!(utxos.unwrap().len(), 0);

key-wallet/src/transaction_checking/wallet_checker.rs

@@ -6,6 +6,7 @@
 pub(crate) use super::account_checker::TransactionCheckResult;
 use super::transaction_router::TransactionRouter;
 use crate::wallet::immature_transaction::ImmatureTransaction;
+use crate::wallet::managed_wallet_info::wallet_info_interface::WalletInfoInterface;
 use crate::wallet::managed_wallet_info::ManagedWalletInfo;
 use crate::Network;
 use dashcore::blockdata::transaction::Transaction;

key-wallet/src/wallet/managed_wallet_info/mod.rs

@@ -91,68 +91,11 @@ impl ManagedWalletInfo {
         info
     }
 
-    /// Set the wallet name
-    pub fn set_name(&mut self, name: String) {
-        self.name = Some(name);
-    }
-
-    /// Set the wallet description
-    pub fn set_description(&mut self, description: String) {
-        self.description = Some(description);
-    }
-
-    /// Update the last synced timestamp
-    pub fn update_last_synced(&mut self, timestamp: u64) {
-        self.metadata.last_synced = Some(timestamp);
-    }
-
     /// Increment the transaction count
     pub fn increment_transactions(&mut self) {
         self.metadata.total_transactions += 1;
     }
 
-    /// Get a managed account by network and index
-    pub fn get_account(&self, network: Network, index: u32) -> Option<&ManagedAccount> {
-        self.accounts.get(&network).and_then(|collection| collection.get(index))
-    }
-
-    /// Get a mutable managed account by network and index
-    pub fn get_account_mut(&mut self, network: Network, index: u32) -> Option<&mut ManagedAccount> {
-        self.accounts.get_mut(&network).and_then(|collection| collection.get_mut(index))
-    }
-
-    /// Update the cached wallet balance by summing all accounts
-    pub fn update_balance(&mut self) {
-        let mut confirmed = 0u64;
-        let mut unconfirmed = 0u64;
-        let mut locked = 0u64;
-
-        // Sum balances from all accounts across all networks
-        for collection in self.accounts.values() {
-            for account in collection.all_accounts() {
-                for utxo in account.utxos.values() {
-                    let value = utxo.txout.value;
-                    if utxo.is_locked {
-                        locked += value;
-                    } else if utxo.is_confirmed {
-                        confirmed += value;
-                    } else {
-                        unconfirmed += value;
-                    }
-                }
-            }
-        }
-
-        // Update balance, ignoring overflow errors as we're recalculating from scratch
-        self.balance = WalletBalance::new(confirmed, unconfirmed, locked)
-            .unwrap_or_else(|_| WalletBalance::default());
-    }
-
-    /// Get the cached wallet balance
-    pub fn get_balance(&self) -> WalletBalance {
-        self.balance
-    }
-
     /// Get total wallet balance by recalculating from all accounts (for verification)
     pub fn calculate_balance(&self) -> WalletBalance {
         let mut confirmed = 0u64;
@@ -178,167 +121,6 @@ impl ManagedWalletInfo {
         WalletBalance::new(confirmed, unconfirmed, locked)
             .unwrap_or_else(|_| WalletBalance::default())
     }
-
-    /// Get all transaction history across all accounts
-    pub fn get_transaction_history(&self) -> Vec<&TransactionRecord> {
-        let mut transactions = Vec::new();
-
-        // Collect transactions from all accounts across all networks
-        for collection in self.accounts.values() {
-            for account in collection.all_accounts() {
-                transactions.extend(account.transactions.values());
-            }
-        }
-
-        transactions
-    }
-
-    /// Get all UTXOs across all accounts
-    pub fn get_utxos(&self) -> BTreeSet<&Utxo> {
-        let mut utxos = BTreeSet::new();
-
-        // Collect UTXOs from all accounts across all networks
-        for collection in self.accounts.values() {
-            for account in collection.all_accounts() {
-                utxos.extend(account.utxos.values());
-            }
-        }
-
-        utxos
-    }
-
-    /// Get spendable UTXOs (confirmed and not locked)
-    pub fn get_spendable_utxos(&self) -> Vec<&Utxo> {
-        self.get_utxos()
-            .into_iter()
-            .filter(|utxo| !utxo.is_locked && (utxo.is_confirmed || utxo.is_instantlocked))
-            .collect()
-    }
-
-    /// Add an immature transaction
-    pub fn add_immature_transaction(
-        &mut self,
-        network: Network,
-        tx: super::immature_transaction::ImmatureTransaction,
-    ) {
-        self.immature_transactions
-            .entry(network)
-            .or_insert_with(ImmatureTransactionCollection::new)
-            .insert(tx);
-    }
-
-    /// Process matured transactions for a given chain height
-    pub fn process_matured_transactions(
-        &mut self,
-        network: Network,
-        current_height: u32,
-    ) -> Vec<super::immature_transaction::ImmatureTransaction> {
-        if let Some(collection) = self.immature_transactions.get_mut(&network) {
-            let matured = collection.remove_matured(current_height);
-
-            // Update accounts with matured transactions
-            if let Some(account_collection) = self.accounts.get_mut(&network) {
-                for tx in &matured {
-                    // Process BIP44 accounts
-                    for &index in &tx.affected_accounts.bip44_accounts {
-                        if let Some(account) =
-                            account_collection.standard_bip44_accounts.get_mut(&index)
-                        {
-                            // Add transaction record as confirmed
-                            let tx_record = crate::account::TransactionRecord::new_confirmed(
-                                tx.transaction.clone(),
-                                tx.height,
-                                tx.block_hash,
-                                tx.timestamp,
-                                tx.total_received as i64,
-                                false, // Not ours (we received)
-                            );
-                            account.transactions.insert(tx.txid, tx_record);
-                        }
-                    }
-
-                    // Process BIP32 accounts
-                    for &index in &tx.affected_accounts.bip32_accounts {
-                        if let Some(account) =
-                            account_collection.standard_bip32_accounts.get_mut(&index)
-                        {
-                            let tx_record = crate::account::TransactionRecord::new_confirmed(
-                                tx.transaction.clone(),
-                                tx.height,
-                                tx.block_hash,
-                                tx.timestamp,
-                                tx.total_received as i64,
-                                false,
-                            );
-                            account.transactions.insert(tx.txid, tx_record);
-                        }
-                    }
-
-                    // Process CoinJoin accounts
-                    for &index in &tx.affected_accounts.coinjoin_accounts {
-                        if let Some(account) = account_collection.coinjoin_accounts.get_mut(&index)
-                        {
-                            let tx_record = crate::account::TransactionRecord::new_confirmed(
-                                tx.transaction.clone(),
-                                tx.height,
-                                tx.block_hash,
-                                tx.timestamp,
-                                tx.total_received as i64,
-                                false,
-                            );
-                            account.transactions.insert(tx.txid, tx_record);
-                        }
-                    }
-                }
-            }
-
-            // Update balance after processing matured transactions
-            self.update_balance();
-
-            matured
-        } else {
-            Vec::new()
-        }
-    }
-
-    /// Get immature transactions for a network
-    pub fn get_immature_transactions(
-        &self,
-        network: Network,
-    ) -> Option<&ImmatureTransactionCollection> {
-        self.immature_transactions.get(&network)
-    }
-
-    /// Get total immature balance across all networks
-    pub fn total_immature_balance(&self) -> u64 {
-        self.immature_transactions
-            .values()
-            .map(|collection| collection.total_immature_balance())
-            .sum()
-    }
-
-    /// Get immature balance for a specific network
-    pub fn network_immature_balance(&self, network: Network) -> u64 {
-        self.immature_transactions
-            .get(&network)
-            .map(|collection| collection.total_immature_balance())
-            .unwrap_or(0)
-    }
-
-    /// Get monitored addresses for a specific network
-    /// These are automatically collected from all accounts in the network
-    pub fn monitored_addresses(&self, network: Network) -> Vec<Address> {
-        let mut addresses = Vec::new();
-
-        if let Some(collection) = self.accounts.get(&network) {
-            // Collect from all accounts using the account's get_all_addresses method
-            for account in collection.all_accounts() {
-                addresses.extend(account.get_all_addresses());
-            }
-        }
-
-        addresses
-    }
 }
 
 /// Re-export types from account module for convenience

key-wallet/src/wallet/managed_wallet_info/transaction_building.rs

@@ -39,7 +39,7 @@ pub enum TransactionError {
 impl ManagedWalletInfo {
     /// Create an unsigned payment transaction
     #[allow(clippy::too_many_arguments)]
-    pub fn create_unsigned_payment_transaction(
+    pub(crate) fn create_unsigned_payment_transaction_internal(
         &mut self,
         wallet: &Wallet,
         network: Network,
@@ -169,15 +169,11 @@ impl ManagedWalletInfo {
 mod tests {
     use super::*;
     use crate::wallet::managed_wallet_info::transaction_builder::TransactionBuilder;
-    use crate::wallet::Wallet;
     use crate::Utxo;
     use dashcore::blockdata::script::ScriptBuf;
-    use dashcore::blockdata::transaction::special_transaction::asset_lock::AssetLockPayload;
     use dashcore::blockdata::transaction::special_transaction::TransactionPayload;
     use dashcore::{Address, Network, OutPoint, Transaction, TxOut, Txid};
     use dashcore_hashes::{sha256d, Hash};
-    use secp256k1::SecretKey;
-    use std::collections::BTreeMap;
     use std::str::FromStr;
 
     fn test_utxo(value: u64, confirmed: bool) -> Utxo {