sequencer_client 0.4.1

A library for reading the Arbitrum Sequencer feed.
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
103
104
105
106
107
108
109

# SequencerClient
 This library is used to read messages from the arbitrum sequencer feed and parses them into alloy transactions.
## Features
### It supports the following transaction types
- L2 Messages
  - Legacy transactions
  - EIP-2930 transactions
  - EIP-1559 transactions
  - EIP-7702 transactions
- Arbitrum Specific Transactions
  - SubmitRetryable
  - More to come (it's a wip)
## Motivation
Listening to the sequencer feed is generally faster than listening through
subscribing to logs. Since existing libraries ignore batch transactions, which 
seemingly make up for 80% of transactions, I created this library.
In the long run, types from this library could be extracted into a seperate crate at some point to support arbitrum tooling in rust.
## Example 
```rust
use color_eyre::install;
use futures_util::stream::StreamExt;
use sequencer_client::reader::SequencerReader;
#[tokio::main()]
async fn main() {
    let url = "wss://arb1-feed.arbitrum.io/feed";
    let subscriber = tracing_subscriber::FmtSubscriber::builder()
        .with_max_level(tracing::Level::DEBUG)
        .finish();
    tracing::subscriber::set_global_default(subscriber)
        .expect("Failed to set global default subscriber");

    tracing::info!("Starting application");

    rustls::crypto::aws_lc_rs::default_provider()
        .install_default()
        .expect("Failed to install rustls crypto provider");

    tracing::info!("Connecting to sequencer at {}", url);

    let reader = SequencerReader::new(url, 42161).await;

    let mut stream = reader.into_stream();
    tracing::info!("Created stream, starting to read messages...");

    let mut count = 0;
    let timeout = std::time::Duration::from_secs(30);

    loop {
        match tokio::time::timeout(timeout, stream.next()).await {
            Ok(Some(msg_result)) => {
                count += 1;
                tracing::info!("Received message #{}", count);

                match msg_result {
                    Ok(msg) => match msg.tx.inner() {
                        sequencer_client::types::transactions::ArbTxEnvelope::Legacy(signed) => {
                            tracing::info!(
                                "Received legacy transaction with hash {}",
                                signed.hash()
                            );
                        }
                        sequencer_client::types::transactions::ArbTxEnvelope::Eip2930(signed) => {
                            tracing::info!(
                                "Received EIP-2930 transaction with hash {}",
                                signed.hash()
                            );
                        }
                        sequencer_client::types::transactions::ArbTxEnvelope::Eip1559(signed) => {
                            tracing::info!(
                                "Received EIP-1559 transaction with hash {}",
                                signed.hash()
                            );
                        }
                        sequencer_client::types::transactions::ArbTxEnvelope::Eip7702(signed) => {
                            tracing::info!(
                                "Received EIP-7702 transaction with hash {}",
                                signed.hash()
                            );
                        }
                        sequencer_client::types::transactions::ArbTxEnvelope::ArbRetryable(
                            tx_submit_retryable,
                        ) => {
                            tracing::info!(
                                "Received ArbRetryable transaction with hash {}",
                                tx_submit_retryable.tx_hash()
                            );
                        }
                    },
                    Err(e) => {
                        tracing::error!("Error in received message: {:?}", e);
                    }
                }
            }
            Ok(None) => {
                tracing::warn!("Stream ended, exiting");
                break;
            }
            Err(_) => {
                tracing::warn!(
                    "No messages received in the last {} seconds",
                    timeout.as_secs()
                );
                tracing::info!("Waiting for messages...");
            }
        }
    }
}

```