Preliminary work on ripple_path_find

Author: gmosx

xrpl_api/src/api.rs

@@ -66,6 +66,12 @@ pub use nft_buy_offers::*;
 pub mod nft_sell_offers;
 pub use nft_sell_offers::*;
 
+pub mod path_find;
+pub use path_find::*;
+
+pub mod ripple_path_find;
+pub use ripple_path_find::*;
+
 // Server Info methods
 
 pub mod fee;

xrpl_api/src/api/path_find.rs

@@ -0,0 +1,17 @@
+//! WebSocket API only! The path_find method searches for a path along which a
+//! transaction can possibly be made, and periodically sends updates when the
+//! path changes over time. For a simpler version that is supported by
+//! JSON-RPC, see the ripple_path_find method. For payments occurring strictly
+//! in XRP, it is not necessary to find a path, because XRP can be sent
+//! directly to any account.
+//!
+//! There are three different modes, or sub-commands, of the path_find command.
+//! Specify which one you want with the subcommand parameter:
+//!
+//! create - Start sending pathfinding information
+//! close - Stop sending pathfinding information
+//! status - Get the information of the currently-open pathfinding request
+//!
+//! - https://xrpl.org/path_find.html
+
+// #TODO

xrpl_api/src/api/ripple_path_find.rs

@@ -0,0 +1,84 @@
+//! The ripple_path_find method is a simplified version of the path_find method
+//! that provides a single response with a payment path you can use right away.
+//! It is available in both the WebSocket and JSON-RPC APIs. However, the
+//! results tend to become outdated as time passes. Instead of making multiple
+//! calls to stay updated, you should instead use the path_find method to
+//! subscribe to continued updates where possible.
+//!
+//! Although the rippled server tries to find the cheapest path or combination
+//! of paths for making a payment, it is not guaranteed that the paths
+//! returned by this method are, in fact, the best paths.
+//!
+//! - https://xrpl.org/ripple_path_find.html
+//! - https://xrpl.org/paths.html
+
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use xrpl_types::Amount;
+
+use crate::Request;
+
+// #TODO is Clone really needed?
+#[derive(Default, Clone, Serialize)]
+pub struct RipplePathFindRequest {
+    /// Unique address of the account that would send funds in a transaction.
+    source_account: String,
+    /// Unique address of the account that would receive funds in a transaction.
+    destination_account: String,
+    /// Currency Amount that the destination account would receive in a
+    /// transaction. Special case: New in: rippled 0.30.0  You can specify "-1"
+    /// (for XRP) or provide -1 as the contents of the value field
+    /// (for non-XRP currencies). This requests a path to deliver as much as
+    /// possible, while spending no more than the amount specified in
+    /// send_max (if provided).
+    destination_amount: Amount,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    send_max: Option<Amount>,
+    /// A 20-byte hex string for the ledger version to use.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ledger_hash: Option<String>,
+    /// The ledger index of the ledger to use, or a shortcut string to choose a
+    /// ledger automatically.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub ledger_index: Option<String>,
+}
+
+impl Request for RipplePathFindRequest {
+    type Response = RipplePathFindResponse;
+
+    fn method(&self) -> String {
+        "ripple_path_find".to_owned()
+    }
+}
+
+impl RipplePathFindRequest {
+    pub fn new(
+        source_account: &str,
+        destination_account: &str,
+        destination_amount: Amount,
+    ) -> Self {
+        Self {
+            source_account: source_account.to_owned(),
+            destination_account: destination_account.to_owned(),
+            destination_amount,
+            ..Default::default()
+        }
+    }
+}
+
+#[derive(Debug, Deserialize)]
+pub struct Path {
+    // #TODO full types missing
+    /// Array of arrays of objects defining payment paths.
+    pub paths_computed: Vec<Vec<Value>>,
+    /// Currency Amount that the source would have to send along this path for
+    /// the destination to receive the desired amount.
+    pub source_amount: Amount,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct RipplePathFindResponse {
+    pub alternatives: Vec<Path>,
+    pub destination_account: String,
+    pub destination_currencies: Vec<String>,
+}

xrpl_sdk_jsonrpc/src/client.rs

@@ -102,6 +102,7 @@ impl Client {
 
         let body = serde_json::to_string(&request)?;
 
+        // dbg!(&body);
         debug!("POST {}", body);
 
         let response = self
@@ -125,6 +126,7 @@ impl Client {
             let status = body["result"]["status"].as_str().unwrap_or("error");
 
             if status == "error" {
+                // dbg!(&body);
                 debug!("{}", body);
 
                 return Err(Error::Api(

xrpl_sdk_jsonrpc/src/client_tests.rs

@@ -1,15 +1,19 @@
 #[cfg(test)]
 mod tests {
-    use crate::client::{Client, NFT_DEVNET_URL};
+    use crate::{
+        client::{Client, NFT_DEVNET_URL},
+        error::Error,
+    };
     use xrpl_api::{
         AccountChannelsRequest, AccountCurrenciesRequest, AccountInfoRequest, AccountLinesRequest,
         AccountNftsRequest, AccountOffersRequest, AccountTxRequest, BookOffersRequest,
         DepositAuthorizedRequest, FeeRequest, GatewayBalancesRequest, GetOfferObjectRequest,
         LedgerClosedRequest, LedgerCurrentRequest, LedgerDataRequest, LedgerEntryRequest,
         ManifestRequest, NftBuyOffersRequest, NftSellOffersRequest, PingRequest, RandomRequest,
-        ServerInfoRequest, ServerStateRequest, TransactionEntryRequest, TxRequest,
+        RipplePathFindRequest, ServerInfoRequest, ServerStateRequest, TransactionEntryRequest,
+        TxRequest,
     };
-    use xrpl_types::Currency;
+    use xrpl_types::{Amount, Currency};
 
     #[tokio::test]
     async fn client_can_fetch_account_currencies() {
@@ -220,6 +224,24 @@ mod tests {
         assert_eq!(resp.nft_id, nft_id);
     }
 
+    #[tokio::test]
+    async fn client_can_find_a_payment_path() {
+        let client = Client::default();
+
+        let resp = client
+            .call(RipplePathFindRequest::new(
+                "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
+                "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59",
+                Amount::issued("0.001", "USD", "rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B"),
+            ))
+            .await;
+
+        let resp = resp;
+
+        // #TODO investigate why the server returns notSupported?
+        assert!(matches!(resp, Err(Error::Api(s)) if s == "notSupported"));
+    }
+
     #[tokio::test]
     async fn client_can_fetch_transaction_entries() {
         let client = Client::default();

xrpl_types/src/amount.rs

@@ -2,7 +2,7 @@ use crate::Currency;
 use serde::{Deserialize, Serialize};
 
 /// https://xrpl.org/serialization.html#amount-fields
-#[derive(Debug, Eq, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Eq, PartialEq, Serialize, Deserialize, Clone)]
 #[serde(untagged)]
 pub enum Amount {
     Issued {
@@ -13,6 +13,12 @@ pub enum Amount {
     Drops(String),
 }
 
+impl Default for Amount {
+    fn default() -> Self {
+        Amount::drops(0)
+    }
+}
+
 impl Amount {
     pub fn issued(value: &str, currency: &str, issuer: &str) -> Self {
         Self::Issued {