fix(engines): Make leftovers be an associated type

This allows the trait implementer to choose the data type of the leftovers instead of forcing them to use BigUint

Author: gakonst

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

@@ -35,7 +35,7 @@ use tokio_retry::{strategy::ExponentialBackoff, Retry};
 use url::Url;
 use uuid::Uuid;
 
-use crate::stores::redis_ethereum_ledger::*;
+use crate::stores::{redis_ethereum_ledger::*, LeftoversStore};
 use crate::{ApiResponse, CreateAccount, SettlementEngine, SettlementEngineApi};
 use interledger_settlement::{Convert, ConvertDetails, Quantity};
 
@@ -101,7 +101,12 @@ pub struct EthereumLedgerSettlementEngineBuilder<'a, S, Si, A> {
 
 impl<'a, S, Si, A> EthereumLedgerSettlementEngineBuilder<'a, S, Si, A>
 where
-    S: EthereumStore<Account = A> + Clone + Send + Sync + 'static,
+    S: EthereumStore<Account = A>
+        + LeftoversStore<AssetType = BigUint>
+        + Clone
+        + Send
+        + Sync
+        + 'static,
     Si: EthereumLedgerTxSigner + Clone + Send + Sync + 'static,
     A: EthereumAccount + Send + Sync + 'static,
 {
@@ -223,7 +228,12 @@ where
 
 impl<S, Si, A> EthereumLedgerSettlementEngine<S, Si, A>
 where
-    S: EthereumStore<Account = A> + Clone + Send + Sync + 'static,
+    S: EthereumStore<Account = A>
+        + LeftoversStore<AssetType = BigUint>
+        + Clone
+        + Send
+        + Sync
+        + 'static,
     Si: EthereumLedgerTxSigner + Clone + Send + Sync + 'static,
     A: EthereumAccount + Send + Sync + 'static,
 {
@@ -373,7 +383,11 @@ where
                         store
                             .load_account_id_from_address(addr)
                             .and_then(move |id| {
-                                self_clone.notify_connector(id.to_string(), amount.to_string(), tx_hash)
+                                self_clone.notify_connector(
+                                    id.to_string(),
+                                    amount.to_string(),
+                                    tx_hash,
+                                )
                             })
                             .and_then(move |_| {
                                 // only save the transaction hash if the connector
@@ -571,29 +585,31 @@ where
                 })
                 .and_then(move |quantity: Quantity| {
                     result(BigUint::from_str(&quantity.amount))
-                    .map_err(|err| {
-                        let error_msg = format!("Error converting to BigUint {:?}", err);
-                        error!("{:?}", error_msg);
-                    })
-                    .and_then(move |connector_amount: BigUint| {
-                        // Scale the amount settled by the
-                        // connector back up to our scale
-                        result(connector_amount.normalize_scale(ConvertDetails {
-                            from: quantity.scale,
-                            to: engine_scale,
-                        }))
-                        .and_then(move |scaled_connector_amount| {
-                            let diff: BigUint = engine_amount - scaled_connector_amount;
-                            if diff > Zero::zero() {
-                                // connector settled less than we
-                                // instructed it to, so we must save
-                                // the difference for the leftovers
-                                Either::A(store.save_leftovers(account_id, diff))
-                            } else {
-                                Either::B(ok(()))
-                            }
+                        .map_err(|err| {
+                            let error_msg = format!("Error converting to BigUint {:?}", err);
+                            error!("{:?}", error_msg);
+                        })
+                        .and_then(move |connector_amount: BigUint| {
+                            // Scale the amount settled by the
+                            // connector back up to our scale
+                            result(connector_amount.normalize_scale(ConvertDetails {
+                                from: quantity.scale,
+                                to: engine_scale,
+                            }))
+                            .and_then(
+                                move |scaled_connector_amount| {
+                                    let diff: BigUint = engine_amount - scaled_connector_amount;
+                                    if diff > Zero::zero() {
+                                        // connector settled less than we
+                                        // instructed it to, so we must save
+                                        // the difference for the leftovers
+                                        Either::A(store.save_leftovers(account_id, diff))
+                                    } else {
+                                        Either::B(ok(()))
+                                    }
+                                },
+                            )
                         })
-                    })
                 }),
         )
     }
@@ -689,7 +705,12 @@ where
 
 impl<S, Si, A> SettlementEngine for EthereumLedgerSettlementEngine<S, Si, A>
 where
-    S: EthereumStore<Account = A> + Clone + Send + Sync + 'static,
+    S: EthereumStore<Account = A>
+        + LeftoversStore<AssetType = BigUint>
+        + Clone
+        + Send
+        + Sync
+        + 'static,
     Si: EthereumLedgerTxSigner + Clone + Send + Sync + 'static,
     A: EthereumAccount + Send + Sync + 'static,
 {

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

@@ -68,17 +68,22 @@ use crate::stores::LeftoversStore;
 use num_bigint::BigUint;
 
 impl LeftoversStore for TestStore {
+    type AssetType = BigUint;
+
     fn save_leftovers(
         &self,
         account_id: String,
-        leftovers: BigUint,
+        leftovers: Self::AssetType,
     ) -> Box<Future<Item = (), Error = ()> + Send> {
         let mut guard = self.leftovers.write();
         (*guard).insert(account_id, leftovers);
         Box::new(ok(()))
     }
 
-    fn load_leftovers(&self, account_id: String) -> Box<Future<Item = BigUint, Error = ()> + Send> {
+    fn load_leftovers(
+        &self,
+        account_id: String,
+    ) -> Box<Future<Item = Self::AssetType, Error = ()> + Send> {
         let guard = self.leftovers.read();
         if let Some(l) = guard.get(&account_id) {
             Box::new(ok(l.clone()))
@@ -261,6 +266,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())),
         }
     }
 }
@@ -288,7 +294,13 @@ pub fn test_engine<Si, S, A>(
 ) -> EthereumLedgerSettlementEngine<S, Si, A>
 where
     Si: EthereumLedgerTxSigner + Clone + Send + Sync + 'static,
-    S: EthereumStore<Account = A> + IdempotentStore + Clone + Send + Sync + 'static,
+    S: EthereumStore<Account = A>
+        + LeftoversStore<AssetType = BigUint>
+        + IdempotentStore
+        + Clone
+        + Send
+        + Sync
+        + 'static,
     A: EthereumAccount + Send + Sync + 'static,
 {
     EthereumLedgerSettlementEngineBuilder::new(store, key)

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

@@ -30,16 +30,18 @@ pub trait IdempotentEngineStore {
 }
 
 pub trait LeftoversStore {
+    type AssetType;
+
     /// Saves the leftover data
     fn save_leftovers(
         &self,
         account_id: String,
-        leftovers: BigUint,
+        leftovers: Self::AssetType,
     ) -> Box<dyn Future<Item = (), Error = ()> + Send>;
 
     /// Saves the leftover data
     fn load_leftovers(
         &self,
         account_id: String,
-    ) -> Box<dyn Future<Item = BigUint, Error = ()> + Send>;
+    ) -> Box<dyn Future<Item = Self::AssetType, Error = ()> + Send>;
 }

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

@@ -14,6 +14,8 @@ use redis::{self, cmd, r#async::SharedConnection, ConnectionInfo, PipelineComman
 use log::{error, trace};
 
 use crate::stores::redis_store_common::{EngineRedisStore, EngineRedisStoreBuilder};
+use crate::stores::LeftoversStore;
+use num_bigint::BigUint;
 
 // Key for the latest observed block and balance. The data is stored in order to
 // avoid double crediting transactions which have already been processed, and in
@@ -107,10 +109,12 @@ impl EthereumLedgerRedisStore {
 }
 
 impl LeftoversStore for EthereumLedgerRedisStore {
+    type AssetType = BigUint;
+
     fn save_leftovers(
         &self,
         account_id: String,
-        leftovers: BigUint,
+        leftovers: Self::AssetType,
     ) -> Box<dyn Future<Item = (), Error = ()> + Send> {
         let mut pipe = redis::pipe();
         pipe.set(format!("leftovers:{}", account_id), leftovers.to_string())
@@ -125,10 +129,9 @@ impl LeftoversStore for EthereumLedgerRedisStore {
     fn load_leftovers(
         &self,
         account_id: String,
-    ) -> Box<dyn Future<Item = BigUint, Error = ()> + Send> {
+    ) -> Box<dyn Future<Item = Self::AssetType, Error = ()> + Send> {
         let mut pipe = redis::pipe();
-        pipe.get(format!("leftovers:{}", account_id))
-            .ignore();
+        pipe.get(format!("leftovers:{}", account_id)).ignore();
         Box::new(
             pipe.query_async(self.connection.clone())
                 .map_err(move |err| error!("Error loading leftovers {:?}: ", err))
@@ -138,7 +141,7 @@ impl LeftoversStore for EthereumLedgerRedisStore {
                     } else {
                         Box::new(err(()))
                     }
-                })
+                }),
         )
     }
 }