Merge pull request #84 from sephynox/wallet-generation

Wallet generation

Cargo.toml

@@ -113,9 +113,15 @@ transactions = ["core", "amounts", "currencies"]
 requests = ["core", "amounts", "currencies"]
 results = ["core", "amounts", "currencies"]
 ledger = ["core", "amounts", "currencies"]
-helpers = ["account-helpers", "ledger-helpers", "transaction-helpers"]
+helpers = [
+    "account-helpers",
+    "ledger-helpers",
+    "transaction-helpers",
+    "wallet-helpers",
+]
 account-helpers = ["amounts", "currencies", "requests", "results"]
 ledger-helpers = ["amounts", "currencies", "requests", "results"]
+wallet-helpers = ["requests", "results"]
 transaction-helpers = [
     "wallet",
     "amounts",
@@ -128,8 +134,8 @@ transaction-helpers = [
 ]
 amounts = ["core"]
 currencies = ["core"]
-json-rpc = ["url", "reqwless", "embedded-nal-async"]
-json-rpc-std = ["url", "reqwest"]
+json-rpc = ["url", "reqwless", "embassy-sync", "embedded-nal-async"]
+json-rpc-std = ["url", "reqwest", "embassy-sync", "tokio"]
 wallet = ["core"]
 websocket = [
     "url",

src/asynch/account/mod.rs

@@ -69,20 +69,17 @@ where
             Err(e) => return Err!(e),
         };
     }
