diff --git a/applications/minotari_app_grpc/proto/wallet.proto b/applications/minotari_app_grpc/proto/wallet.proto index 6d87cd46da..a10a7f8326 100644 --- a/applications/minotari_app_grpc/proto/wallet.proto +++ b/applications/minotari_app_grpc/proto/wallet.proto @@ -214,13 +214,17 @@ enum TransactionStatus { // The transaction was rejected by the mempool TRANSACTION_STATUS_REJECTED = 7; // This is faux transaction mainly for one-sided transaction outputs or wallet recovery outputs have been found - TRANSACTION_STATUS_FAUX_UNCONFIRMED = 8; + TRANSACTION_STATUS_ONE_SIDED_UNCONFIRMED = 8; // All Imported and FauxUnconfirmed transactions will end up with this status when the outputs have been confirmed - TRANSACTION_STATUS_FAUX_CONFIRMED = 9; + TRANSACTION_STATUS_ONE_SIDED_CONFIRMED = 9; // This transaction is still being queued for sending TRANSACTION_STATUS_QUEUED = 10; // The transaction was not found by the wallet its in transaction database TRANSACTION_STATUS_NOT_FOUND = 11; + // This is Coinbase transaction that is detected from chain + TRANSACTION_STATUS_COINBASE_UNCONFIRMED = 12; + // This is Coinbase transaction that is detected from chain + TRANSACTION_STATUS_COINBASE_CONFIRMED = 13; } message GetCompletedTransactionsRequest { } diff --git a/applications/minotari_app_grpc/src/conversions/transaction.rs b/applications/minotari_app_grpc/src/conversions/transaction.rs index 77c9bb5176..fbb078c8c2 100644 --- a/applications/minotari_app_grpc/src/conversions/transaction.rs +++ b/applications/minotari_app_grpc/src/conversions/transaction.rs @@ -100,8 +100,10 @@ impl From for grpc::TransactionStatus { Coinbase => grpc::TransactionStatus::Coinbase, MinedConfirmed => grpc::TransactionStatus::MinedConfirmed, Rejected => grpc::TransactionStatus::Rejected, - FauxUnconfirmed => grpc::TransactionStatus::FauxUnconfirmed, - FauxConfirmed => grpc::TransactionStatus::FauxConfirmed, + OneSidedUnconfirmed => grpc::TransactionStatus::OneSidedUnconfirmed, + OneSidedConfirmed => grpc::TransactionStatus::OneSidedConfirmed, + CoinbaseUnconfirmed => grpc::TransactionStatus::CoinbaseUnconfirmed, + CoinbaseConfirmed => grpc::TransactionStatus::CoinbaseConfirmed, Queued => grpc::TransactionStatus::Queued, } } diff --git a/applications/minotari_console_wallet/src/grpc/wallet_grpc_server.rs b/applications/minotari_console_wallet/src/grpc/wallet_grpc_server.rs index ac7f8df2e3..976f30014e 100644 --- a/applications/minotari_console_wallet/src/grpc/wallet_grpc_server.rs +++ b/applications/minotari_console_wallet/src/grpc/wallet_grpc_server.rs @@ -682,8 +682,8 @@ impl wallet_server::Wallet for WalletGrpcServer { } }, ReceivedFinalizedTransaction(tx_id) => handle_completed_tx(tx_id, RECEIVED, &mut transaction_service, &mut sender).await, - TransactionMinedUnconfirmed{tx_id, num_confirmations: _, is_valid: _} | FauxTransactionUnconfirmed{tx_id, num_confirmations: _, is_valid: _}=> handle_completed_tx(tx_id, CONFIRMATION, &mut transaction_service, &mut sender).await, - TransactionMined{tx_id, is_valid: _} | FauxTransactionConfirmed{tx_id, is_valid: _} => handle_completed_tx(tx_id, MINED, &mut transaction_service, &mut sender).await, + TransactionMinedUnconfirmed{tx_id, num_confirmations: _, is_valid: _} | DetectedTransactionUnconfirmed{tx_id, num_confirmations: _, is_valid: _}=> handle_completed_tx(tx_id, CONFIRMATION, &mut transaction_service, &mut sender).await, + TransactionMined{tx_id, is_valid: _} | DetectedTransactionConfirmed{tx_id, is_valid: _} => handle_completed_tx(tx_id, MINED, &mut transaction_service, &mut sender).await, TransactionCancelled(tx_id, _) => { match transaction_service.get_any_transaction(tx_id).await{ Ok(Some(wallet_tx)) => { diff --git a/applications/minotari_console_wallet/src/ui/state/wallet_event_monitor.rs b/applications/minotari_console_wallet/src/ui/state/wallet_event_monitor.rs index 99c6954b2c..da5a085e23 100644 --- a/applications/minotari_console_wallet/src/ui/state/wallet_event_monitor.rs +++ b/applications/minotari_console_wallet/src/ui/state/wallet_event_monitor.rs @@ -109,7 +109,7 @@ impl WalletEventMonitor { ).await; }, TransactionEvent::TransactionMinedUnconfirmed{tx_id, num_confirmations, is_valid: _} | - TransactionEvent::FauxTransactionUnconfirmed{tx_id, num_confirmations, is_valid: _}=> { + TransactionEvent::DetectedTransactionUnconfirmed{tx_id, num_confirmations, is_valid: _}=> { self.trigger_confirmations_refresh(tx_id, num_confirmations).await; self.trigger_tx_state_refresh(tx_id).await; self.trigger_balance_refresh(); @@ -123,7 +123,7 @@ impl WalletEventMonitor { ).await; }, TransactionEvent::TransactionMined{tx_id, is_valid: _} | - TransactionEvent::FauxTransactionConfirmed{tx_id, is_valid: _}=> { + TransactionEvent::DetectedTransactionConfirmed{tx_id, is_valid: _}=> { self.trigger_confirmations_cleanup(tx_id).await; self.trigger_tx_state_refresh(tx_id).await; self.trigger_balance_refresh(); diff --git a/base_layer/common_types/src/transaction.rs b/base_layer/common_types/src/transaction.rs index 63f483606c..39004f602c 100644 --- a/base_layer/common_types/src/transaction.rs +++ b/base_layer/common_types/src/transaction.rs @@ -15,38 +15,96 @@ pub use crate::tx_id::TxId; #[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] pub enum TransactionStatus { /// This transaction has been completed between the parties but has not been broadcast to the base layer network. - Completed, + Completed = 0, /// This transaction has been broadcast to the base layer network and is currently in one or more base node /// mempools. - Broadcast, + Broadcast = 1, /// This transaction has been mined and included in a block. - MinedUnconfirmed, + MinedUnconfirmed = 2, /// This transaction was generated as part of importing a spendable unblinded UTXO - Imported, + Imported = 3, /// This transaction is still being negotiated by the parties #[default] - Pending, + Pending = 4, /// This is a created Coinbase Transaction - Coinbase, + Coinbase = 5, /// This transaction is mined and confirmed at the current base node's height - MinedConfirmed, + MinedConfirmed = 6, /// This transaction was Rejected by the mempool - Rejected, - /// This is faux transaction mainly for one-sided transaction outputs or wallet recovery outputs have been found - FauxUnconfirmed, - /// All Imported and FauxUnconfirmed transactions will end up with this status when the outputs have been confirmed - FauxConfirmed, + Rejected = 7, + /// This transaction import status is used when a one-sided transaction has been scanned but is unconfirmed + OneSidedUnconfirmed = 8, + /// This transaction import status is used when a one-sided transaction has been scanned and confirmed + OneSidedConfirmed = 9, /// This transaction is still being queued for initial sending - Queued, + Queued = 10, + /// This transaction import status is used when a one-sided transaction has been scanned but is unconfirmed + CoinbaseUnconfirmed = 11, + /// This transaction import status is used when a one-sided transaction has been scanned and confirmed + CoinbaseConfirmed = 12, } impl TransactionStatus { - pub fn is_faux(&self) -> bool { + pub fn is_imported_from_chain(&self) -> bool { matches!( self, - TransactionStatus::Imported | TransactionStatus::FauxUnconfirmed | TransactionStatus::FauxConfirmed + TransactionStatus::Imported | TransactionStatus::OneSidedUnconfirmed | TransactionStatus::OneSidedConfirmed ) } + + pub fn is_coinbase(&self) -> bool { + matches!( + self, + TransactionStatus::CoinbaseUnconfirmed | TransactionStatus::CoinbaseConfirmed + ) + } + + pub fn is_confirmed(&self) -> bool { + matches!( + self, + TransactionStatus::OneSidedConfirmed | + TransactionStatus::CoinbaseConfirmed | + TransactionStatus::MinedConfirmed + ) + } + + pub fn mined_confirm(&self) -> Self { + match self { + TransactionStatus::Completed | + TransactionStatus::Broadcast | + TransactionStatus::Pending | + TransactionStatus::Coinbase | + TransactionStatus::Rejected | + TransactionStatus::Queued | + TransactionStatus::MinedUnconfirmed | + TransactionStatus::MinedConfirmed => TransactionStatus::MinedConfirmed, + TransactionStatus::Imported | + TransactionStatus::OneSidedUnconfirmed | + TransactionStatus::OneSidedConfirmed => TransactionStatus::OneSidedConfirmed, + TransactionStatus::CoinbaseConfirmed | TransactionStatus::CoinbaseUnconfirmed => { + TransactionStatus::CoinbaseConfirmed + }, + } + } + + pub fn mined_unconfirm(&self) -> Self { + match self { + TransactionStatus::Completed | + TransactionStatus::Broadcast | + TransactionStatus::Pending | + TransactionStatus::Coinbase | + TransactionStatus::Rejected | + TransactionStatus::Queued | + TransactionStatus::MinedUnconfirmed | + TransactionStatus::MinedConfirmed => TransactionStatus::MinedUnconfirmed, + TransactionStatus::Imported | + TransactionStatus::OneSidedUnconfirmed | + TransactionStatus::OneSidedConfirmed => TransactionStatus::OneSidedUnconfirmed, + TransactionStatus::CoinbaseConfirmed | TransactionStatus::CoinbaseUnconfirmed => { + TransactionStatus::CoinbaseUnconfirmed + }, + } + } } #[derive(Debug, Error)] @@ -68,9 +126,11 @@ impl TryFrom for TransactionStatus { 5 => Ok(TransactionStatus::Coinbase), 6 => Ok(TransactionStatus::MinedConfirmed), 7 => Ok(TransactionStatus::Rejected), - 8 => Ok(TransactionStatus::FauxUnconfirmed), - 9 => Ok(TransactionStatus::FauxConfirmed), + 8 => Ok(TransactionStatus::OneSidedUnconfirmed), + 9 => Ok(TransactionStatus::OneSidedConfirmed), 10 => Ok(TransactionStatus::Queued), + 11 => Ok(TransactionStatus::CoinbaseUnconfirmed), + 12 => Ok(TransactionStatus::CoinbaseConfirmed), code => Err(TransactionConversionError { code }), } } @@ -88,8 +148,10 @@ impl Display for TransactionStatus { TransactionStatus::Pending => write!(f, "Pending"), TransactionStatus::Coinbase => write!(f, "Coinbase"), TransactionStatus::Rejected => write!(f, "Rejected"), - TransactionStatus::FauxUnconfirmed => write!(f, "FauxUnconfirmed"), - TransactionStatus::FauxConfirmed => write!(f, "FauxConfirmed"), + TransactionStatus::OneSidedUnconfirmed => write!(f, "One-Sided Unconfirmed"), + TransactionStatus::OneSidedConfirmed => write!(f, "One-Sided Confirmed"), + TransactionStatus::CoinbaseUnconfirmed => write!(f, "Coinbase Unconfirmed"), + TransactionStatus::CoinbaseConfirmed => write!(f, "Coinbase Confirmed"), TransactionStatus::Queued => write!(f, "Queued"), } } @@ -100,9 +162,13 @@ pub enum ImportStatus { /// This transaction import status is used when importing a spendable UTXO Imported, /// This transaction import status is used when a one-sided transaction has been scanned but is unconfirmed - FauxUnconfirmed, + OneSidedUnconfirmed, + /// This transaction import status is used when a one-sided transaction has been scanned and confirmed + OneSidedConfirmed, + /// This transaction import status is used when a one-sided transaction has been scanned but is unconfirmed + CoinbaseUnconfirmed, /// This transaction import status is used when a one-sided transaction has been scanned and confirmed - FauxConfirmed, + CoinbaseConfirmed, } impl TryFrom for TransactionStatus { @@ -111,8 +177,10 @@ impl TryFrom for TransactionStatus { fn try_from(value: ImportStatus) -> Result { match value { ImportStatus::Imported => Ok(TransactionStatus::Imported), - ImportStatus::FauxUnconfirmed => Ok(TransactionStatus::FauxUnconfirmed), - ImportStatus::FauxConfirmed => Ok(TransactionStatus::FauxConfirmed), + ImportStatus::OneSidedUnconfirmed => Ok(TransactionStatus::OneSidedUnconfirmed), + ImportStatus::OneSidedConfirmed => Ok(TransactionStatus::OneSidedConfirmed), + ImportStatus::CoinbaseUnconfirmed => Ok(TransactionStatus::CoinbaseUnconfirmed), + ImportStatus::CoinbaseConfirmed => Ok(TransactionStatus::CoinbaseConfirmed), } } } @@ -123,8 +191,10 @@ impl TryFrom for ImportStatus { fn try_from(value: TransactionStatus) -> Result { match value { TransactionStatus::Imported => Ok(ImportStatus::Imported), - TransactionStatus::FauxUnconfirmed => Ok(ImportStatus::FauxUnconfirmed), - TransactionStatus::FauxConfirmed => Ok(ImportStatus::FauxConfirmed), + TransactionStatus::OneSidedUnconfirmed => Ok(ImportStatus::OneSidedUnconfirmed), + TransactionStatus::OneSidedConfirmed => Ok(ImportStatus::OneSidedConfirmed), + TransactionStatus::CoinbaseUnconfirmed => Ok(ImportStatus::CoinbaseUnconfirmed), + TransactionStatus::CoinbaseConfirmed => Ok(ImportStatus::CoinbaseConfirmed), _ => Err(TransactionConversionError { code: i32::MAX }), } } @@ -134,8 +204,10 @@ impl fmt::Display for ImportStatus { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> { match self { ImportStatus::Imported => write!(f, "Imported"), - ImportStatus::FauxUnconfirmed => write!(f, "FauxUnconfirmed"), - ImportStatus::FauxConfirmed => write!(f, "FauxConfirmed"), + ImportStatus::OneSidedUnconfirmed => write!(f, "OneSidedUnconfirmed"), + ImportStatus::OneSidedConfirmed => write!(f, "OneSidedConfirmed"), + ImportStatus::CoinbaseUnconfirmed => write!(f, "CoinbaseUnconfirmed"), + ImportStatus::CoinbaseConfirmed => write!(f, "CoinbaseConfirmed"), } } } diff --git a/base_layer/wallet/src/transaction_service/handle.rs b/base_layer/wallet/src/transaction_service/handle.rs index 862580e902..d1f1c8cccc 100644 --- a/base_layer/wallet/src/transaction_service/handle.rs +++ b/base_layer/wallet/src/transaction_service/handle.rs @@ -302,12 +302,12 @@ pub enum TransactionEvent { TransactionCancelled(TxId, TxCancellationReason), TransactionBroadcast(TxId), TransactionImported(TxId), - FauxTransactionUnconfirmed { + DetectedTransactionUnconfirmed { tx_id: TxId, num_confirmations: u64, is_valid: bool, }, - FauxTransactionConfirmed { + DetectedTransactionConfirmed { tx_id: TxId, is_valid: bool, }, @@ -360,19 +360,19 @@ impl fmt::Display for TransactionEvent { TransactionEvent::TransactionImported(tx) => { write!(f, "TransactionImported for {tx}") }, - TransactionEvent::FauxTransactionUnconfirmed { + TransactionEvent::DetectedTransactionUnconfirmed { tx_id, num_confirmations, is_valid, } => { write!( f, - "FauxTransactionUnconfirmed for {tx_id} with num confirmations: {num_confirmations}. is_valid: \ - {is_valid}" + "DetectedTransactionUnconfirmed for {tx_id} with num confirmations: {num_confirmations}. \ + is_valid: {is_valid}" ) }, - TransactionEvent::FauxTransactionConfirmed { tx_id, is_valid } => { - write!(f, "FauxTransactionConfirmed for {tx_id}. is_valid: {is_valid}") + TransactionEvent::DetectedTransactionConfirmed { tx_id, is_valid } => { + write!(f, "DetectedTransactionConfirmed for {tx_id}. is_valid: {is_valid}") }, TransactionEvent::TransactionMined { tx_id, is_valid } => { write!(f, "TransactionMined for {tx_id}. is_valid: {is_valid}") diff --git a/base_layer/wallet/src/transaction_service/protocols/transaction_validation_protocol.rs b/base_layer/wallet/src/transaction_service/protocols/transaction_validation_protocol.rs index f910bd114a..568b745620 100644 --- a/base_layer/wallet/src/transaction_service/protocols/transaction_validation_protocol.rs +++ b/base_layer/wallet/src/transaction_service/protocols/transaction_validation_protocol.rs @@ -371,18 +371,18 @@ where mined_timestamp, num_confirmations, num_confirmations >= self.config.num_confirmations_required, - status.is_faux(), + status, ) .for_protocol(self.operation_id)?; if num_confirmations >= self.config.num_confirmations_required { - if status.is_faux() { - self.publish_event(TransactionEvent::FauxTransactionConfirmed { tx_id, is_valid: true }) + if status.is_coinbase() || status.is_imported_from_chain() { + self.publish_event(TransactionEvent::DetectedTransactionConfirmed { tx_id, is_valid: true }) } else { self.publish_event(TransactionEvent::TransactionMined { tx_id, is_valid: true }) } - } else if status.is_faux() { - self.publish_event(TransactionEvent::FauxTransactionUnconfirmed { + } else if status.is_coinbase() || status.is_imported_from_chain() { + self.publish_event(TransactionEvent::DetectedTransactionUnconfirmed { tx_id, num_confirmations, is_valid: true, diff --git a/base_layer/wallet/src/transaction_service/service.rs b/base_layer/wallet/src/transaction_service/service.rs index 25ea2c3e60..ea231553b5 100644 --- a/base_layer/wallet/src/transaction_service/service.rs +++ b/base_layer/wallet/src/transaction_service/service.rs @@ -117,7 +117,7 @@ use crate::{ models::{CompletedTransaction, TxCancellationReason}, }, tasks::{ - check_faux_transaction_status::check_faux_transactions, + check_faux_transaction_status::check_detected_transactions, send_finalized_transaction::send_finalized_transaction_message, send_transaction_cancelled::send_transaction_cancelled_message, send_transaction_reply::send_transaction_reply, @@ -928,7 +928,7 @@ where None => 0u64, }; let event_publisher = self.event_publisher.clone(); - tokio::spawn(check_faux_transactions( + tokio::spawn(check_detected_transactions( output_manager_handle, db, event_publisher, @@ -2813,12 +2813,16 @@ where )?; let transaction_event = match import_status { ImportStatus::Imported => TransactionEvent::TransactionImported(tx_id), - ImportStatus::FauxUnconfirmed => TransactionEvent::FauxTransactionUnconfirmed { - tx_id, - num_confirmations: 0, - is_valid: true, + ImportStatus::OneSidedUnconfirmed | ImportStatus::CoinbaseUnconfirmed => { + TransactionEvent::DetectedTransactionUnconfirmed { + tx_id, + num_confirmations: 0, + is_valid: true, + } + }, + ImportStatus::OneSidedConfirmed | ImportStatus::CoinbaseConfirmed => { + TransactionEvent::DetectedTransactionConfirmed { tx_id, is_valid: true } }, - ImportStatus::FauxConfirmed => TransactionEvent::FauxTransactionConfirmed { tx_id, is_valid: true }, }; let _size = self.event_publisher.send(Arc::new(transaction_event)).map_err(|e| { trace!( diff --git a/base_layer/wallet/src/transaction_service/storage/database.rs b/base_layer/wallet/src/transaction_service/storage/database.rs index 7e22032e45..e3fa6f6f5b 100644 --- a/base_layer/wallet/src/transaction_service/storage/database.rs +++ b/base_layer/wallet/src/transaction_service/storage/database.rs @@ -131,7 +131,7 @@ pub trait TransactionBackend: Send + Sync + Clone { mined_timestamp: u64, num_confirmations: u64, must_be_confirmed: bool, - is_faux: bool, + status: &TransactionStatus, ) -> Result<(), TransactionStorageError>; /// Clears the mined block and height of a transaction fn set_transaction_as_unmined(&self, tx_id: TxId) -> Result<(), TransactionStorageError>; @@ -142,8 +142,8 @@ pub trait TransactionBackend: Send + Sync + Clone { &self, ) -> Result, TransactionStorageError>; fn fetch_imported_transactions(&self) -> Result, TransactionStorageError>; - fn fetch_unconfirmed_faux_transactions(&self) -> Result, TransactionStorageError>; - fn fetch_confirmed_faux_transactions_from_height( + fn fetch_unconfirmed_detected_transactions(&self) -> Result, TransactionStorageError>; + fn fetch_confirmed_detected_transactions_from_height( &self, height: u64, ) -> Result, TransactionStorageError>; @@ -416,16 +416,16 @@ where T: TransactionBackend + 'static Ok(t) } - pub fn get_unconfirmed_faux_transactions(&self) -> Result, TransactionStorageError> { - let t = self.db.fetch_unconfirmed_faux_transactions()?; + pub fn get_unconfirmed_detected_transactions(&self) -> Result, TransactionStorageError> { + let t = self.db.fetch_unconfirmed_detected_transactions()?; Ok(t) } - pub fn get_confirmed_faux_transactions_from_height( + pub fn get_confirmed_detected_transactions_from_height( &self, height: u64, ) -> Result, TransactionStorageError> { - let t = self.db.fetch_confirmed_faux_transactions_from_height(height)?; + let t = self.db.fetch_confirmed_detected_transactions_from_height(height)?; Ok(t) } @@ -695,7 +695,7 @@ where T: TransactionBackend + 'static mined_timestamp: u64, num_confirmations: u64, must_be_confirmed: bool, - is_faux: bool, + status: &TransactionStatus, ) -> Result<(), TransactionStorageError> { self.db.update_mined_height( tx_id, @@ -704,7 +704,7 @@ where T: TransactionBackend + 'static mined_timestamp, num_confirmations, must_be_confirmed, - is_faux, + status, ) } diff --git a/base_layer/wallet/src/transaction_service/storage/sqlite_db.rs b/base_layer/wallet/src/transaction_service/storage/sqlite_db.rs index d392187c02..bde3455804 100644 --- a/base_layer/wallet/src/transaction_service/storage/sqlite_db.rs +++ b/base_layer/wallet/src/transaction_service/storage/sqlite_db.rs @@ -787,21 +787,15 @@ impl TransactionBackend for TransactionServiceSqliteDatabase { mined_timestamp: u64, num_confirmations: u64, must_be_confirmed: bool, - is_faux: bool, + status: &TransactionStatus, ) -> Result<(), TransactionStorageError> { let start = Instant::now(); let mut conn = self.database_connection.get_pooled_connection()?; let acquire_lock = start.elapsed(); let status = if must_be_confirmed { - if is_faux { - TransactionStatus::FauxConfirmed - } else { - TransactionStatus::MinedConfirmed - } - } else if is_faux { - TransactionStatus::FauxUnconfirmed + status.mined_confirm() } else { - TransactionStatus::MinedUnconfirmed + status.mined_unconfirm() }; match CompletedTransactionSql::update_mined_height( @@ -1013,27 +1007,54 @@ impl TransactionBackend for TransactionServiceSqliteDatabase { .collect::, TransactionStorageError>>() } - fn fetch_unconfirmed_faux_transactions(&self) -> Result, TransactionStorageError> { + fn fetch_unconfirmed_detected_transactions(&self) -> Result, TransactionStorageError> { let mut conn = self.database_connection.get_pooled_connection()?; let cipher = acquire_read_lock!(self.cipher); - CompletedTransactionSql::index_by_status_and_cancelled(TransactionStatus::FauxUnconfirmed, false, &mut conn)? - .into_iter() - .map(|ct: CompletedTransactionSql| { - CompletedTransaction::try_from(ct, &cipher).map_err(TransactionStorageError::from) - }) - .collect::, TransactionStorageError>>() + let mut one_sided = CompletedTransactionSql::index_by_status_and_cancelled( + TransactionStatus::OneSidedUnconfirmed, + false, + &mut conn, + )? + .into_iter() + .map(|ct: CompletedTransactionSql| { + CompletedTransaction::try_from(ct, &cipher).map_err(TransactionStorageError::from) + }) + .collect::, TransactionStorageError>>()?; + let mut coinbases = CompletedTransactionSql::index_by_status_and_cancelled( + TransactionStatus::CoinbaseUnconfirmed, + false, + &mut conn, + )? + .into_iter() + .map(|ct: CompletedTransactionSql| { + CompletedTransaction::try_from(ct, &cipher).map_err(TransactionStorageError::from) + }) + .collect::, TransactionStorageError>>()?; + coinbases.append(&mut one_sided); + Ok(coinbases) } - fn fetch_confirmed_faux_transactions_from_height( + fn fetch_confirmed_detected_transactions_from_height( &self, height: u64, ) -> Result, TransactionStorageError> { let mut conn = self.database_connection.get_pooled_connection()?; let cipher = acquire_read_lock!(self.cipher); - CompletedTransactionSql::index_by_status_and_cancelled_from_block_height( - TransactionStatus::FauxConfirmed, + let mut one_sided = CompletedTransactionSql::index_by_status_and_cancelled_from_block_height( + TransactionStatus::OneSidedConfirmed, + false, + height as i64, + &mut conn, + )? + .into_iter() + .map(|ct: CompletedTransactionSql| { + CompletedTransaction::try_from(ct, &cipher).map_err(TransactionStorageError::from) + }) + .collect::, TransactionStorageError>>()?; + let mut coinbases = CompletedTransactionSql::index_by_status_and_cancelled_from_block_height( + TransactionStatus::CoinbaseConfirmed, false, height as i64, &mut conn, @@ -1042,7 +1063,9 @@ impl TransactionBackend for TransactionServiceSqliteDatabase { .map(|ct: CompletedTransactionSql| { CompletedTransaction::try_from(ct, &cipher).map_err(TransactionStorageError::from) }) - .collect::, TransactionStorageError>>() + .collect::, TransactionStorageError>>()?; + coinbases.append(&mut one_sided); + Ok(coinbases) } } @@ -1836,10 +1859,14 @@ impl CompletedTransactionSql { .load::(conn)? .first() { - if *status == TransactionStatus::FauxConfirmed as i32 || - *status == TransactionStatus::FauxUnconfirmed as i32 + if *status == TransactionStatus::OneSidedConfirmed as i32 || + *status == TransactionStatus::OneSidedUnconfirmed as i32 + { + Some(TransactionStatus::OneSidedUnconfirmed as i32) + } else if *status == TransactionStatus::CoinbaseUnconfirmed as i32 || + *status == TransactionStatus::CoinbaseConfirmed as i32 { - Some(TransactionStatus::FauxUnconfirmed as i32) + Some(TransactionStatus::CoinbaseUnconfirmed as i32) } else if *status == TransactionStatus::Imported as i32 { Some(TransactionStatus::Imported as i32) } else if *status == TransactionStatus::Broadcast as i32 { @@ -2078,8 +2105,10 @@ impl UnconfirmedTransactionInfoSql { completed_transactions::status // Filter out imported or scanned transactions .ne(TransactionStatus::Imported as i32) - .and(completed_transactions::status.ne(TransactionStatus::FauxUnconfirmed as i32)) - .and(completed_transactions::status.ne(TransactionStatus::FauxConfirmed as i32)) + .and(completed_transactions::status.ne(TransactionStatus::OneSidedUnconfirmed as i32)) + .and(completed_transactions::status.ne(TransactionStatus::OneSidedConfirmed as i32)) + .and(completed_transactions::status.ne(TransactionStatus::CoinbaseUnconfirmed as i32)) + .and(completed_transactions::status.ne(TransactionStatus::CoinbaseConfirmed as i32)) // Filter out any transaction without a kernel signature .and(completed_transactions::transaction_signature_nonce.ne(vec![0u8; 32])) .and(completed_transactions::transaction_signature_key.ne(vec![0u8; 32])) diff --git a/base_layer/wallet/src/transaction_service/tasks/check_faux_transaction_status.rs b/base_layer/wallet/src/transaction_service/tasks/check_faux_transaction_status.rs index 75156e173d..6182d78193 100644 --- a/base_layer/wallet/src/transaction_service/tasks/check_faux_transaction_status.rs +++ b/base_layer/wallet/src/transaction_service/tasks/check_faux_transaction_status.rs @@ -23,10 +23,7 @@ use std::sync::Arc; use log::*; -use tari_common_types::{ - transaction::TransactionStatus, - types::{BlockHash, FixedHash}, -}; +use tari_common_types::types::{BlockHash, FixedHash}; use crate::{ output_manager_service::handle::OutputManagerHandle, @@ -43,30 +40,30 @@ use crate::{ const LOG_TARGET: &str = "wallet::transaction_service::service"; #[allow(clippy::too_many_lines)] -pub async fn check_faux_transactions( +pub async fn check_detected_transactions( mut output_manager: OutputManagerHandle, db: TransactionDatabase, event_publisher: TransactionEventSender, tip_height: u64, ) { - let mut all_faux_transactions: Vec = match db.get_imported_transactions() { + let mut all_detected_transactions: Vec = match db.get_imported_transactions() { Ok(txs) => txs, Err(e) => { error!(target: LOG_TARGET, "Problem retrieving imported transactions: {}", e); return; }, }; - let mut unconfirmed_faux = match db.get_unconfirmed_faux_transactions() { + let mut unconfirmed_detected = match db.get_unconfirmed_detected_transactions() { Ok(txs) => txs, Err(e) => { error!( target: LOG_TARGET, - "Problem retrieving unconfirmed faux transactions: {}", e + "Problem retrieving unconfirmed detected transactions: {}", e ); return; }, }; - all_faux_transactions.append(&mut unconfirmed_faux); + all_detected_transactions.append(&mut unconfirmed_detected); // Reorged faux transactions cannot be detected by excess signature, thus use last known confirmed transaction // height or current tip height with safety margin to determine if these should be returned let last_mined_transaction = match db.fetch_last_mined_transaction() { @@ -79,24 +76,24 @@ pub async fn check_faux_transactions( } else { height_with_margin }; - let mut confirmed_faux = match db.get_confirmed_faux_transactions_from_height(check_height) { + let mut confirmed_dectected = match db.get_confirmed_detected_transactions_from_height(check_height) { Ok(txs) => txs, Err(e) => { error!( target: LOG_TARGET, - "Problem retrieving confirmed faux transactions: {}", e + "Problem retrieving confirmed detected transactions: {}", e ); return; }, }; - all_faux_transactions.append(&mut confirmed_faux); + all_detected_transactions.append(&mut confirmed_dectected); debug!( target: LOG_TARGET, - "Checking {} faux transaction statuses", - all_faux_transactions.len() + "Checking {} detected transaction statuses", + all_detected_transactions.len() ); - for tx in all_faux_transactions { + for tx in all_detected_transactions { let output_info_for_tx_id = match output_manager.get_output_info_for_tx_id(tx.tx_id).await { Ok(s) => s, Err(e) => { @@ -116,7 +113,7 @@ pub async fn check_faux_transactions( FixedHash::zero() }; let is_valid = tip_height >= mined_height; - let previously_confirmed = tx.status == TransactionStatus::FauxConfirmed; + let previously_confirmed = tx.status.is_confirmed(); let must_be_confirmed = tip_height.saturating_sub(mined_height) >= TransactionServiceConfig::default().num_confirmations_required; let num_confirmations = tip_height - mined_height; @@ -139,7 +136,7 @@ pub async fn check_faux_transactions( .map_or(0, |mined_timestamp| mined_timestamp.timestamp() as u64), num_confirmations, must_be_confirmed, - true, + &tx.status, ); if let Err(e) = result { error!( @@ -151,12 +148,12 @@ pub async fn check_faux_transactions( // now not confirmed (i.e. confirmation changed) if !(previously_confirmed && must_be_confirmed) { let transaction_event = if must_be_confirmed { - TransactionEvent::FauxTransactionConfirmed { + TransactionEvent::DetectedTransactionConfirmed { tx_id: tx.tx_id, is_valid, } } else { - TransactionEvent::FauxTransactionUnconfirmed { + TransactionEvent::DetectedTransactionUnconfirmed { tx_id: tx.tx_id, num_confirmations: 0, is_valid, diff --git a/base_layer/wallet/src/utxo_scanner_service/utxo_scanner_task.rs b/base_layer/wallet/src/utxo_scanner_service/utxo_scanner_task.rs index d3d5d7557e..550c3d0e66 100644 --- a/base_layer/wallet/src/utxo_scanner_service/utxo_scanner_task.rs +++ b/base_layer/wallet/src/utxo_scanner_service/utxo_scanner_task.rs @@ -485,7 +485,7 @@ where total_scanned += outputs.len(); let start = Instant::now(); - let found_outputs = self.scan_for_outputs(outputs).await?; + let found_outputs = self.scan_for_outputs(outputs, current_height).await?; scan_for_outputs_profiling.push(start.elapsed()); let (mut count, mut amount) = self @@ -553,6 +553,7 @@ where async fn scan_for_outputs( &mut self, outputs: Vec, + height: u64, ) -> Result, UtxoScannerError> { let mut found_outputs: Vec<(WalletOutput, String, ImportStatus, TxId, TransactionOutput)> = Vec::new(); found_outputs.append( @@ -563,15 +564,18 @@ where .await? .into_iter() .map(|ro| -> Result<_, UtxoScannerError> { - let message = if ro.output.features.is_coinbase() { - "**COINBASE** ".to_owned() + &self.resources.recovery_message + let (message, status) = if ro.output.features.is_coinbase() { + ( + format!("Coinbase for height: {}", height), + ImportStatus::CoinbaseUnconfirmed, + ) } else { - self.resources.recovery_message.clone() + (self.resources.recovery_message.clone(), ImportStatus::Imported) }; let output = outputs.iter().find(|o| o.hash() == ro.hash).ok_or_else(|| { UtxoScannerError::UtxoScanningError(format!("Output '{}' not found", ro.hash.to_hex())) })?; - Ok((ro.output, message, ImportStatus::Imported, ro.tx_id, output.clone())) + Ok((ro.output, message, status, ro.tx_id, output.clone())) }) .collect::, _>>()?, ); @@ -584,21 +588,21 @@ where .await? .into_iter() .map(|ro| -> Result<_, UtxoScannerError> { - let message = if ro.output.features.is_coinbase() { - "**COINBASE** ".to_owned() + &self.resources.one_sided_payment_message + let (message, status) = if ro.output.features.is_coinbase() { + ( + format!("Coinbase for height: {}", height), + ImportStatus::CoinbaseUnconfirmed, + ) } else { - self.resources.one_sided_payment_message.clone() + ( + self.resources.recovery_message.clone(), + ImportStatus::OneSidedUnconfirmed, + ) }; let output = outputs.iter().find(|o| o.hash() == ro.hash).ok_or_else(|| { UtxoScannerError::UtxoScanningError(format!("Output '{}' not found", ro.hash.to_hex())) })?; - Ok(( - ro.output, - message, - ImportStatus::FauxUnconfirmed, - ro.tx_id, - output.clone(), - )) + Ok((ro.output, message, status, ro.tx_id, output.clone())) }) .collect::, _>>()?, ); diff --git a/base_layer/wallet/tests/transaction_service_tests/service.rs b/base_layer/wallet/tests/transaction_service_tests/service.rs index 17b58c1218..63983ec4c0 100644 --- a/base_layer/wallet/tests/transaction_service_tests/service.rs +++ b/base_layer/wallet/tests/transaction_service_tests/service.rs @@ -5200,7 +5200,7 @@ async fn test_update_faux_tx_on_oms_validation() { MicroMinotari::from(20000), alice_address.clone(), "one-sided 1".to_string(), - ImportStatus::FauxUnconfirmed, + ImportStatus::OneSidedUnconfirmed, None, None, None, @@ -5216,7 +5216,7 @@ async fn test_update_faux_tx_on_oms_validation() { MicroMinotari::from(30000), alice_address, "one-sided 2".to_string(), - ImportStatus::FauxConfirmed, + ImportStatus::OneSidedConfirmed, None, None, None, @@ -5251,14 +5251,14 @@ async fn test_update_faux_tx_on_oms_validation() { } if tx_id == tx_id_2 { if let WalletTransaction::Completed(tx) = &transaction { - assert_eq!(tx.status, TransactionStatus::FauxUnconfirmed); + assert_eq!(tx.status, TransactionStatus::OneSidedUnconfirmed); } else { panic!("Should find a complete FauxUnconfirmed transaction"); } } if tx_id == tx_id_3 { if let WalletTransaction::Completed(tx) = &transaction { - assert_eq!(tx.status, TransactionStatus::FauxConfirmed); + assert_eq!(tx.status, TransactionStatus::OneSidedConfirmed); } else { panic!("Should find a complete FauxConfirmed transaction"); } @@ -5284,13 +5284,13 @@ async fn test_update_faux_tx_on_oms_validation() { .unwrap() .unwrap(); if let WalletTransaction::Completed(tx) = transaction { - if tx_id == tx_id_1 && tx.status == TransactionStatus::FauxUnconfirmed && !found_imported { + if tx_id == tx_id_1 && tx.status == TransactionStatus::OneSidedUnconfirmed && !found_imported { found_imported = true; } - if tx_id == tx_id_2 && tx.status == TransactionStatus::FauxUnconfirmed && !found_faux_unconfirmed { + if tx_id == tx_id_2 && tx.status == TransactionStatus::OneSidedUnconfirmed && !found_faux_unconfirmed { found_faux_unconfirmed = true; } - if tx_id == tx_id_3 && tx.status == TransactionStatus::FauxConfirmed && !found_faux_confirmed { + if tx_id == tx_id_3 && tx.status == TransactionStatus::OneSidedConfirmed && !found_faux_confirmed { found_faux_confirmed = true; } } diff --git a/base_layer/wallet/tests/transaction_service_tests/storage.rs b/base_layer/wallet/tests/transaction_service_tests/storage.rs index b84475d8ee..aa92522581 100644 --- a/base_layer/wallet/tests/transaction_service_tests/storage.rs +++ b/base_layer/wallet/tests/transaction_service_tests/storage.rs @@ -367,8 +367,16 @@ pub async fn test_db_backend(backend: T) { assert!(db.fetch_last_mined_transaction().unwrap().is_none()); - db.set_transaction_mined_height(completed_txs[0].tx_id, 10, FixedHash::zero(), 0, 5, true, false) - .unwrap(); + db.set_transaction_mined_height( + completed_txs[0].tx_id, + 10, + FixedHash::zero(), + 0, + 5, + true, + &completed_txs[0].status, + ) + .unwrap(); assert_eq!( db.fetch_last_mined_transaction().unwrap().unwrap().tx_id, @@ -594,7 +602,7 @@ async fn import_tx_and_read_it_from_db() { PrivateKey::random(&mut OsRng), PrivateKey::random(&mut OsRng), ), - TransactionStatus::FauxUnconfirmed, + TransactionStatus::OneSidedUnconfirmed, "message".to_string(), Utc::now().naive_utc(), TransactionDirection::Inbound, @@ -623,7 +631,7 @@ async fn import_tx_and_read_it_from_db() { PrivateKey::random(&mut OsRng), PrivateKey::random(&mut OsRng), ), - TransactionStatus::FauxConfirmed, + TransactionStatus::OneSidedConfirmed, "message".to_string(), Utc::now().naive_utc(), TransactionDirection::Inbound, @@ -644,14 +652,14 @@ async fn import_tx_and_read_it_from_db() { assert_eq!(db_tx.first().unwrap().tx_id, TxId::from(1u64)); assert_eq!(db_tx.first().unwrap().mined_height, Some(5)); - let db_tx = sqlite_db.fetch_unconfirmed_faux_transactions().unwrap(); + let db_tx = sqlite_db.fetch_unconfirmed_detected_transactions().unwrap(); assert_eq!(db_tx.len(), 1); assert_eq!(db_tx.first().unwrap().tx_id, TxId::from(2u64)); assert_eq!(db_tx.first().unwrap().mined_height, Some(6)); - let db_tx = sqlite_db.fetch_confirmed_faux_transactions_from_height(10).unwrap(); + let db_tx = sqlite_db.fetch_confirmed_detected_transactions_from_height(10).unwrap(); assert_eq!(db_tx.len(), 0); - let db_tx = sqlite_db.fetch_confirmed_faux_transactions_from_height(4).unwrap(); + let db_tx = sqlite_db.fetch_confirmed_detected_transactions_from_height(4).unwrap(); assert_eq!(db_tx.len(), 1); assert_eq!(db_tx.first().unwrap().tx_id, TxId::from(3u64)); assert_eq!(db_tx.first().unwrap().mined_height, Some(7)); diff --git a/base_layer/wallet/tests/utxo_scanner/mod.rs b/base_layer/wallet/tests/utxo_scanner/mod.rs index a7b79a6951..414a94335e 100644 --- a/base_layer/wallet/tests/utxo_scanner/mod.rs +++ b/base_layer/wallet/tests/utxo_scanner/mod.rs @@ -957,7 +957,7 @@ async fn test_utxo_scanner_one_sided_payments() { scanned_output: _, } = req { - assert_eq!(message, "one-sided non-default".to_string()); + assert_eq!(message, "Output found on blockchain during Wallet Recovery".to_string()); } } @@ -1056,7 +1056,7 @@ async fn test_utxo_scanner_one_sided_payments() { } = req { println!("{:?}", h); - assert_eq!(message, "new one-sided message".to_string()); + assert_eq!(message, "Output found on blockchain during Wallet Recovery".to_string()); } } } diff --git a/base_layer/wallet_ffi/src/callback_handler.rs b/base_layer/wallet_ffi/src/callback_handler.rs index 8a972b8ad6..e6a170bcf1 100644 --- a/base_layer/wallet_ffi/src/callback_handler.rs +++ b/base_layer/wallet_ffi/src/callback_handler.rs @@ -277,11 +277,11 @@ where TBackend: TransactionBackend + 'static self.receive_transaction_mined_unconfirmed_event(tx_id, num_confirmations); self.trigger_balance_refresh().await; }, - TransactionEvent::FauxTransactionConfirmed{tx_id, is_valid: _} => { + TransactionEvent::DetectedTransactionConfirmed{tx_id, is_valid: _} => { self.receive_faux_transaction_confirmed_event(tx_id); self.trigger_balance_refresh().await; }, - TransactionEvent::FauxTransactionUnconfirmed{tx_id, num_confirmations, is_valid: _} => { + TransactionEvent::DetectedTransactionUnconfirmed{tx_id, num_confirmations, is_valid: _} => { self.receive_faux_transaction_unconfirmed_event(tx_id, num_confirmations); self.trigger_balance_refresh().await; }, diff --git a/base_layer/wallet_ffi/src/callback_handler_tests.rs b/base_layer/wallet_ffi/src/callback_handler_tests.rs index 5f51103dce..184fe38b08 100644 --- a/base_layer/wallet_ffi/src/callback_handler_tests.rs +++ b/base_layer/wallet_ffi/src/callback_handler_tests.rs @@ -384,7 +384,7 @@ mod test { PrivateKey::default(), PrivateKey::default(), ), - TransactionStatus::FauxUnconfirmed, + TransactionStatus::OneSidedUnconfirmed, "6".to_string(), Utc::now().naive_utc(), TransactionDirection::Inbound, @@ -416,7 +416,7 @@ mod test { PrivateKey::default(), PrivateKey::default(), ), - TransactionStatus::FauxConfirmed, + TransactionStatus::OneSidedConfirmed, "7".to_string(), Utc::now().naive_utc(), TransactionDirection::Inbound, @@ -748,7 +748,7 @@ mod test { mock_output_manager_service_state.set_balance(balance.clone()); // Balance updated should be detected with following event, total = 6 times transaction_event_sender - .send(Arc::new(TransactionEvent::FauxTransactionUnconfirmed { + .send(Arc::new(TransactionEvent::DetectedTransactionUnconfirmed { tx_id: 6u64.into(), num_confirmations: 2, is_valid: true, @@ -771,7 +771,7 @@ mod test { mock_output_manager_service_state.set_balance(balance.clone()); // Balance updated should be detected with following event, total = 7 times transaction_event_sender - .send(Arc::new(TransactionEvent::FauxTransactionConfirmed { + .send(Arc::new(TransactionEvent::DetectedTransactionConfirmed { tx_id: 7u64.into(), is_valid: true, })) diff --git a/base_layer/wallet_ffi/src/lib.rs b/base_layer/wallet_ffi/src/lib.rs index 95608462ce..8b3dc14e86 100644 --- a/base_layer/wallet_ffi/src/lib.rs +++ b/base_layer/wallet_ffi/src/lib.rs @@ -8737,7 +8737,7 @@ mod test { type_of((*tx).clone()), std::any::type_name::() ); - assert_eq!((*tx).status, TransactionStatus::FauxConfirmed); + assert_eq!((*tx).status, TransactionStatus::OneSidedConfirmed); let mut lock = CALLBACK_STATE_FFI.lock().unwrap(); lock.scanned_tx_callback_called = true; drop(lock); @@ -8750,7 +8750,7 @@ mod test { type_of((*tx).clone()), std::any::type_name::() ); - assert_eq!((*tx).status, TransactionStatus::FauxUnconfirmed); + assert_eq!((*tx).status, TransactionStatus::OneSidedUnconfirmed); let mut lock = CALLBACK_STATE_FFI.lock().unwrap(); lock.scanned_tx_unconfirmed_callback_called = true; let mut error = 0; diff --git a/integration_tests/tests/steps/wallet_steps.rs b/integration_tests/tests/steps/wallet_steps.rs index b60642d3d6..5c4f3d37d1 100644 --- a/integration_tests/tests/steps/wallet_steps.rs +++ b/integration_tests/tests/steps/wallet_steps.rs @@ -190,8 +190,8 @@ async fn wallet_detects_all_txs_as_mined_confirmed(world: &mut TariWorld, wallet grpc::TransactionStatus::Broadcast | grpc::TransactionStatus::MinedUnconfirmed | grpc::TransactionStatus::MinedConfirmed | - grpc::TransactionStatus::FauxUnconfirmed | - grpc::TransactionStatus::FauxConfirmed => { + grpc::TransactionStatus::OneSidedUnconfirmed | + grpc::TransactionStatus::OneSidedConfirmed => { break; }, _ => (), @@ -201,8 +201,8 @@ async fn wallet_detects_all_txs_as_mined_confirmed(world: &mut TariWorld, wallet grpc::TransactionStatus::Broadcast | grpc::TransactionStatus::MinedUnconfirmed | grpc::TransactionStatus::MinedConfirmed | - grpc::TransactionStatus::FauxUnconfirmed | - grpc::TransactionStatus::FauxConfirmed => { + grpc::TransactionStatus::OneSidedUnconfirmed | + grpc::TransactionStatus::OneSidedConfirmed => { break; }, _ => (), @@ -211,8 +211,8 @@ async fn wallet_detects_all_txs_as_mined_confirmed(world: &mut TariWorld, wallet grpc::TransactionStatus::Broadcast | grpc::TransactionStatus::MinedUnconfirmed | grpc::TransactionStatus::MinedConfirmed | - grpc::TransactionStatus::FauxUnconfirmed | - grpc::TransactionStatus::FauxConfirmed => { + grpc::TransactionStatus::OneSidedUnconfirmed | + grpc::TransactionStatus::OneSidedConfirmed => { break; }, _ => (), @@ -220,14 +220,14 @@ async fn wallet_detects_all_txs_as_mined_confirmed(world: &mut TariWorld, wallet "Mined_or_Faux_Unconfirmed" => match tx_info.status() { grpc::TransactionStatus::MinedUnconfirmed | grpc::TransactionStatus::MinedConfirmed | - grpc::TransactionStatus::FauxUnconfirmed | - grpc::TransactionStatus::FauxConfirmed => { + grpc::TransactionStatus::OneSidedUnconfirmed | + grpc::TransactionStatus::OneSidedConfirmed => { break; }, _ => (), }, "Mined_or_Faux_Confirmed" => match tx_info.status() { - grpc::TransactionStatus::MinedConfirmed | grpc::TransactionStatus::FauxConfirmed => { + grpc::TransactionStatus::MinedConfirmed | grpc::TransactionStatus::OneSidedConfirmed => { break; }, _ => (), @@ -294,8 +294,8 @@ async fn wallet_detects_all_txs_are_at_least_in_some_status( grpc::TransactionStatus::Broadcast | grpc::TransactionStatus::MinedUnconfirmed | grpc::TransactionStatus::MinedConfirmed | - grpc::TransactionStatus::FauxUnconfirmed | - grpc::TransactionStatus::FauxConfirmed => { + grpc::TransactionStatus::OneSidedUnconfirmed | + grpc::TransactionStatus::OneSidedConfirmed => { break; }, _ => (), @@ -305,8 +305,8 @@ async fn wallet_detects_all_txs_are_at_least_in_some_status( grpc::TransactionStatus::Broadcast | grpc::TransactionStatus::MinedUnconfirmed | grpc::TransactionStatus::MinedConfirmed | - grpc::TransactionStatus::FauxUnconfirmed | - grpc::TransactionStatus::FauxConfirmed => { + grpc::TransactionStatus::OneSidedUnconfirmed | + grpc::TransactionStatus::OneSidedConfirmed => { break; }, _ => (), @@ -315,8 +315,8 @@ async fn wallet_detects_all_txs_are_at_least_in_some_status( grpc::TransactionStatus::Broadcast | grpc::TransactionStatus::MinedUnconfirmed | grpc::TransactionStatus::MinedConfirmed | - grpc::TransactionStatus::FauxUnconfirmed | - grpc::TransactionStatus::FauxConfirmed => { + grpc::TransactionStatus::OneSidedUnconfirmed | + grpc::TransactionStatus::OneSidedConfirmed => { break; }, _ => (), @@ -324,8 +324,8 @@ async fn wallet_detects_all_txs_are_at_least_in_some_status( "Mined_or_Faux_Unconfirmed" => match tx_info.status() { grpc::TransactionStatus::MinedUnconfirmed | grpc::TransactionStatus::MinedConfirmed | - grpc::TransactionStatus::FauxUnconfirmed | - grpc::TransactionStatus::FauxConfirmed => { + grpc::TransactionStatus::OneSidedUnconfirmed | + grpc::TransactionStatus::OneSidedConfirmed => { break; }, _ => (), @@ -2707,7 +2707,7 @@ async fn check_if_last_imported_txs_are_valid_in_wallet(world: &mut TariWorld, w let tx_info = tx.unwrap().transaction.unwrap(); for &tx_id in &world.last_imported_tx_ids { if tx_id == tx_info.tx_id { - assert_eq!(tx_info.status(), grpc::TransactionStatus::FauxConfirmed); + assert_eq!(tx_info.status(), grpc::TransactionStatus::OneSidedConfirmed); imported_cnt += 1; } }