DO NOT MERGE - Async networking

.gitignore

@@ -14,6 +14,7 @@ Cargo.lock
 
 # VSCode
 .vscode
+
 .idea
 
 # Additional

Cargo.toml

@@ -59,6 +59,14 @@ fnv = { version = "1.0.7", default-features = false }
 derive-new = { version = "0.5.9", default-features = false }
 thiserror-no-std = "2.0.2"
 anyhow = { version ="1.0.69", default-features = false }
+tokio = { version = "1.28.0", default-features = false, optional = true }
+
+# Use git version as long as there is no release for em-as-net.
+[dependencies.em-as-net]
+git = "https://github.com/LimpidCrypto/em-as-net"
+package = "em-as-net"
+default-features = false
+optional = true
 
 [dev-dependencies]
 criterion = "0.4.0"
@@ -71,13 +79,14 @@ name = "benchmarks"
 harness = false
 
 [features]
-default = ["std", "core", "models", "utils"]
+default = ["std", "core", "models", "utils", "net"]
 models = ["core", "transactions", "requests", "ledger"]
 transactions = ["core", "amounts", "currencies"]
 requests = ["core", "amounts", "currencies"]
 ledger = ["core", "amounts", "currencies"]
 amounts = ["core"]
 currencies = ["core"]
+net = ["em-as-net"]
 core = ["utils"]
 utils = []
-std = ["rand/std", "regex/std", "chrono/std", "rand/std_rng", "hex/std", "rust_decimal/std", "bs58/std", "serde/std", "indexmap/std", "secp256k1/std"]
+std = ["em-as-net/std", "tokio/full", "rand/std", "regex/std", "chrono/std", "rand/std_rng", "hex/std", "rust_decimal/std", "bs58/std", "serde/std", "indexmap/std", "secp256k1/std"]

src/_anyhow/mod.rs

