layerzero_scan_client 0.1.0

Layerzero Scan Client
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

#[cfg(test)]
mod test;

pub async fn get_message_by_src_tx_hash<'a>(
    src_chain_id: u64,
    src_tx_hash: &'a str,
) -> Result<GetMessageBySrcTxHashResponse, Error> {
    let env = if src_chain_id < 10000 {
        Environment::Mainnet
    } else if src_chain_id < 20000 {
        Environment::Testnet
    } else {
        Environment::Sandbox
    };

    let client = Client::new(env, None);
    client.get_message_by_src_tx_hash(src_tx_hash).await
}

pub struct Client {
    #[allow(dead_code)]
    options: ClientOptions,
    env: Environment,
}

impl Client {
    pub fn new(env: Environment, options: Option<ClientOptions>) -> Self {
        Client {
            options: options.unwrap_or(ClientOptions::default()),
            env,
        }
    }

    pub async fn get_message_by_src_tx_hash<'a>(
        &self,
        src_tx_hash: &'a str,
    ) -> Result<GetMessageBySrcTxHashResponse, Error> {
        let url = match self.env {
            Environment::Testnet => TESTNET_URL,
            Environment::Mainnet => MAINNET_URL,
            Environment::Sandbox => SANDBOX_URL,
        };
        let path = format!("/tx/{}", src_tx_hash);
        let full_url = format!("{}{}", url, path);

        Ok(reqwest::get(full_url).await?.json::<GetMessageBySrcTxHashResponse>().await?)
    }
}

const TESTNET_URL: &str = "https://api-testnet.layerzero-scan.com";
const MAINNET_URL: &str = "https://api-mainnet.layerzero-scan.com";
const SANDBOX_URL: &str = "https://api-sandbox.layerzero-scan.com";

#[derive(Debug, thiserror::Error)]
pub enum Error {
    #[error("reqwest error: {0}")]
    Reqwest(#[from] reqwest::Error),
}

#[derive(Debug, Clone, serde::Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct Message {
    pub src_ua_address: String,
    pub dst_ua_address: String,
    pub src_chain_id: u64,
    pub dst_chain_id: u64,
    pub dst_tx_hash: Option<String>,
    pub dst_tx_error: Option<String>,
    pub src_tx_hash: String,
    pub src_block_hash: String,
    pub src_block_number: String,
    pub src_ua_nonce: u64,
    pub status: MessageStatus,
}

#[derive(Debug, Clone, serde::Deserialize, PartialEq)]
#[serde(rename_all = "UPPERCASE")]
pub enum MessageStatus {
    Inflight,
    Delivered,
    Failed,
}

#[derive(Debug, Clone, serde::Deserialize, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct GetMessageBySrcTxHashResponse {
    pub messages: Vec<Message>,
}

pub struct ClientOptions {}

impl Default for ClientOptions {
    fn default() -> Self {
        ClientOptions {}
    }
}

pub enum Environment {
    Testnet,
    Mainnet,
    Sandbox,
}