Merge branch 'dev' into utility-functions

Author: LimpidCrypto

.devcontainer/playground/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "playground"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+xrpl-rust = { path = "../.." }
+tokio = { version = "1", features = ["full"] }

.devcontainer/playground/src/main.rs

@@ -0,0 +1,4 @@
+#[tokio::main]
+async fn main() {
+    println!("Hello, world!");
+}

.gitignore

@@ -1,10 +1,10 @@
 # Generated by Cargo
 # will have compiled files and executables
-/target/
+**/target/
 
 # Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
 # More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
-Cargo.lock
+**/Cargo.lock
 
 # These are backup files generated by rustfmt
 **/*.rs.bk
@@ -17,7 +17,7 @@ Cargo.lock
 .idea
 
 # Additional
-src/main.rs
+**/src/main.rs
 
 **/.DS_Store
 

src/account/mod.rs

@@ -13,7 +13,10 @@ use crate::{
         clients::XRPLClient,
         exceptions::XRPLHelperResult,
     },
-    models::{ledger::objects::AccountRoot, results::account_tx::AccountTx, XRPAmount},
+    models::{
+        ledger::objects::account_root::AccountRoot, results::account_tx::AccountTxVersionMap,
+        XRPAmount,
+    },
 };
 
 pub fn does_account_exist<C>(
@@ -44,7 +47,7 @@ where
 
 pub fn get_xrp_balance<'a: 'b, 'b, C>(
     address: Cow<'a, str>,
-    client: &C,
+    client: &'a C,
     ledger_index: Option<Cow<'a, str>>,
 ) -> XRPLHelperResult<XRPAmount<'b>>
 where
@@ -55,7 +58,7 @@ where
 
 pub fn get_account_root<'a: 'b, 'b, C>(
     address: Cow<'a, str>,
-    client: &C,
+    client: &'a C,
     ledger_index: Cow<'a, str>,
 ) -> XRPLHelperResult<AccountRoot<'b>>
 where
@@ -67,7 +70,7 @@ where
 pub fn get_latest_transaction<'a: 'b, 'b, C>(
     address: Cow<'a, str>,
     client: &C,
-) -> XRPLHelperResult<AccountTx<'b>>
+) -> XRPLHelperResult<AccountTxVersionMap<'b>>
 where
     C: XRPLClient,
 {

src/asynch/account/mod.rs

@@ -1,9 +1,9 @@
-use alloc::borrow::Cow;
+use alloc::borrow::{Cow, ToOwned};
 
 use crate::{
     core::addresscodec::{is_valid_xaddress, xaddress_to_classic_address},
     models::{
-        ledger::objects::AccountRoot,
+        ledger::objects::account_root::AccountRoot,
         requests::{account_info::AccountInfo, account_tx::AccountTx},
         results::{self},
         XRPAmount,
@@ -38,7 +38,7 @@ pub async fn get_next_valid_seq_number(
 
 pub async fn get_xrp_balance<'a: 'b, 'b, C>(
     address: Cow<'a, str>,
-    client: &C,
+    client: &'a C,
     ledger_index: Option<Cow<'a, str>>,
 ) -> XRPLHelperResult<XRPAmount<'b>>
 where
@@ -54,7 +54,7 @@ where
 
 pub async fn get_account_root<'a: 'b, 'b, C>(
     address: Cow<'a, str>,
-    client: &C,
+    client: &'a C,
     ledger_index: Cow<'a, str>,
 ) -> XRPLHelperResult<AccountRoot<'b>>
 where
@@ -74,17 +74,17 @@ where
         None,
     )
     .into();
-    let account_info = client.request(request).await?;
+    let response = client.request(request).await?;
+    let account_info = results::account_info::AccountInfoVersionMap::try_from(response)?;
+    let account_root = account_info.get_account_root().to_owned();
 
-    Ok(account_info
-        .try_into_result::<results::account_info::AccountInfo<'_>>()?
-        .account_data)
+    Ok(account_root)
 }
 
 pub async fn get_latest_transaction<'a: 'b, 'b, C>(
     mut address: Cow<'a, str>,
     client: &C,
-) -> XRPLHelperResult<crate::models::results::account_tx::AccountTx<'b>>
+) -> XRPLHelperResult<crate::models::results::account_tx::AccountTxVersionMap<'b>>
 where
     C: XRPLAsyncClient,
 {
@@ -103,7 +103,8 @@ where
         Some(1),
         None,
     );
-    let response = client.request(account_tx.into()).await?;
+    let response: results::account_tx::AccountTxVersionMap =
+        client.request(account_tx.into()).await?.try_into()?;
 
-    Ok(response.try_into_result::<results::account_tx::AccountTx<'_>>()?)
+    Ok(response)
 }

src/asynch/clients/async_client.rs

