Menyiapkan klien

Menyiapkan klien SDK

Setelah SDK diimpor ke dalam proyek, SDK tersebut dapat digunakan untuk berinteraksi dengan blockchain Namada. Anggaplah kita memiliki node yang berjalan pada ip dan port 127.0.0.1:26657dan kita ingin mengirim transaksi ke jaringan.

SDK mungkin untuk berbagai tujuan, namun dalam contoh ini kita akan menggunakannya untuk mengirim transaksi ke jaringan.

Pertama, kita perlu mengimplementasikannya Clientagar kita dapat berkomunikasi dengan node yang sedang berjalan.

use reqwest::{Client, Response as ClientResponse};
 
 
pub struct SdkClient {
    url: String,
    client: Client,
}
 
impl SdkClient {
    pub fn new(url: String) -> Self {
        Self {
            client: Client::new(),
            url,
        }
    }
 
    pub async fn post(&self, body: String) -> Result<ClientResponse, reqwest::Error> {
        self.client
            .post(format!("http://{}", &self.url))
            .body(body)
            .send()
            .await
    }
}

Hal ini memungkinkan kita menggunakan Clientfrom reqwest(perpustakaan eksternal) untuk mengirim transaksi ke jaringan.

Kita juga perlu mendefinisikan beberapa fungsi yang akan digunakan klien untuk berinteraksi dengan jaringan.

#[async_trait::async_trait]
impl ClientTrait for SdkClient {
    type Error = Error;
 
    async fn request(
        &self,
        path: String,
        data: Option<Vec<u8>>,
        height: Option<BlockHeight>,
        prove: bool,
    ) -> Result<EncodedResponseQuery, Self::Error> {
        let data = data.unwrap_or_default();
        let height = height
            .map(|height| {
                tendermint::block::Height::try_from(height.0)
                    .map_err(|_err| Error::InvalidHeight(height))
            })
            .transpose()?;
        let response = self
            .abci_query(
                Some(std::str::FromStr::from_str(&path).unwrap()),
                data,
                height,
                prove,
            )
            .await?;
 
        match response.code {
            Code::Ok => Ok(EncodedResponseQuery {
                data: response.value,
                info: response.info,
                proof: response.proof,
            }),
            Code::Err(code) => Err(Error::Query(response.info, code)),
        }
    }
 
    async fn perform<R>(&self, request: R) -> Result<R::Response, tm_rpc::Error>
    where
        R: tm_rpc::SimpleRequest,
    {
        let request_body = request.into_json();
        let response = self.post(request_body).await;
 
        match response {
            Ok(response) => {
                let response_json = response.text().await.unwrap();
                R::Response::from_string(response_json)
            }
            Err(e) => {
                let error_msg = e.to_string();
                Err(tm_rpc::Error::server(error_msg))
            }
        }
    }
}

Sekarang, kami siap menggunakan klien ini untuk mengirim transaksi.