GH-605: Review two

node/src/accountant/db_access_objects/failed_payable_dao.rs

@@ -1,7 +1,7 @@
 // Copyright (c) 2025, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
 use crate::accountant::db_access_objects::sent_payable_dao::Tx;
 use crate::accountant::db_access_objects::utils::{
-    DaoFactoryReal, TxHash, TxIdentifiers, VigilantRusqliteFlatten,
+    sql_values_of_failed_tx, DaoFactoryReal, TxHash, TxIdentifiers, VigilantRusqliteFlatten,
 };
 use crate::accountant::db_access_objects::Transaction;
 use crate::accountant::db_big_integer::big_int_divider::BigIntDivider;
@@ -96,31 +96,31 @@ pub struct FailedTx {
 
 impl Transaction for FailedTx {
     fn hash(&self) -> TxHash {
-        todo!()
+        self.hash
     }
 
     fn receiver_address(&self) -> Address {
         self.receiver_address
     }
 
     fn amount(&self) -> u128 {
-        todo!()
+        self.amount
     }
 
     fn timestamp(&self) -> i64 {
-        todo!()
+        self.timestamp
     }
 
     fn gas_price_wei(&self) -> u128 {
-        todo!()
+        self.gas_price_wei
     }
 
     fn nonce(&self) -> u64 {
-        todo!()
+        self.nonce
     }
 
     fn is_failed(&self) -> bool {
-        todo!()
+        true
     }
 }
 
@@ -142,9 +142,9 @@ impl Ord for FailedTx {
     }
 }
 
