[xrpl_sdk_ws] Add support for book subscriptions

Author: gmosx

xrpl_api/src/api/book_offers.rs

@@ -1,39 +1,8 @@
 use serde::{Deserialize, Serialize};
-use xrpl_types::{Currency, Offer};
+use xrpl_types::{Currency, CurrencySpec, Offer};
 
 use crate::Request;
 
-#[derive(Clone, Serialize)]
-pub struct CurrencyParams {
-    pub currency: String, // TODO: hm, consider name.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub issuer: Option<String>,
-}
-
-impl Default for CurrencyParams {
-    fn default() -> Self {
-        Self {
-            currency: "XRP".to_string(),
-            issuer: None,
-        }
-    }
-}
-
-impl CurrencyParams {
-    pub fn from_currency(c: &Currency) -> Self {
-        match c {
-            Currency::Xrp => CurrencyParams {
-                currency: "XRP".to_owned(),
-                issuer: None,
-            },
-            Currency::Issued { name, issuer } => CurrencyParams {
-                currency: name.clone(),
-                issuer: Some(issuer.clone()),
-            },
-        }
-    }
-}
-
 /// - https://xrpl.org/book_offers.html
 #[derive(Default, Clone, Serialize)]
 pub struct BookOffersRequest {
@@ -45,8 +14,8 @@ pub struct BookOffersRequest {
     limit: Option<u32>,
     #[serde(skip_serializing_if = "Option::is_none")]
     taker: Option<String>,
-    taker_gets: CurrencyParams,
-    taker_pays: CurrencyParams,
+    taker_gets: CurrencySpec,
+    taker_pays: CurrencySpec,
 }
 
 impl Request for BookOffersRequest {
@@ -60,8 +29,8 @@ impl Request for BookOffersRequest {
 impl BookOffersRequest {
     pub fn new(taker_gets: &Currency, taker_pays: &Currency) -> Self {
         Self {
-            taker_gets: CurrencyParams::from_currency(taker_gets),
-            taker_pays: CurrencyParams::from_currency(taker_pays),
+            taker_gets: CurrencySpec::from_currency(taker_gets),
+            taker_pays: CurrencySpec::from_currency(taker_pays),
             ..Default::default()
         }
     }

xrpl_api/src/api/subscribe.rs

@@ -5,6 +5,7 @@
 
 use crate::Request;
 use serde::{Deserialize, Serialize};
+use xrpl_types::Book;
 
 #[derive(Default, Clone, Serialize)]
 pub struct SubscribeRequest {
@@ -13,6 +14,8 @@ pub struct SubscribeRequest {
     #[serde(skip_serializing_if = "Option::is_none")]
     accounts: Option<Vec<String>>,
     #[serde(skip_serializing_if = "Option::is_none")]
+    books: Option<Vec<Book>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     url: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     url_username: Option<String>,
@@ -33,6 +36,9 @@ impl SubscribeRequest {
         Self::default()
     }
 
+    /// The ledger stream only sends ledgerClosed messages when the consensus
+    /// process declares a new validated ledger. The message identifies the
+    /// ledger and provides some information about its contents.
     pub fn streams(streams: &[&str]) -> Self {
         let streams = streams.iter().map(|s| s.to_string()).collect();
         Self {
@@ -48,6 +54,15 @@ impl SubscribeRequest {
             ..Default::default()
         }
     }
+
+    /// When you subscribe to one or more order books with the books field, you
+    /// get back any transactions that affect those order books.
+    pub fn books(books: &[Book]) -> Self {
+        Self {
+            books: Some(books.to_vec()),
+            ..Default::default()
+        }
+    }
 }
 
 #[derive(Debug, Deserialize)]

xrpl_sdk_ws/src/client_tests.rs

@@ -4,6 +4,8 @@ mod tests {
     use crate::client::DEFAULT_WS_URL;
     use futures_util::StreamExt;
     use xrpl_api::{AccountInfoRequest, SubscribeRequest};
+    use xrpl_types::Book;
+    use xrpl_types::Currency;
 
     #[tokio::test]
     async fn client_can_request_account_info() {
@@ -40,4 +42,32 @@ mod tests {
             count += 1;
         }
     }
+
+    #[tokio::test]
+    async fn client_can_subscribe_to_books() {
+        let mut client = Client::connect(DEFAULT_WS_URL)
+            .await
+            .expect("cannot connect");
+
+        let book = Book::new(
+            &Currency::Xrp,
+            &Currency::issued("USD", "rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B"),
+            "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
+        )
+        .snapshot(true);
+
+        let req = SubscribeRequest::books(&[book]);
+
+        client.call(req).await.expect("cannot subscribe");
+
+        let mut count = 0;
+
+        while let Some(msg) = client.messages.next().await {
+            if count > 5 {
+                break;
+            }
+            dbg!(&msg);
+            count += 1;
+        }
+    }
 }

xrpl_types/src/book.rs

@@ -0,0 +1,44 @@
+use crate::{Currency, CurrencySpec};
+use serde::Serialize;
+
+/// A book on the ledger.
+#[derive(Default, Debug, Clone, Serialize)]
+pub struct Book {
+    /// Specification of which currency the account taking the Offer would pay.
+    pub taker_gets: CurrencySpec,
+    /// Specification of which currency the account taking the Offer would receive.
+    pub taker_pays: CurrencySpec,
+    /// Unique account address to use as a perspective for viewing offers, in the XRP Ledger's base58 format.
+    pub taker: String,
+    /// If true, return the current state of the order book once when you subscribe before sending updates.
+    /// The default is false.
+    pub snapshot: Option<bool>,
+    /// If true, return both sides of the order book. The default is false.
+    pub both: Option<bool>,
+}
+
+impl Book {
+    pub fn new(taker_gets: &Currency, taker_pays: &Currency, taker: &str) -> Self {
+        Self {
+            taker_gets: CurrencySpec::from_currency(taker_gets),
+            taker_pays: CurrencySpec::from_currency(taker_pays),
+            taker: taker.to_owned(),
+            snapshot: None,
+            both: None,
+        }
+    }
+
+    pub fn snapshot(self, snapshot: bool) -> Self {
+        Self {
+            snapshot: Some(snapshot),
+            ..self
+        }
+    }
+
+    pub fn both(self, both: bool) -> Self {
+        Self {
+            both: Some(both),
+            ..self
+        }
+    }
+}

xrpl_types/src/currency.rs

@@ -37,3 +37,36 @@ impl Currency {
         !self.is_xrp()
     }
 }
+
+// #TODO implement from/into.
+/// Currency specification for books.
+#[derive(Debug, Clone, Serialize)]
+pub struct CurrencySpec {
+    pub currency: String, // TODO: hm, consider name.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub issuer: Option<String>,
+}
+
+impl Default for CurrencySpec {
+    fn default() -> Self {
+        Self {
+            currency: "XRP".to_string(),
+            issuer: None,
+        }
+    }
+}
+
+impl CurrencySpec {
+    pub fn from_currency(c: &Currency) -> Self {
+        match c {
+            Currency::Xrp => CurrencySpec {
+                currency: "XRP".to_owned(),
+                issuer: None,
+            },
+            Currency::Issued { name, issuer } => CurrencySpec {
+                currency: name.clone(),
+                issuer: Some(issuer.clone()),
+            },
+        }
+    }
+}

xrpl_types/src/lib.rs

@@ -3,12 +3,14 @@
 
 pub mod account;
 pub mod amount;
+pub mod book;
 pub mod currency;
 pub mod offer;
 pub mod transaction;
 
 pub use account::*;
 pub use amount::*;
+pub use book::*;
 pub use currency::*;
 pub use offer::*;
 pub use transaction::*;