rename leftovers to uncredited_settlement_amount

Author: gakonst

crates/interledger-settlement-engines/src/engines/ethereum_ledger/eth_engine.rs

@@ -297,6 +297,9 @@ where
         let our_address = self.address.own_address;
         let token_address = self.address.token_address;
 
+        // We `Box` futures in these functions due to
+        // https://github.com/rust-lang/rust/issues/54540#issuecomment-494749912.
+        // Otherwise, we get `type_length_limit` errors.
         // get the current block number
         Box::new(
             web3.eth()
@@ -306,7 +309,6 @@ where
                     trace!("Current block {}", current_block);
                     // get the safe number of blocks to avoid reorgs
                     let fetch_until = current_block - confirmations;
-                    // U256 does not implement IntoFuture so we must wrap it
                     Ok((Ok(fetch_until), store.load_recently_observed_block()))
                 })
                 .flatten()
@@ -506,19 +508,19 @@ where
             .push("settlements");
         debug!("Making POST to {:?} {:?} about {:?}", url, amount, tx_hash);
 
-        // settle for amount + leftovers
+        // settle for amount + uncredited_settlement_amount
         let account_id_clone = account_id.clone();
         let full_amount_fut = self
             .store
-            .pop_leftovers(account_id.clone())
-            .and_then(move |leftovers| {
+            .load_uncredited_settlement_amount(account_id.clone())
+            .and_then(move |uncredited_settlement_amount| {
                 let full_amount_fut2 = result(BigUint::from_str(&amount).map_err(move |err| {
                     let error_msg = format!("Error converting to BigUint {:?}", err);
                     error!("{:?}", error_msg);
                 }))
                 .and_then(move |amount| {
                     debug!("Got uncredited amount {}", amount);
-                    let full_amount = amount + leftovers;
+                    let full_amount = amount + uncredited_settlement_amount;
                     debug!(
                         "Notifying accounting system about full amount: {}",
                         full_amount
@@ -573,7 +575,7 @@ where
 
     /// Parses a response from a connector into a Quantity type and calls a
     /// function to further process the parsed data to check if the store's
-    /// leftovers should be updated.
+    /// uncredited settlement amount should be updated.
     fn process_connector_response(
         &self,
         account_id: String,
@@ -608,7 +610,7 @@ where
 
     // Normalizes a received Quantity object against the local engine scale, and
     // if the normalized value is less than what the engine originally sent, it
-    // stores it as leftovers in the store.
+    // stores it as uncredited settlement amount in the store.
     fn process_received_quantity(
         &self,
         account_id: String,
@@ -635,8 +637,8 @@ where
                             let diff = engine_amount - scaled_connector_amount;
                             // connector settled less than we
                             // instructed it to, so we must save
-                            // the difference for the leftovers
-                            store.save_leftovers(account_id, diff)
+                            // the difference
+                            store.save_uncredited_settlement_amount(account_id, diff)
                         } else {
                             Box::new(ok(()))
                         }

crates/interledger-settlement-engines/src/engines/ethereum_ledger/test_helpers.rs

@@ -62,7 +62,7 @@ pub struct TestStore {
     pub last_observed_block: Arc<RwLock<U256>>,
     pub saved_hashes: Arc<RwLock<HashMap<H256, bool>>>,
     pub cache_hits: Arc<RwLock<u64>>,
-    pub leftovers: Arc<RwLock<HashMap<String, BigUint>>>,
+    pub uncredited_settlement_amount: Arc<RwLock<HashMap<String, BigUint>>>,
 }
 
 use crate::stores::LeftoversStore;
@@ -71,21 +71,21 @@ use num_bigint::BigUint;
 impl LeftoversStore for TestStore {
     type AssetType = BigUint;
 
-    fn save_leftovers(
+    fn save_uncredited_settlement_amount(
         &self,
         account_id: String,
-        leftovers: Self::AssetType,
+        uncredited_settlement_amount: Self::AssetType,
     ) -> Box<Future<Item = (), Error = ()> + Send> {
-        let mut guard = self.leftovers.write();
-        (*guard).insert(account_id, leftovers);
+        let mut guard = self.uncredited_settlement_amount.write();
+        (*guard).insert(account_id, uncredited_settlement_amount);
         Box::new(ok(()))
     }
 
-    fn pop_leftovers(
+    fn load_uncredited_settlement_amount(
         &self,
         account_id: String,
     ) -> Box<Future<Item = Self::AssetType, Error = ()> + Send> {
-        let mut guard = self.leftovers.write();
+        let mut guard = self.uncredited_settlement_amount.write();
         if let Some(l) = guard.get(&account_id) {
             let l = l.clone();
             (*guard).insert(account_id, Zero::zero());
@@ -269,7 +269,7 @@ impl TestStore {
             cache_hits: Arc::new(RwLock::new(0)),
             last_observed_block: Arc::new(RwLock::new(U256::from(0))),
             saved_hashes: Arc::new(RwLock::new(HashMap::new())),
-            leftovers: Arc::new(RwLock::new(HashMap::new())),
+            uncredited_settlement_amount: Arc::new(RwLock::new(HashMap::new())),
         }
     }
 }

crates/interledger-settlement-engines/src/stores/mod.rs

@@ -33,14 +33,14 @@ pub trait LeftoversStore {
     type AssetType;
 
     /// Saves the leftover data
-    fn save_leftovers(
+    fn save_uncredited_settlement_amount(
         &self,
         account_id: String,
-        leftovers: Self::AssetType,
+        uncredited_settlement_amount: Self::AssetType,
     ) -> Box<dyn Future<Item = (), Error = ()> + Send>;
 
     /// Clears the leftover data in the database and returns the cleared value
-    fn pop_leftovers(
+    fn load_uncredited_settlement_amount(
         &self,
         account_id: String,
     ) -> Box<dyn Future<Item = Self::AssetType, Error = ()> + Send>;

crates/interledger-settlement-engines/src/stores/redis_ethereum_ledger/store.rs

@@ -112,46 +112,64 @@ impl EthereumLedgerRedisStore {
 impl LeftoversStore for EthereumLedgerRedisStore {
     type AssetType = BigUint;
 
-    fn save_leftovers(
+    fn save_uncredited_settlement_amount(
         &self,
         account_id: String,
-        leftovers: Self::AssetType,
+        uncredited_settlement_amount: Self::AssetType,
     ) -> Box<dyn Future<Item = (), Error = ()> + Send> {
-        trace!("Saving leftovers {:?} {:?}", account_id, leftovers);
+        trace!(
+            "Saving uncredited_settlement_amount {:?} {:?}",
+            account_id,
+            uncredited_settlement_amount
+        );
         let mut pipe = redis::pipe();
-        pipe.set(format!("leftovers:{}", account_id), leftovers.to_string())
-            .ignore();
+        pipe.set(
+            format!("uncredited_settlement_amount:{}", account_id),
+            uncredited_settlement_amount.to_string(),
+        )
+        .ignore();
         Box::new(
             pipe.query_async(self.connection.clone())
-                .map_err(move |err| error!("Error saving leftovers {:?}: {:?}", leftovers, err))
+                .map_err(move |err| {
+                    error!(
+                        "Error saving uncredited_settlement_amount {:?}: {:?}",
+                        uncredited_settlement_amount, err
+                    )
+                })
                 .and_then(move |(_conn, _ret): (_, Value)| Ok(())),
         )
     }
 
-    fn pop_leftovers(
+    fn load_uncredited_settlement_amount(
         &self,
         account_id: String,
     ) -> Box<dyn Future<Item = Self::AssetType, Error = ()> + Send> {
-        trace!("Loading leftovers {:?}", account_id);
+        trace!("Loading uncredited_settlement_amount {:?}", account_id);
         let mut pipe = redis::pipe();
         // Loads the value and resets it to 0
-        pipe.getset(format!("leftovers:{}", account_id), 0);
+        pipe.getset(format!("uncredited_settlement_amount:{}", account_id), 0);
         Box::new(
             pipe.query_async(self.connection.clone())
-                .map_err(move |err| error!("Error loading leftovers {:?}: ", err))
-                .and_then(move |(_conn, leftovers): (_, Vec<String>)| {
-                    // redis.rs returns a bulk value for some reason, length is
-                    // always 1
-                    if leftovers.len() == 1 {
-                        if let Ok(leftovers) = BigUint::from_str(&leftovers[0]) {
-                            Box::new(ok(leftovers))
+                .map_err(move |err| {
+                    error!("Error loading uncredited_settlement_amount {:?}: ", err)
+                })
+                .and_then(
+                    move |(_conn, uncredited_settlement_amount): (_, Vec<String>)| {
+                        // redis.rs returns a bulk value for some reason, length is
+                        // always 1
+                        if uncredited_settlement_amount.len() == 1 {
+                            if let Ok(uncredited_settlement_amount) =
+                                BigUint::from_str(&uncredited_settlement_amount[0])
+                            {
+                                Box::new(ok(uncredited_settlement_amount))
+                            } else {
+                                Box::new(ok(Zero::zero()))
+                            }
                         } else {
                             Box::new(ok(Zero::zero()))
                         }
-                    } else {
-                        Box::new(ok(Zero::zero()))
-                    }
-                }),
+                    },
+                ),
         )
     }
 }
@@ -337,16 +355,16 @@ mod tests {
     use std::str::FromStr;
 
     #[test]
-    fn saves_and_pops_leftovers_properly() {
+    fn saves_and_pops_uncredited_settlement_amount_properly() {
         let amount = BigUint::from(100u64);
         let acc = "0".to_string();
         block_on(test_store().and_then(|(store, context)| {
             store
-                .save_leftovers(acc.clone(), amount.clone())
+                .save_uncredited_settlement_amount(acc.clone(), amount.clone())
                 .map_err(|err| eprintln!("Redis error: {:?}", err))
                 .and_then(move |_| {
                     store
-                        .pop_leftovers(acc)
+                        .load_uncredited_settlement_amount(acc)
                         .map_err(|err| eprintln!("Redis error: {:?}", err))
                         .and_then(move |ret| {
                             assert_eq!(amount, ret);

crates/interledger-settlement/src/lib.rs

@@ -186,7 +186,7 @@ mod tests {
                 .unwrap(),
             1
         );
-        // there's leftovers for all number slots which do not increase in
+        // there's uncredited_settlement_amount for all number slots which do not increase in
         // increments of 10^abs(to_scale-from_scale)
         assert_eq!(
             1u64.normalize_scale(ConvertDetails { from: 2, to: 1 })
@@ -219,7 +219,7 @@ mod tests {
                 .unwrap(),
             100
         );
-        // 299 units with base 3 is 29 units with base 2 (0.9 leftovers)
+        // 299 units with base 3 is 29 units with base 2 (0.9 uncredited_settlement_amount)
         assert_eq!(
             299u64
                 .normalize_scale(ConvertDetails { from: 3, to: 2 })