Plug getConfirmedSignaturesForAddress2 into bigtable storage

core/src/rpc.rs

@@ -839,8 +839,8 @@ impl JsonRpcRequestProcessor {
     pub fn get_confirmed_signatures_for_address2(
         &self,
         address: Pubkey,
-        before: Option<Signature>,
+        mut before: Option<Signature>,
-        limit: usize,
+        mut limit: usize,
     ) -> Result<Vec<RpcConfirmedTransactionStatusWithSignature>> {
         if self.config.enable_rpc_transaction_history {
             let highest_confirmed_root = self
@@ -849,7 +849,7 @@ impl JsonRpcRequestProcessor {
                 .unwrap()
                 .highest_confirmed_root();
 
-            let results = self
+            let mut results = self
                 .blockstore
                 .get_confirmed_signatures_for_address2(
                     address,
@@ -859,6 +859,27 @@ impl JsonRpcRequestProcessor {
                 )
                 .map_err(|err| Error::invalid_params(format!("{}", err)))?;
 
+            if results.len() < limit {
+                if let Some(bigtable_ledger_storage) = &self.bigtable_ledger_storage {
+                    if !results.is_empty() {
+                        limit -= results.len();
+                        before = results.last().map(|x| x.signature);
+                    }
+
+                    let mut bigtable_results = self
+                        .runtime_handle
+                        .block_on(
+                            bigtable_ledger_storage.get_confirmed_signatures_for_address(
+                                &address,
+                                before.as_ref(),
+                                limit,
+                            ),
+                        )
+                        .map_err(|err| Error::invalid_params(format!("{}", err)))?;
+                    results.append(&mut bigtable_results)
+                }
+            }
+
             Ok(results.into_iter().map(|x| x.into()).collect())
         } else {
             Ok(vec![])

ledger-tool/src/bigtable.rs

@@ -308,30 +308,39 @@ async fn confirm(signature: &Signature, verbose: bool) -> Result<(), Box<dyn std
 
 pub async fn transaction_history(
     address: &Pubkey,
-    limit: usize,
+    mut limit: usize,
-    before: Option<&Signature>,
+    mut before: Option<Signature>,
     verbose: bool,
 ) -> Result<(), Box<dyn std::error::Error>> {
     let bigtable = solana_storage_bigtable::LedgerStorage::new(true).await?;
 
-    let results = bigtable
+    while limit > 0 {
-        .get_confirmed_signatures_for_address(address, before, limit)
+        let results = bigtable
-        .await?;
+            .get_confirmed_signatures_for_address(address, before.as_ref(), limit.min(1000))
+            .await?;
 
-    for (signature, slot, memo, err) in results {
+        if results.is_empty() {
-        if verbose {
+            break;
-            println!(
+        }
-                "{}, slot={}, memo=\"{}\", status={}",
+        before = Some(results.last().unwrap().signature);
-                signature,
+        assert!(limit >= results.len());
-                slot,
+        limit = limit.saturating_sub(results.len());
-                memo.unwrap_or_else(|| "".to_string()),
+
-                match err {
+        for result in results {
-                    None => "Confirmed".to_string(),
+            if verbose {
-                    Some(err) => format!("Failed: {:?}", err),
+                println!(
-                }
+                    "{}, slot={}, memo=\"{}\", status={}",
-            );
+                    result.signature,
-        } else {
+                    result.slot,
-            println!("{}", signature);
+                    result.memo.unwrap_or_else(|| "".to_string()),
+                    match result.err {
+                        None => "Confirmed".to_string(),
+                        Some(err) => format!("Failed: {:?}", err),
+                    }
+                );
+            } else {
+                println!("{}", result.signature);
+            }
         }
     }
     Ok(())
@@ -462,7 +471,7 @@ impl BigTableSubCommand for App<'_, '_> {
                                 .value_name("LIMIT")
                                 .validator(is_slot)
                                 .index(2)
-                                .default_value("1000")
+                                .default_value("18446744073709551615")
                                 .help("Maximum number of transaction signatures to return"),
                         )
                         .arg(
@@ -531,12 +540,7 @@ pub fn bigtable_process_command(ledger_path: &Path, matches: &ArgMatches<'_>) {
                 .map(|signature| signature.parse().expect("Invalid signature"));
             let verbose = arg_matches.is_present("verbose");
 
-            runtime.block_on(transaction_history(
+            runtime.block_on(transaction_history(&address, limit, before, verbose))
-                &address,
-                limit,
-                before.as_ref(),
-                verbose,
-            ))
         }
         _ => unreachable!(),
     };

storage-bigtable/src/lib.rs

@@ -8,8 +8,9 @@ use solana_sdk::{
     transaction::{Transaction, TransactionError},
 };
 use solana_transaction_status::{
-    ConfirmedBlock, ConfirmedTransaction, EncodedTransaction, Rewards, TransactionStatus,
+    ConfirmedBlock, ConfirmedTransaction, ConfirmedTransactionStatusWithSignature,
-    TransactionWithStatusMeta, UiTransactionEncoding, UiTransactionStatusMeta,
+    EncodedTransaction, Rewards, TransactionStatus, TransactionWithStatusMeta,
+    UiTransactionEncoding, UiTransactionStatusMeta,
 };
 use std::{
     collections::HashMap,
@@ -365,7 +366,7 @@ impl LedgerStorage {
         address: &Pubkey,
         before_signature: Option<&Signature>,
         limit: usize,
-    ) -> Result<Vec<(Signature, Slot, Option<String>, Option<TransactionError>)>> {
+    ) -> Result<Vec<ConfirmedTransactionStatusWithSignature>> {
         let mut bigtable = self.connection.client();
         let address_prefix = format!("{}/", address);
 
@@ -414,12 +415,12 @@ impl LedgerStorage {
                 .into_iter()
                 .skip(first_transaction_index as usize)
             {
-                infos.push((
+                infos.push(ConfirmedTransactionStatusWithSignature {
-                    tx_by_addr_info.signature,
+                    signature: tx_by_addr_info.signature,
                     slot,
-                    tx_by_addr_info.memo,
+                    err: tx_by_addr_info.err,
-                    tx_by_addr_info.err,
+                    memo: tx_by_addr_info.memo,
-                ));
+                });
                 if infos.len() >= limit {
                     break 'outer;
                 }