Settlement Engine API interop updates (#183)

* fix(engines): make CreateAccount endpoint accept the id as a json body parameter

* fix(settlement): Make Connector's receive_money endpoint accept a String instead of u64 for amount.

The number is only ever converted to a u64 before scale conversion and input to the store.
The client also converts it to a string before submitting to the engine

* fix(engines): use the Quantity struct exposed from the Settlements API
When sending money we convert the received string to a U256
When receiving money we convert the received U256 to a string

* feat(eth-se): configure asset_scale via CLI

Author: gakonst

crates/interledger-api/src/routes/accounts.rs

@@ -85,15 +85,15 @@ impl_web! {
                             se_url
                                 .path_segments_mut()
                                 .expect("Invalid settlement engine URL")
-                                .push("accounts")
-                                .push(&id.to_string());
+                                .push("accounts");
                             trace!(
                                 "Sending account {} creation request to settlement engine: {:?}",
                                 id,
                                 se_url.clone()
                             );
                             let action = move || {
                                 Client::new().post(se_url.clone())
+                                .json(&json!({"id" : id.to_string()}))
                                 .send()
                                 .map_err(move |err| {
                                     error!("Error sending account creation command to the settlement engine: {:?}", err)

crates/interledger-settlement-engines/src/api.rs

@@ -1,12 +1,11 @@
-use crate::ApiResponse;
-use crate::Quantity;
-use crate::SettlementEngine;
+use crate::{ApiResponse, CreateAccount, SettlementEngine};
 use bytes::Bytes;
 use futures::{
     future::{err, ok, Either},
     Future,
 };
 use hyper::{Response, StatusCode};
+use interledger_settlement::Quantity;
 use interledger_settlement::{IdempotentData, IdempotentStore};
 use log::error;
 use ring::digest::{digest, SHA256};
@@ -60,13 +59,14 @@ impl_web! {
             self.make_idempotent_call(f, input_hash, idempotency_key)
         }
 
-        #[post("/accounts/:account_id")]
+        #[post("/accounts")]
         /// Forwards the data to the API engine's `create_account` function.
-        /// Endpoint: POST /accounts/:id/
-        fn create_account(&self, account_id: String, idempotency_key: Option<String>) -> impl Future<Item = Response<String>, Error = Response<String>> {
-            let input_hash = get_hash_of(account_id.as_ref());
+        /// Endpoint: POST /accounts/
+        fn create_account(&self, body: CreateAccount, idempotency_key: Option<String>) -> impl Future<Item = Response<String>, Error = Response<String>> {
+            let input = format!("{:?}", body);
+            let input_hash = get_hash_of(input.as_ref());
             let engine = self.engine.clone();
-            let f = move || engine.create_account(account_id);
+            let f = move || engine.create_account(body);
             self.make_idempotent_call(f, input_hash, idempotency_key)
         }
 
@@ -214,7 +214,7 @@ mod tests {
 
         fn create_account(
             &self,
-            _account_id: String,
+            _account_id: CreateAccount,
         ) -> Box<dyn Future<Item = ApiResponse, Error = ApiResponse> + Send> {
             Box::new(ok((
                 StatusCode::from_u16(201).unwrap(),
@@ -234,7 +234,7 @@ mod tests {
 
         let ret: Response<_> = block_on(api.execute_settlement(
             "1".to_owned(),
-            Quantity { amount: 100 },
+            Quantity::new(100, 6),
             Some(IDEMPOTENCY.clone()),
         ))
         .unwrap();
@@ -244,7 +244,7 @@ mod tests {
         // is idempotent
         let ret: Response<_> = block_on(api.execute_settlement(
             "1".to_owned(),
-            Quantity { amount: 100 },
+            Quantity::new(100, 6),
             Some(IDEMPOTENCY.clone()),
         ))
         .unwrap();
@@ -254,7 +254,7 @@ mod tests {
         // // fails with different id and same data
         let ret: Response<_> = block_on(api.execute_settlement(
             "42".to_owned(),
-            Quantity { amount: 100 },
+            Quantity::new(100, 6),
             Some(IDEMPOTENCY.clone()),
         ))
         .unwrap_err();
@@ -267,7 +267,7 @@ mod tests {
         // fails with same id and different data
         let ret: Response<_> = block_on(api.execute_settlement(
             "1".to_string(),
-            Quantity { amount: 42 },
+            Quantity::new(42, 6),
             Some(IDEMPOTENCY.clone()),
         ))
         .unwrap_err();
@@ -280,7 +280,7 @@ mod tests {
         // fails with different id and different data
         let ret: Response<_> = block_on(api.execute_settlement(
             "42".to_string(),
-            Quantity { amount: 42 },
+            Quantity::new(42, 6),
             Some(IDEMPOTENCY.clone()),
         ))
         .unwrap_err();
@@ -370,19 +370,22 @@ mod tests {
         };
 
         let ret: Response<_> =
-            block_on(api.create_account("1".to_owned(), Some(IDEMPOTENCY.clone()))).unwrap();
+            block_on(api.create_account(CreateAccount::new("1"), Some(IDEMPOTENCY.clone())))
+                .unwrap();
         assert_eq!(ret.status().as_u16(), 201);
         assert_eq!(ret.body(), "CREATED");
 
         // is idempotent
         let ret: Response<_> =
-            block_on(api.create_account("1".to_owned(), Some(IDEMPOTENCY.clone()))).unwrap();
+            block_on(api.create_account(CreateAccount::new("1"), Some(IDEMPOTENCY.clone())))
+                .unwrap();
         assert_eq!(ret.status().as_u16(), 201);
         assert_eq!(ret.body(), "CREATED");
 
         // fails with different id
         let ret: Response<_> =
-            block_on(api.create_account("42".to_owned(), Some(IDEMPOTENCY.clone()))).unwrap_err();
+            block_on(api.create_account(CreateAccount::new("42"), Some(IDEMPOTENCY.clone())))
+                .unwrap_err();
         assert_eq!(ret.status().as_u16(), 409);
         assert_eq!(
             ret.body(),

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

@@ -34,8 +34,8 @@ use url::Url;
 use uuid::Uuid;
 
 use crate::stores::redis_ethereum_ledger::*;
-
-use crate::{ApiResponse, Quantity, SettlementEngine, SettlementEngineApi};
+use crate::{ApiResponse, CreateAccount, SettlementEngine, SettlementEngineApi};
+use interledger_settlement::Quantity;
 
 const MAX_RETRIES: usize = 10;
 const ETH_CREATE_ACCOUNT_PREFIX: &[u8] = b"ilp-ethl-create-account-message";
@@ -78,6 +78,7 @@ pub struct EthereumLedgerSettlementEngine<S, Si, A> {
     confirmations: u8,
     poll_frequency: Duration,
     connector_url: Url,
+    asset_scale: u8,
 }
 
 pub struct EthereumLedgerSettlementEngineBuilder<'a, S, Si, A> {
@@ -91,6 +92,7 @@ pub struct EthereumLedgerSettlementEngineBuilder<'a, S, Si, A> {
     poll_frequency: Option<Duration>,
     connector_url: Option<Url>,
     token_address: Option<Address>,
+    asset_scale: Option<u8>,
     watch_incoming: bool,
     account_type: PhantomData<A>,
 }
@@ -111,6 +113,7 @@ where
             poll_frequency: None,
             connector_url: None,
             token_address: None,
+            asset_scale: None,
             watch_incoming: false,
             account_type: PhantomData,
         }
@@ -126,6 +129,11 @@ where
         self
     }
 
+    pub fn asset_scale(&mut self, asset_scale: u8) -> &mut Self {
+        self.asset_scale = Some(asset_scale);
+        self
+    }
+
     pub fn chain_id(&mut self, chain_id: u8) -> &mut Self {
         self.chain_id = Some(chain_id);
         self
@@ -178,6 +186,11 @@ where
         } else {
             Duration::from_secs(5)
         };
+        let asset_scale = if let Some(asset_scale) = self.asset_scale {
+            asset_scale
+        } else {
+            18
+        };
 
         let (eloop, transport) = Http::new(ethereum_endpoint).unwrap();
         eloop.into_remote();
@@ -196,6 +209,7 @@ where
             confirmations,
             poll_frequency,
             connector_url,
+            asset_scale,
             account_type: PhantomData,
         };
         if self.watch_incoming {
@@ -355,11 +369,7 @@ where
                         store
                             .load_account_id_from_address(addr)
                             .and_then(move |id| {
-                                self_clone.notify_connector(
-                                    id.to_string(),
-                                    amount.low_u64(),
-                                    tx_hash,
-                                )
+                                self_clone.notify_connector(id.to_string(), amount, tx_hash)
                             })
                             .and_then(move |_| {
                                 // only save the transaction hash if the connector
@@ -442,7 +452,7 @@ where
                         Either::A(
                         store.load_account_id_from_address(addr)
                         .and_then(move |id| {
-                            self_clone.notify_connector(id.to_string(), amount.low_u64(), tx_hash)
+                            self_clone.notify_connector(id.to_string(), amount, tx_hash)
                         })
                         .and_then(move |_| {
                             // only save the transaction hash if the connector
@@ -463,11 +473,12 @@ where
     fn notify_connector(
         &self,
         account_id: String,
-        amount: u64,
+        amount: U256,
         tx_hash: H256,
     ) -> impl Future<Item = (), Error = ()> {
         let mut url = self.connector_url.clone();
         let account_id_clone = account_id.clone();
+        let asset_scale = self.asset_scale;
         url.path_segments_mut()
             .expect("Invalid connector URL")
             .push("accounts")
@@ -480,7 +491,7 @@ where
             client
                 .post(url.clone())
                 .header("Idempotency-Key", tx_hash.to_string())
-                .json(&json!({ "amount": amount }))
+                .json(&json!({ "amount": amount.to_string(), "scale" : asset_scale }))
                 .send()
                 .map_err(move |err| {
                     error!(
@@ -611,10 +622,11 @@ where
     /// the store.
     fn create_account(
         &self,
-        account_id: String,
+        account_id: CreateAccount,
     ) -> Box<dyn Future<Item = ApiResponse, Error = ApiResponse> + Send> {
         let self_clone = self.clone();
         let store: S = self.store.clone();
+        let account_id = account_id.id;
 
         Box::new(
             result(A::AccountId::from_str(&account_id).map_err({
@@ -741,27 +753,32 @@ where
         account_id: String,
         body: Quantity,
     ) -> Box<dyn Future<Item = ApiResponse, Error = ApiResponse> + Send> {
-        let amount = U256::from(body.amount);
         let self_clone = self.clone();
-
         Box::new(
-            self_clone
-                .load_account(account_id)
-                .map_err(move |err| {
-                    let error_msg = format!("Error loading account {:?}", err);
-                    error!("{}", error_msg);
-                    (StatusCode::from_u16(400).unwrap(), error_msg)
-                })
-                .and_then(move |(_account_id, addresses)| {
-                    self_clone
-                        .settle_to(addresses.own_address, amount, addresses.token_address)
-                        .map_err(move |_| {
-                            let error_msg = "Error connecting to the blockchain.".to_string();
-                            error!("{}", error_msg);
-                            (StatusCode::from_u16(502).unwrap(), error_msg)
-                        })
-                })
-                .and_then(move |_| Ok((StatusCode::OK, "OK".to_string()))),
+            result(U256::from_dec_str(&body.amount).map_err(move |err| {
+                let error_msg = format!("Error converting to U256 {:?}", err);
+                error!("{:?}", error_msg);
+                (StatusCode::from_u16(400).unwrap(), error_msg)
+            }))
+            .and_then(move |amount| {
+                self_clone
+                    .load_account(account_id)
+                    .map_err(move |err| {
+                        let error_msg = format!("Error loading account {:?}", err);
+                        error!("{}", error_msg);
+                        (StatusCode::from_u16(400).unwrap(), error_msg)
+                    })
+                    .and_then(move |(_account_id, addresses)| {
+                        self_clone
+                            .settle_to(addresses.own_address, amount, addresses.token_address)
+                            .map_err(move |_| {
+                                let error_msg = "Error connecting to the blockchain.".to_string();
+                                error!("{}", error_msg);
+                                (StatusCode::from_u16(502).unwrap(), error_msg)
+                            })
+                    })
+                    .and_then(move |_| Ok((StatusCode::OK, "OK".to_string())))
+            }),
         )
     }
 }
@@ -804,6 +821,7 @@ pub fn run_ethereum_engine<R, Si>(
     private_key: Si,
     chain_id: u8,
     confirmations: u8,
+    asset_scale: u8,
     poll_frequency: u64,
     connector_url: String,
     token_address: Option<Address>,
@@ -824,6 +842,7 @@ where
                 .chain_id(chain_id)
                 .connector_url(&connector_url)
                 .confirmations(confirmations)
+                .asset_scale(asset_scale)
                 .poll_frequency(poll_frequency)
                 .watch_incoming(watch_incoming)
                 .token_address(token_address)
@@ -907,7 +926,7 @@ mod tests {
 
         let bob_mock = mockito::mock("POST", "/accounts/42/settlements")
             .match_body(mockito::Matcher::JsonString(
-                "{\"amount\": 100 }".to_string(),
+                "{\"amount\": \"100\", \"scale\": 18 }".to_string(),
             ))
             .with_status(200)
             .with_body("OK".to_string())
@@ -930,8 +949,8 @@ mod tests {
             false, // alice sends the transaction to bob (set it up so that she doesn't listen for inc txs)
         );
 
-        let ret = block_on(alice_engine.send_money(bob.id.to_string(), Quantity { amount: 100 }))
-            .unwrap();
+        let ret =
+            block_on(alice_engine.send_money(bob.id.to_string(), Quantity::new(100, 6))).unwrap();
         assert_eq!(ret.0.as_u16(), 200);
         assert_eq!(ret.1, "OK");
 
@@ -974,7 +993,7 @@ mod tests {
 
         // the signed message does not match. We are not able to make Mockito
         // capture the challenge and return a signature on it.
-        let ret = block_on(engine.create_account(bob.id.to_string())).unwrap_err();
+        let ret = block_on(engine.create_account(CreateAccount::new(bob.id))).unwrap_err();
         assert_eq!(ret.0.as_u16(), 502);
         // assert_eq!(ret.1, "CREATED");
 

crates/interledger-settlement-engines/src/lib.rs

@@ -20,12 +20,19 @@ pub mod engines;
 pub mod stores;
 pub use self::api::SettlementEngineApi;
 
-#[derive(Extract, Debug, Clone, Copy)]
-pub struct Quantity {
-    amount: u64,
+#[derive(Extract, Debug, Clone, Hash)]
+pub struct CreateAccount {
+    id: String,
+}
+
+impl CreateAccount {
+    pub fn new<T: ToString>(id: T) -> Self {
+        CreateAccount { id: id.to_string() }
+    }
 }
 
 use http::StatusCode;
+use interledger_settlement::Quantity;
 
 pub type ApiResponse = (StatusCode, String);
 
@@ -46,6 +53,6 @@ pub trait SettlementEngine {
 
     fn create_account(
         &self,
-        account_id: String,
+        account_id: CreateAccount,
     ) -> Box<dyn Future<Item = ApiResponse, Error = ApiResponse> + Send>;
 }