feat(settlement): Connector returns the amount & account scale for incoming settlements

Author: gakonst

crates/interledger-settlement/src/api.rs

@@ -15,6 +15,7 @@ use log::{debug, error};
 use num_bigint::BigUint;
 use num_traits::cast::ToPrimitive;
 use ring::digest::{digest, SHA256};
+use serde_json::json;
 use std::{
     marker::PhantomData,
     str::{self, FromStr},
@@ -204,9 +205,8 @@ impl_web! {
                         (StatusCode::from_u16(500).unwrap(), error_msg)
                     })
                     .and_then(move |_| {
-                        // TODO: Return a Quantity of safe_amount and account.asset_scale()
-                        let ret = Bytes::from("Success");
-                        Ok((StatusCode::OK, ret))
+                        let ret = json!(Quantity::new(safe_amount, account.asset_scale()));
+                        Ok((StatusCode::OK, ret.to_string().into()))
                     })
                 })
             }))
@@ -315,31 +315,72 @@ mod tests {
     mod settlement_tests {
         use super::*;
 
+        #[test]
+        fn handle_overflow() {
+            // if upscaling would overflow, return u64::MAX
+            let id = TEST_ACCOUNT_0.clone().id.to_string();
+            let store = test_store(false, true);
+            let api = test_api(store.clone(), false);
+            let overflow_quantity = Quantity::new("200000000000", 1);
+            let ret: Response<_> = api
+                .receive_settlement(id.clone(), overflow_quantity, None)
+                .wait()
+                .unwrap();
+            let q: Quantity = serde_json::from_slice(ret.body()).unwrap();
+            assert_eq!(ret.status(), 200);
+            assert_eq!(q.amount, std::u64::MAX.to_string());
+            assert_eq!(q.scale, 9);
+        }
+
+        #[test]
+        fn handle_precision_loss() {
+            // 2 least significant digits get lost
+            let id = TEST_ACCOUNT_0.clone().id.to_string();
+            let store = test_store(false, true);
+            let api = test_api(store.clone(), false);
+            let precision_loss_quantity = Quantity::new(123, 11);
+            let ret: Response<_> = api
+                .receive_settlement(id.clone(), precision_loss_quantity, None)
+                .wait()
+                .unwrap();
+            let q: Quantity = serde_json::from_slice(ret.body()).unwrap();
+            assert_eq!(ret.status(), 200);
+            assert_eq!(q.amount, 1.to_string());
+            let leftovers = 123 - 1.normalize_scale(ConvertDetails { from: 9, to: 11 });
+            assert_eq!(leftovers, 23);
+            assert_eq!(q.scale, 9);
+        }
+
         #[test]
         fn settlement_ok() {
             let id = TEST_ACCOUNT_0.clone().id.to_string();
             let store = test_store(false, true);
             let api = test_api(store.clone(), false);
 
+            let quantity1 = Quantity::new("200000000000", 18);
+
             let ret: Response<_> = api
-                .receive_settlement(id.clone(), Quantity::new(200, 18), IDEMPOTENCY.clone())
+                .receive_settlement(id.clone(), quantity1.clone(), IDEMPOTENCY.clone())
                 .wait()
                 .unwrap();
+            let q: Quantity = serde_json::from_slice(ret.body()).unwrap();
             assert_eq!(ret.status(), 200);
-            assert_eq!(ret.body(), "Success");
+            assert_eq!(q.amount, "200");
+            assert_eq!(q.scale, 9);
 
             // check that it's idempotent
             let ret: Response<_> = api
-                .receive_settlement(id.clone(), Quantity::new(200, 18), IDEMPOTENCY.clone())
+                .receive_settlement(id.clone(), quantity1.clone(), IDEMPOTENCY.clone())
                 .wait()
                 .unwrap();
             assert_eq!(ret.status(), 200);
-            assert_eq!(ret.body(), "Success");
+            assert_eq!(q.amount, "200");
+            assert_eq!(q.scale, 9);
 
             // fails with different account id
             let id2 = "2".to_string();
             let ret: Response<_> = api
-                .receive_settlement(id2.clone(), Quantity::new(200, 18), IDEMPOTENCY.clone())
+                .receive_settlement(id2.clone(), quantity1.clone(), IDEMPOTENCY.clone())
                 .wait()
                 .unwrap_err();
             assert_eq!(ret.status(), StatusCode::from_u16(409).unwrap());
@@ -377,7 +418,10 @@ mod tests {
             let cache_hits = s.cache_hits.read();
             assert_eq!(*cache_hits, 4);
             assert_eq!(cached_data.0, StatusCode::OK);
-            assert_eq!(cached_data.1, &Bytes::from("Success"));
+            assert_eq!(
+                cached_data.1,
+                Bytes::from(json!(Quantity::new("200", 9)).to_string())
+            );
         }
 
         #[test]