Merge branch 'development' into feat/http_download_seed_peers

Author: MCozhusheck

Cargo.lock

@@ -22,17 +22,17 @@
 
 use std::convert::{TryFrom, TryInto};
 
-use tari_core::{blocks::HistoricalBlock, chain_storage::ChainStorageError};
+use tari_node_components::blocks::{BlockError, HistoricalBlock};
 
 use crate::tari_rpc as grpc;
 
 impl TryFrom<HistoricalBlock> for grpc::HistoricalBlock {
-    type Error = ChainStorageError;
+    type Error = BlockError;
 
     fn try_from(hb: HistoricalBlock) -> Result<Self, Self::Error> {
         Ok(Self {
             confirmations: hb.confirmations(),
-            block: Some(hb.into_block().try_into().map_err(ChainStorageError::ConversionError)?),
+            block: Some(hb.into_block().try_into().map_err(|_| BlockError::ConversionError)?),
         })
     }
 }

applications/minotari_app_grpc/src/conversions/historical_block.rs

@@ -29,7 +29,6 @@ pub mod chain_metadata;
 pub mod com_and_pub_signature;
 pub mod commitment_signature;
 pub mod consensus_constants;
-#[cfg(feature = "base_node")]
 pub mod historical_block;
 pub mod new_block_template;
 pub mod output_features;

applications/minotari_app_grpc/src/conversions/mod.rs

@@ -25,7 +25,7 @@ use std::{
     sync::Arc,
 };
 
-use tari_common_types::transaction::{TransactionDirection, TransactionStatus, TxId};
+use tari_common_types::transaction::{LegacyTransactionStatus, TransactionDirection, TransactionStatus, TxId};
 use tari_crypto::ristretto::RistrettoSecretKey;
 use tari_transaction_components::transaction_components::Transaction;
 use tari_utilities::ByteArray;
@@ -87,10 +87,10 @@ impl From<TransactionDirection> for grpc::TransactionDirection {
     }
 }
 