@@ -15,12 +15,10 @@ pub trait XRPLAsyncClient: XRPLClient {
 
     async fn get_common_fields(&self) -> XRPLClientResult<CommonFields<'_>> {
         let server_state = self.request(ServerState::new(None).into()).await?;
-        let state = server_state
-            .try_into_result::<ServerStateResult<'_>>()?
-            .state;
+        let server_state: ServerStateResult = server_state.try_into()?;
         let common_fields = CommonFields {
-            network_id: state.network_id,
-            build_version: Some(state.build_version),
+            network_id: server_state.state.network_id,
+            build_version: Some(server_state.state.build_version),
         };
 
         Ok(common_fields)

src/asynch/clients/client.rs

@@ -18,19 +18,16 @@ pub trait XRPLClient {
 
     fn set_request_id(&self, request: &mut XRPLRequest<'_>) {
         let common_fields = request.get_common_fields_mut();
-        common_fields.id = match &common_fields.id {
-            Some(id) => Some(id.clone()),
-            None => {
-                #[cfg(feature = "std")]
-                {
-                    Some(self.get_random_id())
-                }
-                #[cfg(not(feature = "std"))]
-                unimplemented!(
-                    "Random ID generation is not supported in no_std. Please provide an ID."
-                )
+        if common_fields.id.is_none() {
+            #[cfg(feature = "std")]
+            {
+                common_fields.id = Some(self.get_random_id());
             }
-        };
+            #[cfg(not(feature = "std"))]
+            unimplemented!(
+                "Random ID generation is not supported in no_std. Please provide an ID."
+            );
+        }
     }
 
     /// Generate a random id.

src/asynch/clients/json_rpc/mod.rs

@@ -1,3 +1,4 @@
+
 use alloc::{string::ToString, vec};
 use serde::Serialize;
 use serde_json::{Map, Value};
@@ -12,20 +13,12 @@ use super::{client::XRPLClient, exceptions::XRPLClientResult};
 /// Renames the requests field `command` to `method` for JSON-RPC.
 fn request_to_json_rpc(request: &impl Serialize) -> XRPLClientResult<Value> {
     let mut json_rpc_request = Map::new();
-    // let mut request = match serde_json::to_value(request) {
-    //     Ok(request) => match request.as_object().cloned() {
-    //         Some(request) => request,
-    //         None => todo!("Handle non-object requests"),
-    //     },
-    //     Err(error) => return Err!(error),
-    // };
     let request_value = serde_json::to_value(request)?;
     let mut request = request_value
-        .clone()
         .as_object()
         .ok_or(XRPLSerdeJsonError::UnexpectedValueType {
             expected: "Object".to_string(),
-            found: request_value,
+            found: request_value.clone(),
         })?
         .clone();
     if let Some(command) = request.remove("command") {

src/asynch/clients/websocket/websocket_base.rs

@@ -79,7 +79,7 @@ where
             };
             sender
                 .send(message)
-                .map_err(|e| XRPLWebSocketException::MessageChannelError(e))?;
+                .map_err(XRPLWebSocketException::MessageChannelError)?;
         } else {
             self.messages.send(message).await;
         }

src/asynch/ledger/mod.rs

@@ -4,7 +4,7 @@ use alloc::string::ToString;
 
 use crate::models::{
     requests::{fee::Fee, ledger::Ledger},
-    results::{fee::Drops, fee::Fee as FeeResult, ledger::Ledger as LedgerResult},
+    results::{self},
     XRPAmount,
 };
 
@@ -30,10 +30,9 @@ pub async fn get_latest_validated_ledger_sequence(
             .into(),
         )
         .await?;
+    let ledger_result: results::ledger::Ledger = ledger_response.try_into()?;
 
-    Ok(ledger_response
-        .try_into_result::<LedgerResult<'_>>()?
-        .ledger_index)
+    Ok(ledger_result.ledger_index)
 }
 
 pub async fn get_latest_open_ledger_sequence(
@@ -56,10 +55,9 @@ pub async fn get_latest_open_ledger_sequence(
             .into(),
         )
         .await?;
+    let ledger_result: results::ledger::Ledger = ledger_response.try_into()?;
 
-    Ok(ledger_response
-        .try_into_result::<LedgerResult<'_>>()?
-        .ledger_index)
+    Ok(ledger_result.ledger_index)
 }
 
 pub enum FeeType {
@@ -75,7 +73,8 @@ pub async fn get_fee(
 ) -> XRPLHelperResult<XRPAmount<'_>> {
     let fee_request = Fee::new(None);
     let response = client.request(fee_request.into()).await?;
-    let drops = response.try_into_result::<FeeResult<'_>>()?.drops;
+    let result: results::fee::Fee = response.try_into()?;
+    let drops = result.drops;
     let fee = match_fee_type(fee_type, drops)?;
 
     if let Some(max_fee) = max_fee {
@@ -85,7 +84,10 @@ pub async fn get_fee(
     }
 }
 
-fn match_fee_type(fee_type: Option<FeeType>, drops: Drops<'_>) -> XRPLHelperResult<u32> {
+fn match_fee_type(
+    fee_type: Option<FeeType>,
+    drops: results::fee::Drops<'_>,
+) -> XRPLHelperResult<u32> {
     match fee_type {
         None | Some(FeeType::Open) => Ok(drops.open_ledger_fee.try_into()?),
         Some(FeeType::Minimum) => Ok(drops.minimum_fee.try_into()?),