Project Discussions

[LimpidCrypto]

A space to discuss the tasks defined in the xrpl-rust project.
Because drafts do not have urls one could reference to, we use the following message format to reference to a task to make the discussions as understandable as possible:

`Status field`: `Topic`
Message

[LimpidCrypto]

New: Implement zeroize crate to securely clear memory
I would suggest to move it to the Backlog. It makes totally sense to implement zeroize whenever this library is dealing with sensitive data to ensure that there is no way to find that data in memory once it is no longer needed.

[LimpidCrypto]

New: Implement SAST Using SonarQube via GitHub Actions
When would that action be executed? Every time you push a commit to a PR?
SonarQube sounds like a great tool to ensure that we deliver high quality and secure code users can rely on. As well as the comment above I would suggest moving the task to the Backlog to meet our milestones.

[LimpidCrypto]

Backlog: Add clients and Response struct
Next up for me would be the clients. I will prioritize the websocket clients because they are the most useful. I will use the tokio-tungstenite crate. In the draft I added an example to use as a reference. In the past I struggled to find a convenient way to return a response from a websocket subscription, so that will take some research. I will share my ideas here. If you have a good idea on how to do it please also share here.

[LimpidCrypto]

Finally got the first working async websocket client with whose messages you can actually work with (instead of simply printing it):

use futures_util::{SinkExt, StreamExt};
use tokio::net::TcpStream;
use futures_channel::mpsc::{unbounded, UnboundedSender};
use tokio_tungstenite::{
    tungstenite::protocol::Message, tungstenite::Error, WebSocketStream, MaybeTlsStream, connect_async,
};

struct AsyncWebsocketClient<'a> {
    url: &'a str,
}

impl AsyncWebsocketClient<'static> {
    pub async fn open(&self) -> Result<WebSocketStream<MaybeTlsStream<TcpStream>>, Error> {
        let ws_stream = connect_async(self.url).await;
        match ws_stream {
            Ok((result, _)) => Ok(result),
            Err(error) => Err(error),
        }
    }

    pub async fn send(&mut self, message: Message, sender: UnboundedSender<Message>) -> Result<(), ()>{
        let ws_stream = self.open().await;
        match ws_stream {
            Ok(mut ws_stream) => {
                let _result = ws_stream.send(message).await;
                while let Some(msg) = ws_stream.next().await {
                    match msg {
                        Ok(message) => {
                            let _ = sender.unbounded_send(message);
                        },
                        Err(_error) => continue,
                    }
                }
                Ok(())
            },
            Err(_) => Err(()),
        }
    }
}

#[tokio::main]
async fn main() {
    let mut client = AsyncWebsocketClient {
        url: "wss://xrplcluster.com/",
    };
    let (sender, mut receiver) = unbounded();
    tokio::spawn(async move {
        while let Some(msg) = receiver.next().await {
            // Do anything with the message.
            println!("{:?}", msg);
        }
    });
    let _send = client.send(
        Message::Text(
            r#"{
                "id": "Example watch for new validated ledgers",
                "command": "subscribe",
                "streams": ["ledger"]
            }"#
            .to_string()
        ),
        sender
    ).await;
}

(written in an extern file)

Just wanted to share some progress, of course most things are still missing :)