-impl From<TransactionStatus> for grpc::TransactionStatus {
-    fn from(status: TransactionStatus) -> Self {
+impl From<LegacyTransactionStatus> for grpc::TransactionStatus {
+    fn from(status: LegacyTransactionStatus) -> Self {
         #[allow(clippy::enum_glob_use)]
-        use TransactionStatus::*;
+        use LegacyTransactionStatus::*;
         match status {
             Completed => grpc::TransactionStatus::Completed,
             Broadcast => grpc::TransactionStatus::Broadcast,
@@ -110,6 +110,20 @@ impl From<TransactionStatus> for grpc::TransactionStatus {
     }
 }
 
+impl From<TransactionStatus> for grpc::TransactionStatus {
+    fn from(status: TransactionStatus) -> Self {
+        #[allow(clippy::enum_glob_use)]
+        use TransactionStatus::*;
+        match status {
+            Completed => grpc::TransactionStatus::Completed,
+            Broadcast => grpc::TransactionStatus::Broadcast,
+            MinedUnconfirmed => grpc::TransactionStatus::MinedUnconfirmed,
+            MinedConfirmed => grpc::TransactionStatus::MinedConfirmed,
+            Rejected => grpc::TransactionStatus::Rejected,
+        }
+    }
+}
+
 impl grpc::TransactionInfo {
     pub fn not_found(tx_id: TxId) -> Self {
         Self {

applications/minotari_app_grpc/src/conversions/transaction.rs

@@ -9,7 +9,7 @@ use log::*;
 use minotari_wallet::transaction_service::storage::models::TxCancellationReason;
 use tari_common_types::{
     tari_address::TariAddress,
-    transaction::{TransactionDirection, TransactionStatus},
+    transaction::{LegacyTransactionStatus, TransactionDirection},
 };
 use tari_transaction_components::transaction_components::memo_field::TxType;
 use tokio::runtime::Handle;
@@ -223,8 +223,12 @@ impl TransactionsTab {
             let mut transaction_type = if tx.burn { TxType::Burn } else { TxType::PaymentToOther };
             if let Some(tx_type) = tx.payment_id.as_ref().and_then(|p| p.get_tx_type()) {
                 match tx.status {
-                    TransactionStatus::OneSidedUnconfirmed => transaction_status = TransactionStatus::MinedUnconfirmed,
-                    TransactionStatus::OneSidedConfirmed => transaction_status = TransactionStatus::MinedConfirmed,
+                    LegacyTransactionStatus::OneSidedUnconfirmed => {
+                        transaction_status = LegacyTransactionStatus::MinedUnconfirmed
+                    },
+                    LegacyTransactionStatus::OneSidedConfirmed => {
+                        transaction_status = LegacyTransactionStatus::MinedConfirmed
+                    },
                     _ => {},
                 }
                 transaction_type = tx_type;
@@ -393,8 +397,8 @@ impl TransactionsTab {
             let (status, direction, amount, fee, weight, inputs_count, outputs_count, payment_id, source, destination) =
                 if let Some(fee) = tx.payment_id.as_ref().and_then(|p| p.get_fee()) {
                     let status = match tx.status {
-                        TransactionStatus::OneSidedUnconfirmed => TransactionStatus::MinedUnconfirmed,
-                        TransactionStatus::OneSidedConfirmed => TransactionStatus::MinedConfirmed,
+                        LegacyTransactionStatus::OneSidedUnconfirmed => LegacyTransactionStatus::MinedUnconfirmed,
+                        LegacyTransactionStatus::OneSidedConfirmed => LegacyTransactionStatus::MinedConfirmed,
                         _ => tx.status,
                     };
 
@@ -426,13 +430,13 @@ impl TransactionsTab {
                 };
 
             let source_address =
-                if tx.status == TransactionStatus::Pending && direction == TransactionDirection::Outbound {
+                if tx.status == LegacyTransactionStatus::Pending && direction == TransactionDirection::Outbound {
                     Span::raw("")
                 } else {
                     Span::styled(format!("{source}"), Style::default().fg(Color::White))
                 };
             let destination_address =
-                if tx.status == TransactionStatus::Pending && direction == TransactionDirection::Inbound {
+                if tx.status == LegacyTransactionStatus::Pending && direction == TransactionDirection::Inbound {
                     Span::raw("")
                 } else {
                     Span::styled(format!("{destination}"), Style::default().fg(Color::White))
@@ -482,15 +486,15 @@ impl TransactionsTab {
             );
 
             let confirmation_count = app_state.get_confirmations(tx.tx_id);
-            let confirmations_msg = if (tx.status == TransactionStatus::MinedConfirmed ||
-                tx.status == TransactionStatus::OneSidedConfirmed ||
-                tx.status == TransactionStatus::CoinbaseConfirmed) &&
+            let confirmations_msg = if (tx.status == LegacyTransactionStatus::MinedConfirmed ||
+                tx.status == LegacyTransactionStatus::OneSidedConfirmed ||
+                tx.status == LegacyTransactionStatus::CoinbaseConfirmed) &&
                 tx.cancelled.is_none()
             {
                 format!("{required_confirmations} required confirmations met")
-            } else if (tx.status == TransactionStatus::MinedUnconfirmed ||
-                tx.status == TransactionStatus::OneSidedUnconfirmed ||
-                tx.status == TransactionStatus::CoinbaseUnconfirmed) &&
+            } else if (tx.status == LegacyTransactionStatus::MinedUnconfirmed ||
+                tx.status == LegacyTransactionStatus::OneSidedUnconfirmed ||
+                tx.status == LegacyTransactionStatus::CoinbaseUnconfirmed) &&
                 tx.cancelled.is_none()
             {
                 if let Some(count) = confirmation_count {

applications/minotari_console_wallet/src/ui/components/transactions_tab.rs

@@ -48,7 +48,7 @@ use tari_common::configuration::Network;
 use tari_common_types::{
     payment_reference::generate_payment_reference,
     tari_address::TariAddress,
-    transaction::{TransactionDirection, TransactionStatus, TxId},
+    transaction::{LegacyTransactionStatus, TransactionDirection, TxId},
     types::{CompressedPublicKey, PrivateKey},
     wallet_types::WalletType,
 };
@@ -399,7 +399,7 @@ impl AppState {
             self.cached_data
                 .completed_txs
                 .iter()
-                .filter(|tx| !matches!(tx.status, TransactionStatus::CoinbaseNotInBlockChain))
+                .filter(|tx| !matches!(tx.status, LegacyTransactionStatus::CoinbaseNotInBlockChain))
                 .collect()
         } else {
             self.cached_data.completed_txs.iter().collect()
@@ -733,14 +733,14 @@ impl AppStateInner {
                 )
                 .map_err(|e| UiError::TransactionError(e.to_string()))?;
                 if let Some(index) = self.data.pending_txs.iter().position(|i| i.tx_id == tx_id) {
-                    if tx.status == TransactionStatus::Pending && tx.cancelled.is_none() {
+                    if tx.status == LegacyTransactionStatus::Pending && tx.cancelled.is_none() {
                         self.data.pending_txs[index] = tx;
                         self.updated = true;
                         return Ok(());
                     } else {
                         let _completed_transaction_info = self.data.pending_txs.remove(index);
                     }
-                } else if tx.status == TransactionStatus::Pending && tx.cancelled.is_none() {
+                } else if tx.status == LegacyTransactionStatus::Pending && tx.cancelled.is_none() {
                     self.data.pending_txs.push(tx);
                     self.data.pending_txs.sort_by(|a, b| {
                         b.timestamp
@@ -881,7 +881,7 @@ pub struct CompletedTransactionInfo {
     pub fee: MicroMinotari,
     pub excess_signature: String,
     pub maturity: u64,
-    pub status: TransactionStatus,
+    pub status: LegacyTransactionStatus,
     pub timestamp: NaiveDateTime,
     pub mined_timestamp: Option<NaiveDateTime>,
     pub cancelled: Option<TxCancellationReason>,

applications/minotari_console_wallet/src/ui/state/app_state.rs

@@ -78,11 +78,11 @@ use tari_comms::{
 use tari_comms_dht::{DhtDiscoveryRequester, MetricsCollectorHandle};
 use tari_core::{
     base_node::{state_machine_service::states::StatusInfo, LocalNodeCommsInterface},
-    blocks::ChainHeader,
     chain_storage::{async_db::AsyncBlockchainDb, LMDBDatabase},
     consensus::BaseNodeConsensusManager,
     mempool::service::LocalMempoolService,
 };
+use tari_node_components::blocks::ChainHeader;
 use tari_p2p::{auto_update::SoftwareUpdaterHandle, services::liveness::LivenessHandle};
 use tari_shutdown::Shutdown;
 use tokio::{sync::watch, time};

applications/minotari_node/src/commands/command/mod.rs

@@ -22,7 +22,8 @@
 
 use std::cmp;
 
-use tari_core::{base_node::LocalNodeCommsInterface, blocks::HistoricalBlock};
+use tari_core::base_node::LocalNodeCommsInterface;
+use tari_node_components::blocks::HistoricalBlock;
 use tonic::Status;
 
 // The maximum number of blocks that can be requested at a time. These will be streamed to the