fixed gettransactions test

Author: rdeioris

stackslib/src/chainstate/coordinator/mod.rs

@@ -223,12 +223,12 @@ impl ChainsCoordinatorConfig {
         }
     }
 
-    pub fn test_new() -> ChainsCoordinatorConfig {
+    pub fn test_new(txindex: bool) -> ChainsCoordinatorConfig {
         ChainsCoordinatorConfig {
             always_use_affirmation_maps: false,
             require_affirmed_anchor_blocks: false,
             assume_present_anchor_blocks: false,
-            txindex: false,
+            txindex,
         }
     }
 }
@@ -651,6 +651,7 @@ impl<T: BlockEventDispatcher, U: RewardSetProvider, B: BurnchainHeaderReader>
         path: &str,
         reward_set_provider: U,
         indexer: B,
+        txindex: bool,
     ) -> ChainsCoordinator<'a, T, (), U, (), (), B> {
         ChainsCoordinator::test_new_full(
             burnchain,
@@ -660,6 +661,7 @@ impl<T: BlockEventDispatcher, U: RewardSetProvider, B: BurnchainHeaderReader>
             None,
             indexer,
             None,
+            txindex,
         )
     }
 
@@ -673,6 +675,7 @@ impl<T: BlockEventDispatcher, U: RewardSetProvider, B: BurnchainHeaderReader>
         dispatcher: Option<&'a T>,
         burnchain_indexer: B,
         atlas_config: Option<AtlasConfig>,
+        txindex: bool,
     ) -> ChainsCoordinator<'a, T, (), U, (), (), B> {
         let burnchain = burnchain.clone();
 
@@ -718,7 +721,7 @@ impl<T: BlockEventDispatcher, U: RewardSetProvider, B: BurnchainHeaderReader>
             notifier: (),
             atlas_config,
             atlas_db: Some(atlas_db),
-            config: ChainsCoordinatorConfig::test_new(),
+            config: ChainsCoordinatorConfig::test_new(txindex),
             burnchain_indexer,
             refresh_stacker_db: Arc::new(AtomicBool::new(false)),
             in_nakamoto_epoch: false,

stackslib/src/chainstate/coordinator/tests.rs

@@ -469,13 +469,15 @@ pub fn make_coordinator<'a>(
         path,
         OnChainRewardSetProvider(None),
         indexer,
+        false,
     )
 }
 
 pub fn make_coordinator_atlas<'a>(
     path: &str,
     burnchain: Option<Burnchain>,
     atlas_config: Option<AtlasConfig>,
+    txindex: bool,
 ) -> ChainsCoordinator<
     'a,
     NullEventDispatcher,
@@ -495,6 +497,7 @@ pub fn make_coordinator_atlas<'a>(
         None,
         indexer,
         atlas_config,
+        txindex,
     )
 }
 
@@ -544,6 +547,7 @@ fn make_reward_set_coordinator<'a>(
         path,
         StubbedRewardSetProvider(addrs),
         indexer,
+        false,
     )
 }
 
@@ -4656,6 +4660,7 @@ fn atlas_stop_start() {
         path,
         Some(burnchain_conf.clone()),
         Some(atlas_config.clone()),
+        false,
     );
 
     coord.handle_new_burnchain_block().unwrap();