-    let account_info = client
-        .request(
-            AccountInfo::new(
-                None,
-                classic_address,
-                None,
-                Some(ledger_index),
-                None,
-                None,
-                None,
-            )
-            .into(),
-        )
-        .await?;
+    let request = AccountInfo::new(
+        None,
+        classic_address,
+        None,
+        Some(ledger_index),
+        None,
+        None,
+        None,
+    )
+    .into();
+    let account_info = client.request(request).await?;
 
     Ok(account_info
         .try_into_result::<results::AccountInfo<'_>>()?

src/asynch/clients/client.rs

@@ -6,11 +6,14 @@ use crate::models::{
 use crate::utils::get_random_id;
 use alloc::borrow::{Cow, ToOwned};
 use anyhow::Result;
+use url::Url;
 
 #[allow(async_fn_in_trait)]
 pub trait Client {
     async fn request_impl<'a: 'b, 'b>(&self, request: XRPLRequest<'a>) -> Result<XRPLResponse<'b>>;
 
+    fn get_host(&self) -> Url;
+
     fn set_request_id(&self, request: &mut XRPLRequest<'_>) -> () {
         let common_fields = request.get_common_fields_mut();
         common_fields.id = match &common_fields.id {

src/asynch/clients/json_rpc/exceptions.rs

@@ -1,8 +1,12 @@
+use reqwest::Response;
 use thiserror_no_std::Error;
 
 #[derive(Debug, Error)]
 pub enum XRPLJsonRpcException {
     #[cfg(feature = "json-rpc")]
     #[error("Reqwless error")]
     ReqwlessError,
+    #[cfg(feature = "json-rpc-std")]
+    #[error("Request error: {0:?}")]
+    RequestError(Response),
 }

src/asynch/clients/json_rpc/mod.rs

@@ -1,101 +1,134 @@
-use alloc::{string::String, sync::Arc};
+use alloc::{string::ToString, vec};
 use anyhow::Result;
-use embassy_sync::{blocking_mutex::raw::RawMutex, mutex::Mutex};
 use serde::Serialize;
+use serde_json::{Map, Value};
+use url::Url;
 
-use crate::{models::results::XRPLResponse, Err};
+use crate::{
+    asynch::wallet::get_faucet_url,
+    models::{requests::FundFaucet, results::XRPLResponse},
+    Err,
+};
 
 mod exceptions;
 pub use exceptions::XRPLJsonRpcException;
 
-use super::{client::Client, SingleExecutorMutex};
+use super::client::Client;
+
+#[allow(async_fn_in_trait)]
+pub trait XRPLFaucet: Client {
+    fn get_faucet_url(&self, url: Option<Url>) -> Result<Url>
+    where
+        Self: Sized + Client,
+    {
+        get_faucet_url(self, url)
+    }
+
+    async fn request_funding(&self, url: Option<Url>, request: FundFaucet<'_>) -> Result<()>;
+}
 
 /// Renames the requests field `command` to `method` for JSON-RPC.
-fn request_to_json_rpc(request: &impl Serialize) -> Result<String> {
+fn request_to_json_rpc(request: &impl Serialize) -> Result<Value> {
+    let mut json_rpc_request = Map::new();
     let mut request = match serde_json::to_value(request) {
-        Ok(request) => request,
+        Ok(request) => match request.as_object().cloned() {
+            Some(request) => request,
+            None => todo!("Handle non-object requests"),
+        },
         Err(error) => return Err!(error),
     };
-    if let Some(command) = request.get_mut("command") {
-        let method = command.take();
-        request["method"] = method;
-    }
-    match serde_json::to_string(&request) {
-        Ok(request) => Ok(request),
-        Err(error) => Err!(error),
+    if let Some(command) = request.remove("command") {
+        json_rpc_request.insert("method".to_string(), command);
+        json_rpc_request.insert(
+            "params".to_string(),
+            serde_json::Value::Array(vec![Value::Object(request)]),
+        );
     }
+
+    Ok(Value::Object(json_rpc_request))
 }
 
 #[cfg(feature = "json-rpc-std")]
 mod _std {
-    use crate::models::requests::XRPLRequest;
+    use crate::models::requests::{FundFaucet, XRPLRequest};
 
     use super::*;
+    use alloc::string::ToString;
     use reqwest::Client as HttpClient;
     use url::Url;
 
-    pub struct AsyncJsonRpcClient<M = SingleExecutorMutex>
-    where
-        M: RawMutex,
-    {
+    pub struct AsyncJsonRpcClient {
         url: Url,
-        client: Arc<Mutex<M, HttpClient>>,
     }
 
-    impl<M> AsyncJsonRpcClient<M>
-    where
-        M: RawMutex,
-    {
-        pub fn new(url: Url) -> Self {
-            Self {
-                url,
-                client: Arc::new(Mutex::new(HttpClient::new())),
-            }
-        }
-    }
-
-    impl<M> AsyncJsonRpcClient<M>
-    where
-        M: RawMutex,
-    {
-        fn from(url: Url, client: HttpClient) -> Self {
-            Self {
-                url,
-                client: Arc::new(Mutex::new(client)),
-            }
+    impl AsyncJsonRpcClient {
+        pub fn connect(url: Url) -> Self {
+            Self { url }
         }
     }
 
-    impl<M> Client for AsyncJsonRpcClient<M>
-    where
-        M: RawMutex,
-    {
+    impl Client for AsyncJsonRpcClient {
         async fn request_impl<'a: 'b, 'b>(
             &self,
             request: XRPLRequest<'a>,
         ) -> Result<XRPLResponse<'b>> {
-            let client = self.client.lock().await;
-            match client
+            let client = HttpClient::new();
+            let request_json_rpc = request_to_json_rpc(&request)?;
+            let response = client
                 .post(self.url.as_ref())
-                .body(request_to_json_rpc(&request)?)
+                .json(&request_json_rpc)
                 .send()
-                .await
-            {
-                Ok(response) => match response.json().await {
-                    Ok(response) => Ok(response),
+                .await;
+            match response {
+                Ok(response) => match response.text().await {
+                    Ok(response) => {
+                        Ok(serde_json::from_str::<XRPLResponse<'b>>(&response).unwrap())
+                    }
                     Err(error) => Err!(error),
                 },
                 Err(error) => Err!(error),
             }
         }
+
+        fn get_host(&self) -> Url {
+            self.url.clone()
+        }
+    }
+
+    impl XRPLFaucet for AsyncJsonRpcClient {
+        async fn request_funding(&self, url: Option<Url>, request: FundFaucet<'_>) -> Result<()> {
+            let faucet_url = self.get_faucet_url(url)?;
+            let client = HttpClient::new();
+            let request_json_rpc = serde_json::to_value(&request).unwrap();
+            let response = client
+                .post(&faucet_url.to_string())
+                .json(&request_json_rpc)
+                .send()
+                .await;
+            match response {
+                Ok(response) => {
+                    if response.status().is_success() {
+                        Ok(())
+                    } else {
+                        todo!()
+                        // Err!(XRPLJsonRpcException::RequestError())
+                    }
+                }
+                Err(error) => {
+                    Err!(error)
+                }
+            }
+        }
     }
 }
 
 #[cfg(feature = "json-rpc")]
 mod _no_std {
-    use crate::models::requests::XRPLRequest;
+    use crate::{asynch::clients::SingleExecutorMutex, models::requests::XRPLRequest};
 
     use super::*;
+    use alloc::sync::Arc;
+    use embassy_sync::{blocking_mutex::raw::RawMutex, mutex::Mutex};
     use embedded_nal_async::{Dns, TcpConnect};
     use reqwless::{
         client::{HttpClient, TlsConfig},
@@ -146,7 +179,8 @@ mod _no_std {
             request: XRPLRequest<'a>,
         ) -> Result<XRPLResponse<'b>> {
             let request_json_rpc = request_to_json_rpc(&request)?;
-            let request_buf = request_json_rpc.as_bytes();
+            let request_string = request_json_rpc.to_string();
+            let request_buf = request_string.as_bytes();
             let mut rx_buffer = [0; BUF];
             let mut client = self.client.lock().await;
             let response = match client.request(Method::POST, self.url.as_str()).await {
@@ -170,6 +204,10 @@ mod _no_std {
 
             response
         }
+
+        fn get_host(&self) -> Url {
+            self.url.clone()
+        }
     }
 }
 

src/asynch/clients/websocket/_no_std.rs

@@ -54,6 +54,7 @@ pub struct AsyncWebsocketClient<
     websocket: Arc<Mutex<M, Framer<Rng, Client>>>,
     tx_buffer: [u8; BUF],
     websocket_base: Arc<Mutex<M, WebsocketBase<M>>>,
+    uri: Url,
     status: PhantomData<Status>,
 }
 
@@ -124,6 +125,7 @@ where
             websocket,
             tx_buffer: buffer,
             websocket_base: Arc::new(Mutex::new(WebsocketBase::new())),
+            uri: url,
             status: PhantomData::<WebsocketOpen>,
         })
     }
@@ -245,6 +247,10 @@ where
     E: Debug + Display,
     Tcp: Stream<Item = Result<B, E>> + for<'b> Sink<&'b [u8], Error = E> + Unpin,
 {
+    fn get_host(&self) -> Url {
+        self.uri.clone()
+    }
+
     async fn request_impl<'a: 'b, 'b>(
         &self,
         mut request: XRPLRequest<'a>,

src/asynch/clients/websocket/_std.rs

@@ -30,6 +30,7 @@ where
 {
     websocket: Arc<Mutex<M, TokioTungsteniteMaybeTlsStream>>,
     websocket_base: Arc<Mutex<M, WebsocketBase<M>>>,
+    uri: Url,
     status: PhantomData<Status>,
 }
 
@@ -141,6 +142,7 @@ where
         Ok(AsyncWebsocketClient {
             websocket: Arc::new(Mutex::new(stream)),
             websocket_base: Arc::new(Mutex::new(WebsocketBase::new())),
+            uri,
             status: PhantomData::<WebsocketOpen>,
         })
     }
@@ -199,6 +201,10 @@ impl<M> Client for AsyncWebsocketClient<M, WebsocketOpen>
 where
     M: RawMutex,
 {
+    fn get_host(&self) -> Url {
+        self.uri.clone()
+    }
+
     async fn request_impl<'a: 'b, 'b>(
         &self,
         mut request: XRPLRequest<'a>,

src/asynch/mod.rs

@@ -11,3 +11,5 @@ pub mod clients;
 pub mod ledger;
 #[cfg(feature = "transaction-helpers")]
 pub mod transaction;
+#[cfg(all(feature = "wallet-helpers", feature = "json-rpc-std"))]
+pub mod wallet;

src/asynch/wallet/exceptions.rs

@@ -0,0 +1,13 @@
+use thiserror_no_std::Error;
+
+#[derive(Error, Debug)]
+pub enum XRPLFaucetException {
+    #[error(
+        "Cannot fund an account on an issuing chain. Accounts must be created via the bridge."
+    )]
+    CannotFundSidechainAccount,
+    #[error("Cannot derive a faucet URL from the client host.")]
+    CannotDeriveFaucetUrl,
+    #[error("Funding request timed out.")]
+    FundingTimeout,
+}