iamgroot 0.3.0

Rust code generation from Open-RPC spec
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

#[tokio::main]
async fn main() {
    tracing_subscriber::fmt::init();
    client::run().await;
}

pub struct Http(reqwest::Client);

impl Http {
    pub fn new() -> Self {
        Self(reqwest::Client::new())
    }
}

#[cfg_attr(target_arch = "wasm32", async_trait::async_trait(?Send))]
#[cfg_attr(not(target_arch = "wasm32"), async_trait::async_trait)]
impl gen::client::HttpClient for Http {
    async fn post(
        &self,
        url: &str,
        request: &iamgroot::jsonrpc::Request,
    ) -> std::result::Result<iamgroot::jsonrpc::Response, iamgroot::jsonrpc::Error> {
        Ok(self.0.post(url)
            .json(request)
            .send()
            .await
            .map_err(|e| {
                iamgroot::jsonrpc::Error::new(-32001, format!("post request failed: {e}"))     
            })?
            .json()
            .await
            .map_err(|e| {
                iamgroot::jsonrpc::Error::new(-32002, format!("post response failed: {e}"))
            })?)
    }
}

mod client {
    use super::*;
    pub async fn run() {
        use crate::gen::Rpc;
        let url = std::env::var("URL").expect("URL");
        let client = gen::client::Client::new(&url, Http::new());

        let block_id = gen::BlockId::BlockTag(gen::BlockTag::Latest);
        let block = match client.getBlockWithTxs(block_id).await.unwrap() {
            gen::GetBlockWithTxsResult::BlockWithTxs(block) => block,
            _ => panic!("got pending block for some reason..."),
        };
        let hash = block.block_header.block_hash.0.as_ref();
        let number = block.block_header.block_number.as_ref();
        println!("{}", serde_json::to_string_pretty(&block).unwrap());

        let block_hash = gen::BlockHash(gen::Felt::try_new(hash).unwrap());
        let block_id = gen::BlockId::BlockHash { block_hash };
        let state = client.getStateUpdate(block_id).await.unwrap();
        println!("{}", serde_json::to_string_pretty(&state).unwrap());

        let events = client
            .getEvents(gen::GetEventsFilter {
                event_filter: gen::EventFilter {
                    from_block: Some(gen::BlockId::BlockNumber {
                        block_number: gen::BlockNumber::try_new(*number - 10)
                            .unwrap(),
                    }),
                    to_block: Some(gen::BlockId::BlockNumber {
                        block_number: gen::BlockNumber::try_new(*number)
                            .unwrap(),
                    }),
                    address: None,
                    keys: None,
                },
                result_page_request: gen::ResultPageRequest {
                    continuation_token: None,
                    chunk_size: gen::ResultPageRequestChunkSize::try_new(1000)
                        .unwrap(),
                },
            })
            .await
            .unwrap();
        println!("{}", serde_json::to_string_pretty(&events).unwrap());

        tracing::debug!("block hash: {hash}");
        tracing::debug!("block number: {number}");
    }
}