@@ -4850,7 +4855,7 @@ fn atlas_stop_start() {
     // now, we'll shut down all the coordinator connections and reopen them
     //  to ensure that the queue remains in place
     let coord = (); // dispose of the coordinator, closing all its connections
-    let coord = make_coordinator_atlas(path, Some(burnchain_conf), Some(atlas_config));
+    let coord = make_coordinator_atlas(path, Some(burnchain_conf), Some(atlas_config), false);
 
     let atlas_queue = coord
         .atlas_db

stackslib/src/chainstate/nakamoto/coordinator/tests.rs

@@ -1631,21 +1631,18 @@ fn transactions_indexing() {
     // compare transactions to what has been tracked
     for tx in tracked_block.txs {
         let current_tx_hex = to_hex(&tx.serialize_to_vec());
-        let (index_block_hash, tx_hex) =
-            NakamotoChainState::get_index_block_hash_and_tx_hex_from_txid(
-                &chainstate.index_conn(),
-                tx.txid(),
-            )
-            .unwrap()
-            .unwrap();
+        let (index_block_hash, tx_hex, _) =
+            NakamotoChainState::get_tx_info_from_txid(&chainstate.index_conn(), tx.txid())
+                .unwrap()
+                .unwrap();
         assert_eq!(index_block_hash, tracked_block_id);
         assert_eq!(tx_hex, current_tx_hex);
     }
 
     // ensure untracked transactions are not recorded
     for tx in untracked_block.txs {
         assert_eq!(
-            NakamotoChainState::get_index_block_hash_and_tx_hex_from_txid(
+            NakamotoChainState::get_tx_info_from_txid(
                 &chainstate.index_conn(),
                 tx.txid(),
             )

stackslib/src/chainstate/nakamoto/mod.rs

@@ -3564,20 +3564,20 @@ impl NakamotoChainState {
     }
 
     // Get index_block_hash and transaction payload hex by txid from the transactions table
-    pub fn get_index_block_hash_and_tx_hex_from_txid(
+    pub fn get_tx_info_from_txid(
         conn: &Connection,
         txid: Txid,
-    ) -> Result<Option<(StacksBlockId, String)>, ChainstateError> {
-        let sql = "SELECT index_block_hash, tx_hex FROM transactions WHERE txid = ?";
+    ) -> Result<Option<(StacksBlockId, String, String)>, ChainstateError> {
+        let sql = "SELECT index_block_hash, tx_hex, result FROM transactions WHERE txid = ?";
         let args = params![txid];
 
         let mut stmt = conn.prepare(sql)?;
         Ok(stmt
             .query_row(args, |row| {
                 let index_block_hash: StacksBlockId = row.get(0)?;
                 let tx_hex: String = row.get(1)?;
-
-                Ok((index_block_hash, tx_hex))
+                let result: String = row.get(2)?;
+                Ok((index_block_hash, tx_hex, result))
             })
             .optional()?)
     }

stackslib/src/net/api/gettransactions.rs

@@ -31,6 +31,7 @@ use crate::burnchains::Txid;
 use crate::chainstate::burn::db::sortdb::SortitionDB;
 use crate::chainstate::nakamoto::NakamotoChainState;
 use crate::chainstate::stacks::db::StacksChainState;
+use crate::chainstate::stacks::StacksTransaction;
 use crate::core::mempool::MemPoolDB;
 use crate::net::http::{
     parse_json, Error, HttpNotFound, HttpNotImplemented, HttpRequest, HttpRequestContents,
@@ -48,6 +49,7 @@ use crate::net::{Error as NetError, StacksNodeState, TipRequest};
 pub struct TransactionResponse {
     pub index_block_hash: StacksBlockId,
     pub tx: String,
+    pub result: String,
 }
 
 #[derive(Clone)]
@@ -124,31 +126,28 @@ impl RPCRequestHandler for RPCGetTransactionRequestHandler {
             .ok_or(NetError::SendError("`txid` no set".into()))?;
 
         node.with_node_state(|_network, _sortdb, chainstate, _mempool, _rpc_args| {
-            let index_block_hash_and_tx_hex_opt =
-                match NakamotoChainState::get_index_block_hash_and_tx_hex_from_txid(
-                    chainstate.index_conn().conn(),
-                    txid,
-                ) {
-                    Ok(index_block_hash_and_tx_hex_opt) => index_block_hash_and_tx_hex_opt,
-                    Err(e) => {
-                        // nope -- error trying to check
-                        let msg = format!("Failed to load transaction: {:?}\n", &e);
-                        warn!("{}", &msg);
-                        return StacksHttpResponse::new_error(
-                            &preamble,
-                            &HttpServerError::new(msg),
-                        )
+            let index_block_hash_and_tx_hex_opt = match NakamotoChainState::get_tx_info_from_txid(
+                chainstate.index_conn().conn(),
+                txid,
+            ) {
+                Ok(index_block_hash_and_tx_hex_opt) => index_block_hash_and_tx_hex_opt,
+                Err(e) => {
+                    // nope -- error trying to check
+                    let msg = format!("Failed to load transaction: {:?}\n", &e);
+                    warn!("{}", &msg);
+                    return StacksHttpResponse::new_error(&preamble, &HttpServerError::new(msg))
                         .try_into_contents()
                         .map_err(NetError::from);
-                    }
-                };
+                }
+            };
 
             match index_block_hash_and_tx_hex_opt {
-                Some((index_block_hash, tx_hex)) => {
+                Some((index_block_hash, tx_hex, result)) => {
                     let preamble = HttpResponsePreamble::ok_json(&preamble);
                     let body = HttpResponseContents::try_from_json(&TransactionResponse {
                         index_block_hash,
                         tx: tx_hex,
+                        result,
                     })?;
                     return Ok((preamble, body));
                 }

stackslib/src/net/api/tests/gettransactions.rs

@@ -164,17 +164,12 @@ fn test_try_make_response() {
 
     // check genesis txid
     let response = responses.remove(0);
-    let contents = response.get_http_payload_ok().unwrap();
-    let response_json: serde_json::Value = contents.try_into().unwrap();
-    println!("RESPONSE: {}", response_json);
-    /*
     let resp = response.decode_gettransaction().unwrap();
 
     let tx_bytes = hex_bytes(&resp.tx).unwrap();
     let stacks_transaction = StacksTransaction::consensus_deserialize(&mut &tx_bytes[..]).unwrap();
     assert_eq!(stacks_transaction.txid(), tx_genesis.txid());
     assert_eq!(stacks_transaction.serialize_to_vec(), tx_bytes);
-    */
 
     // check tip txid
     let response = responses.remove(0);

stackslib/src/net/mod.rs

@@ -3141,6 +3141,7 @@ pub mod test {
                 observer,
                 indexer,
                 None,
+                config.txindex,
             );
             coord.handle_new_burnchain_block().unwrap();
 

stackslib/src/net/tests/inv/nakamoto.rs

@@ -517,6 +517,7 @@ where
             .with_test_signers(test_signers)
             .with_test_stackers(test_stackers),
     );
+
     plan.initial_balances.append(&mut initial_balances);
 
     let (peer, other_peers) = plan.boot_into_nakamoto_peers(boot_tenures, Some(observer));

stackslib/src/net/tests/mod.rs

@@ -367,6 +367,7 @@ impl NakamotoBootPlan {
         peer_config.network_id = self.network_id;
         peer_config.private_key = self.private_key.clone();
         peer_config.txindex = self.txindex;
+
         let addr = StacksAddress::from_public_keys(
             C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
             &AddressHashMode::SerializeP2PKH,