@@ -2,6 +2,8 @@
 #[macro_export]
 macro_rules! Err {
     ($err:expr $(,)?) => {{
+        use alloc::string::ToString;
+
         let error = $err.to_string().replace("\"", "");
         let boxed_error = ::alloc::boxed::Box::new(error);
         let leaked_error: &'static str = ::alloc::boxed::Box::leak(boxed_error);

src/asynch/clients/async_client.rs

@@ -0,0 +1,11 @@
+use super::client::Client;
+use crate::models::Model;
+use anyhow::Result;
+use serde::Serialize;
+
+/// Interface for all async network clients to follow.
+pub trait AsyncClient<'a>: Client<'a> {
+    async fn request<T: Model + Serialize, R>(&mut self, request: T) -> Result<R> {
+        self.request_impl(request).await
+    }
+}

src/asynch/clients/async_json_rpc_client.rs

@@ -0,0 +1,2 @@
+// /// An async client for interacting with the rippled JSON RPC.
+// pub struct AsyncJsonRpcClient {}

src/asynch/clients/async_websocket_client.rs

@@ -0,0 +1,164 @@
+use crate::asynch::clients::exceptions::XRPLWebsocketException;
+use crate::asynch::clients::websocket_base::WebsocketBase;
+use crate::models::Model;
+use crate::Err;
+use anyhow::Result;
+use serde::Serialize;
+
+// exports
+#[cfg(feature = "std")]
+pub use if_std::AsyncWebsocketClient;
+
+pub use em_as_net::client::websocket::ReadResult;
+
+#[cfg(feature = "std")]
+mod if_std {
+    use crate::asynch::clients::async_client::AsyncClient;
+    use crate::asynch::clients::client::Client;
+    use crate::asynch::clients::exceptions::XRPLWebsocketException;
+    use crate::asynch::clients::websocket_base::WebsocketBase;
+    use crate::models::Model;
+    use crate::Err;
+    use alloc::borrow::Cow;
+    use core::cell::RefCell;
+    use core::ops::Deref;
+
+    use anyhow::Result;
+
+    use crate::asynch::clients::Websocket;
+    use em_as_net::client::websocket::{
+        ReadResult, WebsocketClient, WebsocketClientIo, WebsocketSendMessageType,
+    };
+    use rand::rngs::ThreadRng;
+    use serde::Serialize;
+    use tokio::net;
+
+    /// An async client for interacting with the rippled WebSocket API.
+    pub struct AsyncWebsocketClient<'a> {
+        pub uri: Cow<'a, str>,
+        inner: RefCell<Option<WebsocketClient<'a, net::TcpStream, ThreadRng>>>,
+    }
+
+    impl<'a> AsyncWebsocketClient<'a> {
+        pub fn new(uri: Cow<'a, str>, buffer: &'a mut [u8]) -> Self {
+            let ws = WebsocketClient::new(uri.clone(), buffer);
+            Self {
+                uri,
+                inner: RefCell::new(Some(ws)),
+            }
+        }
+    }
+
+    impl<'a> Websocket<'a> for AsyncWebsocketClient<'a> {}
+
+    impl<'a> WebsocketBase<'a> for AsyncWebsocketClient<'a> {
+        fn is_open(&self) -> bool {
+            if let Some(ws) = self.inner.borrow().deref() {
+                ws.is_open()
+            } else {
+                false
+            }
+        }
+
+        async fn do_open(&self) -> Result<()> {
+            return match self.inner.borrow_mut().as_mut() {
+                None => {
+                    Err!(XRPLWebsocketException::NotOpen)
+                }
+                Some(ws) => ws.connect(None).await,
+            };
+        }
+
+        async fn do_close(&self) -> Result<()> {
+            return match self.inner.borrow_mut().as_mut() {
+                None => {
+                    Err!(XRPLWebsocketException::NotOpen)
+                }
+                Some(ws) => ws.close().await,
+            };
+        }
+
+        async fn do_write<T: Model + Serialize>(&self, request: T) -> Result<()> {
+            return match self.inner.borrow_mut().as_mut() {
+                None => {
+                    Err!(XRPLWebsocketException::NotOpen)
+                }
+                Some(ws) => {
+                    let request_string = match serde_json::to_string(&request) {
+                        Ok(as_string) => as_string,
+                        Err(_) => return Err!(XRPLWebsocketException::RequestSerializationError),
+                    };
+                    ws.write(
+                        Cow::from(request_string),
+                        Some(WebsocketSendMessageType::Text),
+                    )
+                    .await
+                }
+            };
+        }
+
+        // TODO: Fix lifetime issue
+        async fn do_read(&'a mut self) -> Result<Option<ReadResult<'a>>> {
+            return match self.inner.get_mut() {
+                None => {
+                    Err!(XRPLWebsocketException::NotOpen)
+                }
+                Some(ws) => match ws.read().await {
+                    None => Ok(None),
+                    Some(Ok(read_result)) => Ok(Some(read_result)),
+                    Some(Err(read_error)) => Err(read_error),
+                },
+            };
+        }
+
+        async fn do_request_impl<T: Model + Serialize, R>(&mut self, _request: T) -> Result<R> {
+            todo!()
+        }
+    }
+
+    impl<'a> AsyncClient<'a> for AsyncWebsocketClient<'a> {}
+
+    impl<'a> Client<'a> for AsyncWebsocketClient<'a> {
+        async fn request_impl<T: Model + Serialize, R>(&mut self, request: T) -> Result<R> {
+            if !<AsyncWebsocketClient<'a> as WebsocketBase<'_>>::is_open(self) {
+                return Err!(XRPLWebsocketException::NotOpen);
+            }
+
+            self.do_request_impl(request).await
+        }
+    }
+}
+
+pub trait Websocket<'a>: WebsocketBase<'a> {
+    async fn open(&mut self) -> Result<()> {
+        if !self.is_open() {
+            self.do_open().await
+        } else {
+            Ok(())
+        }
+    }
+
+    async fn close(&self) -> Result<()> {
+        if self.is_open() {
+            self.do_close().await
+        } else {
+            Ok(())
+        }
+    }
+
+    async fn write<T: Model + Serialize>(&mut self, request: T) -> Result<()> {
+        if self.is_open() {
+            self.do_write(request).await
+        } else {
+            Err!(XRPLWebsocketException::NotOpen)
+        }
+    }
+
+    async fn read(&'a mut self) -> Result<Option<ReadResult<'a>>> {
+        if self.is_open() {
+            self.do_read().await
+        } else {
+            Err!(XRPLWebsocketException::NotOpen)
+        }
+    }
+}

src/asynch/clients/client.rs

@@ -0,0 +1,10 @@
+use crate::models::Model;
+use anyhow::Result;
+use serde::Serialize;
+
+/// Interface for all network clients to follow.
+// TODO: `T` should implement a trait `Request`
+// TODO: `R` should implement a trait `Response`
+pub trait Client<'a> {
+    async fn request_impl<T: Model + Serialize, R>(&mut self, request: T) -> Result<R>;
+}

src/asynch/clients/exceptions.rs

@@ -0,0 +1,9 @@
+use thiserror_no_std::Error;
+
+#[derive(Debug, Clone, PartialEq, Eq, Error)]
+pub enum XRPLWebsocketException {
+    #[error("Websocket is not open")]
+    NotOpen,
+    #[error("Failed to serialize XRPL request to string")]
+    RequestSerializationError,
+}

src/asynch/clients/json_rpc_base.rs

@@ -0,0 +1,2 @@
+// /// A common interface for JsonRpc requests.
+// pub trait JsonRpcBase {}

src/asynch/clients/mod.rs

@@ -0,0 +1,10 @@
+mod async_client;
+pub mod async_json_rpc_client;
+pub mod async_websocket_client;
+mod client;
+pub mod exceptions;
+mod json_rpc_base;
+mod websocket_base;
+
+pub use async_json_rpc_client::*;
+pub use async_websocket_client::*;

src/asynch/clients/websocket_base.rs

@@ -0,0 +1,20 @@
+use crate::asynch::clients::client::Client;
+use crate::models::Model;
+use anyhow::Result;
+use em_as_net::client::websocket::ReadResult;
+use serde::Serialize;
+
+// A client for interacting with the rippled WebSocket API.
+pub trait WebsocketBase<'a>: Client<'a> {
+    fn is_open(&self) -> bool;
+
+    async fn do_open(&self) -> Result<()>;
+
+    async fn do_close(&self) -> Result<()>;
+
+    async fn do_write<T: Model + Serialize>(&self, request: T) -> Result<()>;
+
+    async fn do_read(&'a mut self) -> Result<Option<ReadResult<'a>>>;
+
+    async fn do_request_impl<T: Model + Serialize, R>(&mut self, request: T) -> Result<R>;
+}

src/asynch/mod.rs

@@ -0,0 +1,2 @@
+#[cfg(feature = "net")]
+pub mod clients;

src/lib.rs

@@ -19,12 +19,17 @@
 //! [XRP Ledger](https://xrpl.org/docs.html).
 #![no_std]
 #![allow(dead_code)] // Remove eventually
+#![allow(incomplete_features)]
+#![feature(async_fn_in_trait)]
+#![feature(inherent_associated_types)]
+#![feature(type_alias_impl_trait)]
 
 #[cfg(not(feature = "std"))]
 extern crate alloc;
 #[cfg(feature = "std")]
 extern crate std as alloc;
 
+pub mod asynch;
 pub mod constants;
 #[cfg(feature = "core")]
 pub mod core;

src/models/mod.rs

@@ -9,6 +9,7 @@
 
 pub mod exceptions;
 #[cfg(feature = "ledger")]
+#[allow(clippy::too_many_arguments)]
 pub mod ledger;
 pub mod model;
 #[cfg(feature = "requests")]

src/models/requests/account_channels.rs

@@ -76,7 +76,7 @@ impl<'a> Default for AccountChannels<'a> {
 impl<'a> Model for AccountChannels<'a> {}
 
 impl<'a> AccountChannels<'a> {
-    fn new(
+    pub fn new(
         account: &'a str,
         id: Option<&'a str>,
         ledger_hash: Option<&'a str>,

src/models/requests/account_currencies.rs

@@ -50,7 +50,7 @@ impl<'a> Default for AccountCurrencies<'a> {
 impl<'a> Model for AccountCurrencies<'a> {}
 
 impl<'a> AccountCurrencies<'a> {
-    fn new(
+    pub fn new(
         account: &'a str,
         id: Option<&'a str>,
         ledger_hash: Option<&'a str>,

src/models/requests/account_info.rs

@@ -59,7 +59,7 @@ impl<'a> Default for AccountInfo<'a> {
 impl<'a> Model for AccountInfo<'a> {}
 
 impl<'a> AccountInfo<'a> {
-    fn new(
+    pub fn new(
         account: &'a str,
         id: Option<&'a str>,
         ledger_hash: Option<&'a str>,

src/models/requests/account_lines.rs

@@ -56,7 +56,7 @@ impl<'a> Default for AccountLines<'a> {
 impl<'a> Model for AccountLines<'a> {}
 
 impl<'a> AccountLines<'a> {
-    fn new(
+    pub fn new(
         account: &'a str,
         id: Option<&'a str>,
         ledger_hash: Option<&'a str>,

src/models/requests/account_nfts.rs

@@ -41,7 +41,12 @@ impl<'a> Default for AccountNfts<'a> {
 impl<'a> Model for AccountNfts<'a> {}
 
 impl<'a> AccountNfts<'a> {
-    fn new(account: &'a str, id: Option<&'a str>, limit: Option<u32>, marker: Option<u32>) -> Self {
+    pub fn new(
+        account: &'a str,
+        id: Option<&'a str>,
+        limit: Option<u32>,
+        marker: Option<u32>,
+    ) -> Self {
         Self {
             account,
             id,

src/models/requests/account_objects.rs

@@ -79,7 +79,7 @@ impl<'a> Default for AccountObjects<'a> {
 impl<'a> Model for AccountObjects<'a> {}
 
 impl<'a> AccountObjects<'a> {
-    fn new(
+    pub fn new(
         account: &'a str,
         id: Option<&'a str>,
         ledger_hash: Option<&'a str>,

src/models/requests/account_offers.rs

@@ -55,7 +55,7 @@ impl<'a> Default for AccountOffers<'a> {
 impl<'a> Model for AccountOffers<'a> {}
 
 impl<'a> AccountOffers<'a> {
-    fn new(
+    pub fn new(
         account: &'a str,
         id: Option<&'a str>,
         ledger_hash: Option<&'a str>,

src/models/requests/account_tx.rs

@@ -71,7 +71,7 @@ impl<'a> Default for AccountTx<'a> {
 impl<'a> Model for AccountTx<'a> {}
 
 impl<'a> AccountTx<'a> {
-    fn new(
+    pub fn new(
         account: &'a str,
         id: Option<&'a str>,
         ledger_hash: Option<&'a str>,

src/models/requests/book_offers.rs

@@ -61,7 +61,7 @@ impl<'a> Default for BookOffers<'a> {
 impl<'a> Model for BookOffers<'a> {}
 
 impl<'a> BookOffers<'a> {
-    fn new(
+    pub fn new(
         taker_gets: Currency<'a>,
         taker_pays: Currency<'a>,
         id: Option<&'a str>,