after -> before

ledger-tool/src/bigtable.rs

@@ -309,13 +309,13 @@ async fn confirm(signature: &Signature, verbose: bool) -> Result<(), Box<dyn std
 pub async fn transaction_history(
     address: &Pubkey,
     limit: usize,
-    start_after: Option<&Signature>,
+    before: Option<&Signature>,
     verbose: bool,
 ) -> Result<(), Box<dyn std::error::Error>> {
     let bigtable = solana_storage_bigtable::LedgerStorage::new(true).await?;
 
     let results = bigtable
-        .get_confirmed_signatures_for_address(address, start_after, limit)
+        .get_confirmed_signatures_for_address(address, before, limit)
         .await?;
 
     for (signature, slot, memo, err) in results {
@@ -466,8 +466,8 @@ impl BigTableSubCommand for App<'_, '_> {
                                 .help("Maximum number of transaction signatures to return"),
                         )
                         .arg(
-                            Arg::with_name("after")
-                                .long("after")
+                            Arg::with_name("before")
+                                .long("before")
                                 .value_name("TRANSACTION_SIGNATURE")
                                 .takes_value(true)
                                 .help("Start with the first signature older than this one"),
@@ -526,15 +526,15 @@ pub fn bigtable_process_command(ledger_path: &Path, matches: &ArgMatches<'_>) {
         ("transaction-history", Some(arg_matches)) => {
             let address = pubkey_of(arg_matches, "address").unwrap();
             let limit = value_t_or_exit!(arg_matches, "limit", usize);
-            let after = arg_matches
-                .value_of("after")
+            let before = arg_matches
+                .value_of("before")
                 .map(|signature| signature.parse().expect("Invalid signature"));
             let verbose = arg_matches.is_present("verbose");
 
             runtime.block_on(transaction_history(
                 &address,
                 limit,
-                after.as_ref(),
+                before.as_ref(),
                 verbose,
             ))
         }

storage-bigtable/src/lib.rs

@@ -358,23 +358,23 @@ impl LedgerStorage {
     /// Get confirmed signatures for the provided address, in descending ledger order
     ///
     /// address: address to search for
-    /// start_after_signature: start with the first signature older than this one
+    /// before_signature: start with the first signature older than this one
     /// limit: stop after this many signatures.
     pub async fn get_confirmed_signatures_for_address(
         &self,
         address: &Pubkey,
-        start_after_signature: Option<&Signature>,
+        before_signature: Option<&Signature>,
         limit: usize,
     ) -> Result<Vec<(Signature, Slot, Option<String>, Option<TransactionError>)>> {
         let mut bigtable = self.connection.client();
         let address_prefix = format!("{}/", address);
 
-        // Figure out where to start listing from based on `start_after_signature`
-        let (first_slot, mut first_transaction_index) = match start_after_signature {
+        // Figure out where to start listing from based on `before_signature`
+        let (first_slot, mut first_transaction_index) = match before_signature {
             None => (Slot::MAX, 0),
-            Some(start_after_signature) => {
+            Some(before_signature) => {
                 let TransactionInfo { slot, index, .. } = bigtable
-                    .get_bincode_cell("tx", start_after_signature.to_string())
+                    .get_bincode_cell("tx", before_signature.to_string())
                     .await?;
 
                 (slot, index + 1)