-impl FailedTx {
-    pub fn from_sent_tx_and_web3_err(sent_tx: &Tx, error: &Web3Error) -> Self {
-        FailedTx {
+impl From<(&Tx, &Web3Error)> for FailedTx {
+    fn from((sent_tx, error): (&Tx, &Web3Error)) -> Self {
+        Self {
             hash: sent_tx.hash,
             receiver_address: sent_tx.receiver_address,
             amount: sent_tx.amount,
@@ -260,30 +260,7 @@ impl FailedPayableDao for FailedPayableDaoReal<'_> {
              reason, \
              status
              ) VALUES {}",
-            join_with_separator(
-                txs,
-                |tx| {
-                    let amount_checked = checked_conversion::<u128, i128>(tx.amount);
-                    let gas_price_wei_checked = checked_conversion::<u128, i128>(tx.gas_price_wei);
-                    let (amount_high_b, amount_low_b) = BigIntDivider::deconstruct(amount_checked);
-                    let (gas_price_wei_high_b, gas_price_wei_low_b) =
-                        BigIntDivider::deconstruct(gas_price_wei_checked);
-                    format!(
-                        "('{:?}', '{:?}', {}, {}, {}, {}, {}, {}, '{}', '{}')",
-                        tx.hash,
-                        tx.receiver_address,
-                        amount_high_b,
-                        amount_low_b,
-                        tx.timestamp,
-                        gas_price_wei_high_b,
-                        gas_price_wei_low_b,
-                        tx.nonce,
-                        tx.reason,
-                        tx.status
-                    )
-                },
-                ", "
-            )
+            join_with_separator(txs, |tx| sql_values_of_failed_tx(tx), ", ")
         );
 
         match self.conn.prepare(&sql).expect("Internal error").execute([]) {
@@ -452,13 +429,14 @@ mod tests {
         Concluded, RecheckRequired, RetryRequired,
     };
     use crate::accountant::db_access_objects::failed_payable_dao::{
-        FailedPayableDao, FailedPayableDaoError, FailedPayableDaoReal, FailureReason,
+        FailedPayableDao, FailedPayableDaoError, FailedPayableDaoReal, FailedTx, FailureReason,
         FailureRetrieveCondition, FailureStatus, ValidationStatus,
     };
     use crate::accountant::db_access_objects::test_utils::{
         make_read_only_db_connection, FailedTxBuilder,
     };
     use crate::accountant::db_access_objects::utils::current_unix_timestamp;
+    use crate::accountant::db_access_objects::Transaction;
     use crate::blockchain::errors::rpc_errors::LocalError::Decoder;
     use crate::blockchain::errors::rpc_errors::{AppRpcError, AppRpcErrorKind};
     use crate::blockchain::errors::validation_status::{
@@ -709,23 +687,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn show_str() {
-        let validation_failure_clock = ValidationFailureClockMock::default().now_result(
-            SystemTime::UNIX_EPOCH
-                .add(Duration::from_secs(1755080031))
-                .add(Duration::from_nanos(612180914)),
-        );
-        let a =
-            FailureStatus::RecheckRequired(ValidationStatus::Reattempting(PreviousAttempts::new(
-                BlockchainErrorKind::AppRpc(AppRpcErrorKind::Unreachable),
-                &validation_failure_clock,
-            )))
-            .to_string();
-
-        eprintln!("a: {}", a);
-    }
-
     #[test]
     fn failure_status_from_str_works() {
         let validation_failure_clock = ValidationFailureClockMock::default().now_result(
@@ -988,12 +949,12 @@ mod tests {
         ]);
 
         let result = subject.update_statuses(hashmap);
-
         let updated_txs = subject.retrieve_txs(None);
-        let updated_tx1 = updated_txs.iter().find(|tx| tx.hash == hash1).unwrap();
-        let updated_tx2 = updated_txs.iter().find(|tx| tx.hash == hash2).unwrap();
-        let updated_tx3 = updated_txs.iter().find(|tx| tx.hash == hash3).unwrap();
-        let updated_tx4 = updated_txs.iter().find(|tx| tx.hash == hash4).unwrap();
+        let find_tx = |tx_hash| updated_txs.iter().find(|tx| tx.hash == tx_hash).unwrap();
+        let updated_tx1 = find_tx(hash1);
+        let updated_tx2 = find_tx(hash2);
+        let updated_tx3 = find_tx(hash3);
+        let updated_tx4 = find_tx(hash4);
         assert_eq!(result, Ok(()));
         assert_eq!(tx1.status, RetryRequired);
         assert_eq!(updated_tx1.status, Concluded);
@@ -1206,4 +1167,35 @@ mod tests {
         let expected_order = vec![tx4, tx3, tx2, tx1];
         assert_eq!(set.into_iter().collect::<Vec<_>>(), expected_order);
     }
+
+    #[test]
+    fn transaction_trait_methods_for_failed_tx() {
+        let hash = make_tx_hash(1);
+        let receiver_address = make_address(1);
+        let amount = 1000;
+        let timestamp = 1625247600;
+        let gas_price_wei = 2000;
+        let nonce = 42;
+        let reason = FailureReason::Reverted;
+        let status = FailureStatus::RetryRequired;
+
+        let failed_tx = FailedTx {
+            hash,
+            receiver_address,
+            amount,
+            timestamp,
+            gas_price_wei,
+            nonce,
+            reason,
+            status,
+        };
+
+        assert_eq!(failed_tx.receiver_address(), receiver_address);
+        assert_eq!(failed_tx.hash(), hash);
+        assert_eq!(failed_tx.amount(), amount);
+        assert_eq!(failed_tx.timestamp(), timestamp);
+        assert_eq!(failed_tx.gas_price_wei(), gas_price_wei);
+        assert_eq!(failed_tx.nonce(), nonce);
+        assert_eq!(failed_tx.is_failed(), true);
+    }
 }

node/src/accountant/db_access_objects/payable_dao.rs

@@ -1259,10 +1259,10 @@ mod tests {
     }
 
     #[test]
-    fn retrieve_payables_should_return_payables_with_no_pending_transaction_by_addresses() {
+    fn retrieve_payables_should_return_payables_by_addresses() {
         let home_dir = ensure_node_home_directory_exists(
             "payable_dao",
-            "retrieve_payables_should_return_payables_with_no_pending_transaction_by_addresses",
+            "retrieve_payables_should_return_payables_by_addresses",
         );
         let subject = PayableDaoReal::new(
             DbInitializerReal::default()

node/src/accountant/db_access_objects/sent_payable_dao.rs

@@ -8,7 +8,7 @@ use ethereum_types::{H256};
 use web3::types::Address;
 use masq_lib::utils::ExpectValue;
 use crate::accountant::{checked_conversion, join_with_separator};
-use crate::accountant::db_access_objects::utils::{DaoFactoryReal, TxHash, TxIdentifiers};
+use crate::accountant::db_access_objects::utils::{sql_values_of_sent_tx, DaoFactoryReal, TxHash, TxIdentifiers};
 use crate::accountant::db_big_integer::big_int_divider::BigIntDivider;
 use crate::blockchain::blockchain_interface::blockchain_interface_web3::lower_level_interface_web3::{TransactionBlock};
 use crate::database::rusqlite_wrappers::ConnectionWrapper;
@@ -39,31 +39,31 @@ pub struct Tx {
 
 impl Transaction for Tx {
     fn hash(&self) -> TxHash {
-        todo!()
+        self.hash
     }
 
     fn receiver_address(&self) -> Address {
         self.receiver_address
     }
 
     fn amount(&self) -> u128 {
-        todo!()
+        self.amount
     }
 
     fn timestamp(&self) -> i64 {
-        todo!()
+        self.timestamp
     }
 
     fn gas_price_wei(&self) -> u128 {
-        todo!()
+        self.gas_price_wei
     }
 
     fn nonce(&self) -> u64 {
-        todo!()
+        self.nonce
     }
 
     fn is_failed(&self) -> bool {
-        todo!()
+        false
     }
 }
 
@@ -238,29 +238,7 @@ impl SentPayableDao for SentPayableDaoReal<'_> {
              nonce, \
              status \
              ) VALUES {}",
-            join_with_separator(
-                txs,
-                |tx| {
-                    let amount_checked = checked_conversion::<u128, i128>(tx.amount);
-                    let gas_price_wei_checked = checked_conversion::<u128, i128>(tx.gas_price_wei);
-                    let (amount_high_b, amount_low_b) = BigIntDivider::deconstruct(amount_checked);
-                    let (gas_price_wei_high_b, gas_price_wei_low_b) =
-                        BigIntDivider::deconstruct(gas_price_wei_checked);
-                    format!(
-                        "('{:?}', '{:?}', {}, {}, {}, {}, {}, {}, '{}')",
-                        tx.hash,
-                        tx.receiver_address,
-                        amount_high_b,
-                        amount_low_b,
-                        tx.timestamp,
-                        gas_price_wei_high_b,
-                        gas_price_wei_low_b,
-                        tx.nonce,
-                        tx.status
-                    )
-                },
-                ", "
-            )
+            join_with_separator(txs, |tx| sql_values_of_sent_tx(tx), ", ")
         );
 
         match self.conn.prepare(&sql).expect("Internal error").execute([]) {
@@ -503,6 +481,7 @@ mod tests {
     use crate::accountant::db_access_objects::sent_payable_dao::RetrieveCondition::{ByHash, IsPending};
     use crate::accountant::db_access_objects::sent_payable_dao::SentPayableDaoError::{EmptyInput, PartialExecution};
     use crate::accountant::db_access_objects::test_utils::{make_read_only_db_connection, TxBuilder};
+    use crate::accountant::db_access_objects::Transaction;
     use crate::blockchain::blockchain_interface::blockchain_interface_web3::lower_level_interface_web3::{TransactionBlock};
     use crate::blockchain::errors::BlockchainErrorKind;
     use crate::blockchain::errors::rpc_errors::AppRpcErrorKind;
@@ -1401,4 +1380,33 @@ mod tests {
         let expected_order = vec![tx3, tx2, tx1];
         assert_eq!(set.into_iter().collect::<Vec<_>>(), expected_order);
     }
+
+    #[test]
+    fn transaction_trait_methods_for_tx() {
+        let hash = make_tx_hash(1);
+        let receiver_address = make_address(1);
+        let amount = 1000;
+        let timestamp = 1625247600;
+        let gas_price_wei = 2000;
+        let nonce = 42;
+        let status = TxStatus::Pending(ValidationStatus::Waiting);
+
+        let tx = Tx {
+            hash,
+            receiver_address,
+            amount,
+            timestamp,
+            gas_price_wei,
+            nonce,
+            status,
+        };
+
+        assert_eq!(tx.receiver_address(), receiver_address);
+        assert_eq!(tx.hash(), hash);
+        assert_eq!(tx.amount(), amount);
+        assert_eq!(tx.timestamp(), timestamp);
+        assert_eq!(tx.gas_price_wei(), gas_price_wei);
+        assert_eq!(tx.nonce(), nonce);
+        assert_eq!(tx.is_failed(), false);
+    }
 }

node/src/accountant/db_access_objects/test_utils.rs

@@ -163,6 +163,8 @@ pub fn make_sent_tx(n: u32) -> Tx {
 }
 
 pub fn assert_on_sent_txs(left: Vec<Tx>, right: Vec<Tx>) {
+    assert_eq!(left.len(), right.len());
+
     left.iter().zip(right).for_each(|(t1, t2)| {
         assert_eq!(t1.hash, t2.hash);
         assert_eq!(t1.receiver_address, t2.receiver_address);
@@ -175,6 +177,8 @@ pub fn assert_on_sent_txs(left: Vec<Tx>, right: Vec<Tx>) {
 }
 
 pub fn assert_on_failed_txs(left: Vec<FailedTx>, right: Vec<FailedTx>) {
+    assert_eq!(left.len(), right.len());
+
     left.iter().zip(right).for_each(|(f1, f2)| {
         assert_eq!(f1.hash, f2.hash);
         assert_eq!(f1.receiver_address, f2.receiver_address);

node/src/accountant/db_access_objects/utils.rs

@@ -1,5 +1,6 @@
 // Copyright (c) 2019, MASQ (https://masq.ai) and/or its affiliates. All rights reserved.
 
+use crate::accountant::db_access_objects::failed_payable_dao::FailedTx;
 use crate::accountant::db_access_objects::payable_dao::PayableAccount;
 use crate::accountant::db_access_objects::receivable_dao::ReceivableAccount;
 use crate::accountant::db_big_integer::big_int_divider::BigIntDivider;
@@ -22,6 +23,7 @@ use std::path::{Path, PathBuf};
 use std::string::ToString;
 use std::time::Duration;
 use std::time::SystemTime;
+use crate::accountant::db_access_objects::sent_payable_dao::Tx;
 
 pub type TxHash = H256;
 pub type RowId = u64;
@@ -46,6 +48,47 @@ pub fn from_unix_timestamp(unix_timestamp: i64) -> SystemTime {
     SystemTime::UNIX_EPOCH + interval
 }
 
+pub fn sql_values_of_failed_tx(failed_tx: &FailedTx) -> String {
+    let amount_checked = checked_conversion::<u128, i128>(failed_tx.amount);
+    let gas_price_wei_checked = checked_conversion::<u128, i128>(failed_tx.gas_price_wei);
+    let (amount_high_b, amount_low_b) = BigIntDivider::deconstruct(amount_checked);
+    let (gas_price_wei_high_b, gas_price_wei_low_b) =
+        BigIntDivider::deconstruct(gas_price_wei_checked);
+    format!(
+        "('{:?}', '{:?}', {}, {}, {}, {}, {}, {}, '{}', '{}')",
+        failed_tx.hash,
+        failed_tx.receiver_address,
+        amount_high_b,
+        amount_low_b,
+        failed_tx.timestamp,
+        gas_price_wei_high_b,
+        gas_price_wei_low_b,
+        failed_tx.nonce,
+        failed_tx.reason,
+        failed_tx.status
+    )
+}
+
+pub fn sql_values_of_sent_tx(sent_tx: &Tx) -> String {
+    let amount_checked = checked_conversion::<u128, i128>(sent_tx.amount);
+    let gas_price_wei_checked = checked_conversion::<u128, i128>(sent_tx.gas_price_wei);
+    let (amount_high_b, amount_low_b) = BigIntDivider::deconstruct(amount_checked);
+    let (gas_price_wei_high_b, gas_price_wei_low_b) =
+        BigIntDivider::deconstruct(gas_price_wei_checked);
+    format!(
+        "('{:?}', '{:?}', {}, {}, {}, {}, {}, {}, '{}')",
+        sent_tx.hash,
+        sent_tx.receiver_address,
+        amount_high_b,
+        amount_low_b,
+        sent_tx.timestamp,
+        gas_price_wei_high_b,
+        gas_price_wei_low_b,
+        sent_tx.nonce,
+        sent_tx.status
+    )
+}
+
 pub struct DaoFactoryReal {
     pub data_directory: PathBuf,
     pub init_config: DbInitializationConfig,