feat: add walletAddress endpoint

example.env

@@ -0,0 +1 @@
+WALLET_ADDRESS="0x"

xps-gateway/Cargo.toml

@@ -18,6 +18,8 @@ jsonrpsee = { version = "0.21", features = ["macros", "server", "client-core"] }
 anyhow = "1"
 thiserror = "1"
 ctor = "0.2"
+dotenvy = "0.15.7"
+envy = "0.4.2"
 
 [dev-dependencies]
 jsonrpsee = { version = "0.21", features = ["macros", "server", "client"] }

xps-gateway/src/lib.rs

@@ -4,19 +4,43 @@
 
 use anyhow::Result;
 use jsonrpsee::server::Server;
+use serde::Deserialize;
 
 pub use crate::rpc::{XpsMethods, XpsServer};
 
 pub const SERVER_HOST: &str = "127.0.0.1:0";
+pub const DEFAULT_WALLET_ADDRESS: &str = "0x0000000000000000000000000000000000000000";
+
+#[derive(Deserialize)]
+struct XpsGatewayOptions {
+    /// wallet address
+    #[serde(default = "default_wallet_address")]
+    wallet_address: String,
+}
+
+fn default_wallet_address() -> String {
+    DEFAULT_WALLET_ADDRESS.to_string()
+}
 
 /// Entrypoint for the xps Gateway
 pub async fn run() -> Result<()> {
     crate::util::init_logging();
+    match dotenvy::dotenv() {
+        Ok(path) => {
+            // .env file successfully loaded.
+            log::debug!("Env file {} was loaded successfully", path.display());
+        }
+        Err(err) => {
+            // Error handling for the case where dotenv() fails
+            log::info!("Unable to load env file(s) : {err}");
+        }
+    }
+    let opts: XpsGatewayOptions = envy::from_env()?;
 
     // a port of 0 allows the OS to choose an open port
     let server = Server::builder().build(SERVER_HOST).await?;
     let addr = server.local_addr()?;
-    let handle = server.start(rpc::XpsMethods.into_rpc());
+    let handle = server.start(XpsMethods::new(opts.wallet_address.as_str()).into_rpc());
 
     log::info!("Server Started at {addr}");
     handle.stopped().await;

xps-gateway/src/rpc/api.rs

@@ -98,4 +98,7 @@ pub trait Xps {
     /// - The system should have proper error handling to deal with invalid requests, unauthorized access, and other potential issues.
     #[method(name = "status")]
     async fn status(&self) -> Result<String, ErrorObjectOwned>;
+
+    #[method(name = "walletAddress")]
+    async fn wallet_address(&self) -> Result<String, ErrorObjectOwned>;
 }

xps-gateway/src/rpc/methods.rs

@@ -3,24 +3,29 @@
 use super::api::*;
 use jsonrpsee::types::error::ErrorCode;
 
+use super::super::DEFAULT_WALLET_ADDRESS;
 use async_trait::async_trait;
 use jsonrpsee::types::ErrorObjectOwned;
 
 use crate::types::Message;
 
 /// Gateway Methods for XPS
-pub struct XpsMethods;
+pub struct XpsMethods {
+    pub wallet_address: String,
+}
 
 impl XpsMethods {
     /// Create a new instance of the XpsMethods struct
-    pub fn new() -> Self {
-        Self {}
+    pub fn new(wallet_address: &str) -> Self {
+        Self {
+            wallet_address: wallet_address.to_string(),
+        }
     }
 }
 
 impl Default for XpsMethods {
     fn default() -> Self {
-        Self::new()
+        Self::new(DEFAULT_WALLET_ADDRESS)
     }
 }
 
@@ -36,4 +41,8 @@
         log::debug!("xps_status called");
         Ok("OK".to_string())
     }
+
+    async fn wallet_address(&self) -> Result<String, ErrorObjectOwned> {
+        Ok(self.wallet_address.clone())
+    }
 }

xps-gateway/tests/integration_test.rs

@@ -11,6 +11,7 @@ use tokio::time::timeout as timeout_tokio;
 use xps_gateway::{rpc::XpsClient, types::Message, XpsMethods, XpsServer, SERVER_HOST};
 
 const TEST_TIMEOUT: Duration = Duration::from_secs(10);
+const TEST_WALLET_ADDRESS: &str = "0x000000000000000000000000000000000000dEaD";
 
 #[cfg(test)]
 mod it {
@@ -42,6 +43,16 @@ mod it {
         })
         .await
     }
+
+    #[tokio::test]
+    async fn test_wallet_address() -> Result<(), Error> {
+        with_xps_client(None, |client| async move {
+            let result = client.wallet_address().await?;
+            assert_eq!(result, TEST_WALLET_ADDRESS);
+            Ok(())
+        })
+        .await
+    }
 }
 
 async fn with_xps_client<F, R, T>(timeout: Option<Duration>, f: F) -> Result<T, Error>
@@ -51,7 +62,7 @@ where
 {
     let server = Server::builder().build(SERVER_HOST).await.unwrap();
     let addr = server.local_addr().unwrap();
-    let handle = server.start(XpsMethods::new().into_rpc());
+    let handle = server.start(XpsMethods::new(TEST_WALLET_ADDRESS).into_rpc());
     let client = WsClientBuilder::default()
         .build(&format!("ws://{addr}"))
         .await