feat: add import tx method

applications/minotari_console_wallet/src/automation/commands.rs

@@ -94,6 +94,7 @@ pub enum WalletCommand {
     Whois,
     ExportUtxos,
     ExportTx,
+    ImportTx,
     ExportSpentUtxos,
     CountUtxos,
     SetBaseNode,
@@ -817,6 +818,19 @@ pub async fn command_runner(
                 },
                 Err(e) => eprintln!("ExportTx error! {}", e),
             },
+            ImportTx(args) => {
+                match load_tx_from_csv_file(args.input_file) {
+                    Ok(txs) => {
+                        for tx in txs {
+                            match transaction_service.import_transaction(tx).await {
+                                Ok(id) => println!("imported tx: {}", id),
+                                Err(e) => eprintln!("Could not import tx {}", e),
+                            };
+                        }
+                    },
+                    Err(e) => eprintln!("ImportTx error! {}", e),
+                };
+            },
             ExportSpentUtxos(args) => match output_service.get_spent_outputs().await {
                 Ok(utxos) => {
                     let utxos: Vec<(WalletOutput, Commitment)> =
@@ -1107,6 +1121,19 @@ fn write_tx_to_csv_file(tx: WalletTransaction, file_path: PathBuf) -> Result<(),
     Ok(())
 }
 
+fn load_tx_from_csv_file(file_path: PathBuf) -> Result<Vec<WalletTransaction>, CommandError> {
+    let file_contents = fs::read_to_string(file_path).map_err(|e| CommandError::CSVFile(e.to_string()))?;
+    let mut results = Vec::new();
+    for line in file_contents.lines() {
+        if let Ok(tx) = serde_json::from_str(line) {
+            results.push(tx);
+        } else {
+            return Err(CommandError::CSVFile("Could not read json file".to_string()));
+        }
+    }
+    Ok(results)
+}
+
 #[allow(dead_code)]
 fn write_json_file<P: AsRef<Path>, T: Serialize>(path: P, data: &T) -> Result<(), CommandError> {
     fs::create_dir_all(path.as_ref().parent().unwrap()).map_err(|e| CommandError::JsonFile(e.to_string()))?;

applications/minotari_console_wallet/src/cli.rs

@@ -124,6 +124,7 @@ pub enum CliCommands {
     Whois(WhoisArgs),
     ExportUtxos(ExportUtxosArgs),
     ExportTx(ExportTxArgs),
+    ImportTx(ImportTxArgs),
     ExportSpentUtxos(ExportUtxosArgs),
     CountUtxos,
     SetBaseNode(SetBaseNodeArgs),
@@ -249,6 +250,12 @@ pub struct ExportTxArgs {
     pub output_file: Option<PathBuf>,
 }
 
+#[derive(Debug, Args, Clone)]
+pub struct ImportTxArgs {
+    #[clap(short, long)]
+    pub input_file: PathBuf,
+}
+
 #[derive(Debug, Args, Clone)]
 pub struct SetBaseNodeArgs {
     pub public_key: UniPublicKey,

applications/minotari_console_wallet/src/wallet_modes.rs

@@ -475,6 +475,7 @@ async fn run_grpc(
 
 #[cfg(test)]
 mod test {
+    use std::path::Path;
 
     use crate::{cli::CliCommands, wallet_modes::parse_command_file};
 
@@ -501,6 +502,8 @@ mod test {
 
             export-tx 123456789 --output-file pie.txt
 
+            import-tx --input-file pie_this_message.txt
+
             # End of script file
             "
         .to_string();
@@ -514,6 +517,7 @@ mod test {
         let mut coin_split = false;
         let mut discover_peer = false;
         let mut export_tx = false;
+        let mut import_tx = false;
         let mut whois = false;
         for command in commands {
             match command {
@@ -532,6 +536,11 @@ mod test {
                         export_tx = true
                     }
                 },
+                CliCommands::ImportTx(args) => {
+                    if args.input_file == Path::new("pie_this_message.txt") {
+                        import_tx = true
+                    }
+                },
                 CliCommands::ExportSpentUtxos(_) => {},
                 CliCommands::CountUtxos => {},
                 CliCommands::SetBaseNode(_) => {},
@@ -546,7 +555,15 @@ mod test {
             }
         }
         assert!(
-            get_balance && send_tari && burn_tari && make_it_rain && coin_split && discover_peer && whois && export_tx
+            get_balance &&
+                send_tari &&
+                burn_tari &&
+                make_it_rain &&
+                coin_split &&
+                discover_peer &&
+                whois &&
+                export_tx &&
+                import_tx
         );
     }
 }

base_layer/wallet/src/transaction_service/handle.rs

@@ -82,6 +82,7 @@ pub enum TransactionServiceRequest {
     GetCancelledCompletedTransactions,
     GetCompletedTransaction(TxId),
     GetAnyTransaction(TxId),
+    ImportTransaction(WalletTransaction),
     SendTransaction {
         destination: TariAddress,
         amount: MicroMinotari,
@@ -165,6 +166,7 @@ impl fmt::Display for TransactionServiceRequest {
             Self::GetPendingInboundTransactions => write!(f, "GetPendingInboundTransactions"),
             Self::GetPendingOutboundTransactions => write!(f, "GetPendingOutboundTransactions"),
             Self::GetCompletedTransactions => write!(f, "GetCompletedTransactions"),
+            Self::ImportTransaction(tx) => write!(f, "ImportTransaction: {:?}", tx),
             Self::GetCancelledPendingInboundTransactions => write!(f, "GetCancelledPendingInboundTransactions"),
             Self::GetCancelledPendingOutboundTransactions => write!(f, "GetCancelledPendingOutboundTransactions"),
             Self::GetCancelledCompletedTransactions => write!(f, "GetCancelledCompletedTransactions"),
@@ -243,6 +245,7 @@ impl fmt::Display for TransactionServiceRequest {
 #[derive(Debug)]
 pub enum TransactionServiceResponse {
     TransactionSent(TxId),
+    TransactionImported(TxId),
     BurntTransactionSent {
         tx_id: TxId,
         proof: Box<BurntProof>,
@@ -727,6 +730,17 @@ impl TransactionServiceHandle {
         }
     }
 
+    pub async fn import_transaction(&mut self, tx: WalletTransaction) -> Result<TxId, TransactionServiceError> {
+        match self
+            .handle
+            .call(TransactionServiceRequest::ImportTransaction(tx))
+            .await??
+        {
+            TransactionServiceResponse::TransactionImported(t) => Ok(t),
+            _ => Err(TransactionServiceError::UnexpectedApiResponse),
+        }
+    }
+
     pub async fn import_utxo_with_status(
         &mut self,
         amount: MicroMinotari,

base_layer/wallet/src/transaction_service/service.rs

@@ -114,7 +114,11 @@ use crate::{
         },
         storage::{
             database::{TransactionBackend, TransactionDatabase},
-            models::{CompletedTransaction, TxCancellationReason},
+            models::{
+                CompletedTransaction,
+                TxCancellationReason,
+                WalletTransaction::{Completed, PendingInbound, PendingOutbound},
+            },
         },
         tasks::{
             check_faux_transaction_status::check_detected_transactions,
@@ -774,6 +778,26 @@ where
             TransactionServiceRequest::GetAnyTransaction(tx_id) => Ok(TransactionServiceResponse::AnyTransaction(
                 Box::new(self.db.get_any_transaction(tx_id)?),
             )),
+            TransactionServiceRequest::ImportTransaction(tx) => {
+                let tx_id = match tx {
+                    PendingInbound(inbound_tx) => {
+                        let tx_id = inbound_tx.tx_id;
+                        self.db.insert_pending_inbound_transaction(tx_id, inbound_tx)?;
+                        tx_id
+                    },
+                    PendingOutbound(outbound_tx) => {
+                        let tx_id = outbound_tx.tx_id;
+                        self.db.insert_pending_outbound_transaction(tx_id, outbound_tx)?;
+                        tx_id
+                    },
+                    Completed(completed_tx) => {
+                        let tx_id = completed_tx.tx_id;
+                        self.db.insert_completed_transaction(tx_id, completed_tx)?;
+                        tx_id
+                    },
+                };
+                Ok(TransactionServiceResponse::TransactionImported(tx_id))
+            },
             TransactionServiceRequest::ImportUtxoWithStatus {
                 amount,
                 source_address,

base_layer/wallet/src/transaction_service/storage/database.rs

@@ -320,6 +320,30 @@ where T: TransactionBackend + 'static
             )))
     }
 
+    pub fn insert_pending_inbound_transaction(
+        &self,
+        tx_id: TxId,
+        transaction: InboundTransaction,
+    ) -> Result<Option<DbValue>, TransactionStorageError> {
+        self.db
+            .write(WriteOperation::Insert(DbKeyValuePair::PendingInboundTransaction(
+                tx_id,
+                Box::new(transaction),
+            )))
+    }
+
+    pub fn insert_pending_outbound_transaction(
+        &self,
+        tx_id: TxId,
+        transaction: OutboundTransaction,
+    ) -> Result<Option<DbValue>, TransactionStorageError> {
+        self.db
+            .write(WriteOperation::Insert(DbKeyValuePair::PendingOutboundTransaction(
+                tx_id,
+                Box::new(transaction),
+            )))
+    }
+
     pub fn get_pending_outbound_transaction(
         &self,
         tx_id: TxId,

base_layer/wallet/src/transaction_service/storage/models.rs

@@ -303,7 +303,7 @@ impl From<InboundTransaction> for CompletedTransaction {
     }
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Clone)]
 #[allow(clippy::large_enum_variant)]
 pub enum WalletTransaction {
     PendingInbound(InboundTransaction),