client to scanner

Author: LeoPatOZ

examples/historical_scanning/main.rs

@@ -54,13 +54,13 @@ async fn main() -> anyhow::Result<()> {
 
     let _ = counter_contract.increase().send().await?.get_receipt().await?;
 
-    let mut client =
+    let mut scanner =
         EventScanner::historic().connect_ws::<Ethereum>(anvil.ws_endpoint_url()).await?;
 
-    let mut stream = client.create_event_stream(increase_filter);
+    let mut stream = scanner.create_event_stream(increase_filter);
 
     sleep(Duration::from_secs(10)).await;
-    client.run().await.expect("failed to start scanner");
+    scanner.run().await.expect("failed to start scanner");
 
     while let Some(message) = stream.next().await {
         match message {

examples/simple_counter/main.rs

@@ -52,12 +52,12 @@ async fn main() -> anyhow::Result<()> {
         .with_contract_address(*contract_address)
         .with_event(Counter::CountIncreased::SIGNATURE);
 
-    let mut client = EventScanner::live().connect_ws::<Ethereum>(anvil.ws_endpoint_url()).await?;
+    let mut scanner = EventScanner::live().connect_ws::<Ethereum>(anvil.ws_endpoint_url()).await?;
 
-    let mut stream = client.create_event_stream(increase_filter);
+    let mut stream = scanner.create_event_stream(increase_filter);
 
     let task_1 = tokio::spawn(async move {
-        client.start().await.expect("failed to start scanner");
+        scanner.start().await.expect("failed to start scanner");
     });
 
     let task_2 = tokio::spawn(async move {

tests/common.rs

@@ -66,15 +66,15 @@ pub async fn setup_live_scanner(
 
     let filter = filter.unwrap_or(default_filter);
 
-    let mut client = EventScanner::live()
+    let mut scanner = EventScanner::live()
         .block_confirmations(confirmations)
         .connect_ws(anvil.ws_endpoint_url())
         .await?;
 
-    let stream = client.create_event_stream(filter);
+    let stream = scanner.create_event_stream(filter);
 
     // return anvil otherwise it doesnt live long enough...
-    Ok(LiveScannerSetup { provider, contract, scanner: client, stream, anvil })
+    Ok(LiveScannerSetup { provider, contract, scanner: scanner, stream, anvil })
 }
 
 #[allow(clippy::missing_errors_doc)]

tests/historic_mode/basic.rs

@@ -35,14 +35,14 @@ async fn processes_events_within_specified_historical_range() -> anyhow::Result<
         end_block = receipt.block_number.expect("receipt should contain block number");
     }
 
-    let mut client = EventScanner::historic()
+    let mut scanner = EventScanner::historic()
         .from_block(start_block)
         .to_block(end_block)
         .connect_ws::<Ethereum>(anvil.ws_endpoint_url())
         .await?;
-    let mut stream = client.create_event_stream(filter).take(expected_event_count);
+    let mut stream = scanner.create_event_stream(filter).take(expected_event_count);
 
-    tokio::spawn(async move { client.run().await });
+    tokio::spawn(async move { scanner.run().await });
 
     let event_count = Arc::new(AtomicUsize::new(0));
     let event_count_clone = Arc::clone(&event_count);

tests/historic_to_live/basic.rs

@@ -35,14 +35,14 @@ async fn replays_historical_then_switches_to_live() -> anyhow::Result<()> {
         .with_contract_address(contract_address)
         .with_event(TestCounter::CountIncreased::SIGNATURE);
 
-    let mut client = EventScanner::sync()
+    let mut scanner = EventScanner::sync()
         .from_block(first_historical_block)
         .connect_ws::<Ethereum>(anvil.ws_endpoint_url())
         .await?;
 
-    let mut stream = client.create_event_stream(filter).take(historical_events + live_events);
+    let mut stream = scanner.create_event_stream(filter).take(historical_events + live_events);
 
-    tokio::spawn(async move { client.stream().await });
+    tokio::spawn(async move { scanner.start().await });
 
     for _ in 0..live_events {
         contract.increase().send().await?.watch().await?;

tests/historic_to_live/reorg.rs

@@ -36,7 +36,7 @@ async fn block_confirmations_mitigate_reorgs_historic_to_live() -> anyhow::Resul
 
     let mut stream = scanner.create_event_stream(filter);
 
-    tokio::spawn(async move { scanner.stream().await });
+    tokio::spawn(async move { scanner.start().await });
 
     //  perform a shallow reorg on the live tail
     let num_initial_events = 4u64;

tests/live_mode/basic.rs

@@ -25,10 +25,10 @@ async fn basic_single_event_scanning() -> anyhow::Result<()> {
 
     let expected_event_count = 5;
 
-    let mut client = EventScanner::live().connect_ws::<Ethereum>(anvil.ws_endpoint_url()).await?;
-    let mut stream = client.create_event_stream(filter).take(expected_event_count);
+    let mut scanner = EventScanner::live().connect_ws::<Ethereum>(anvil.ws_endpoint_url()).await?;
+    let mut stream = scanner.create_event_stream(filter).take(expected_event_count);
 
-    tokio::spawn(async move { client.start().await });
+    tokio::spawn(async move { scanner.start().await });
 
     for _ in 0..expected_event_count {
         contract.increase().send().await?.watch().await?;
@@ -83,12 +83,12 @@ async fn multiple_contracts_same_event_isolate_callbacks() -> anyhow::Result<()>
     let expected_events_a = 3;
     let expected_events_b = 2;
 
-    let mut client = EventScanner::live().connect_ws::<Ethereum>(anvil.ws_endpoint_url()).await?;
+    let mut scanner = EventScanner::live().connect_ws::<Ethereum>(anvil.ws_endpoint_url()).await?;
 
-    let a_stream = client.create_event_stream(a_filter);
-    let b_stream = client.create_event_stream(b_filter);
+    let a_stream = scanner.create_event_stream(a_filter);
+    let b_stream = scanner.create_event_stream(b_filter);
 
-    tokio::spawn(async move { client.start().await });
+    tokio::spawn(async move { scanner.start().await });
 
     for _ in 0..expected_events_a {
         a.increase().send().await?.watch().await?;
@@ -155,12 +155,12 @@ async fn multiple_events_same_contract() -> anyhow::Result<()> {
     let expected_incr_events = 6;
     let expected_decr_events = 2;
 
-    let mut client = EventScanner::live().connect_ws::<Ethereum>(anvil.ws_endpoint_url()).await?;
+    let mut scanner = EventScanner::live().connect_ws::<Ethereum>(anvil.ws_endpoint_url()).await?;
 
-    let mut incr_stream = client.create_event_stream(increase_filter).take(expected_incr_events);
-    let mut decr_stream = client.create_event_stream(decrease_filter).take(expected_decr_events);
+    let mut incr_stream = scanner.create_event_stream(increase_filter).take(expected_incr_events);
+    let mut decr_stream = scanner.create_event_stream(decrease_filter).take(expected_decr_events);
 
-    tokio::spawn(async move { client.start().await });
+    tokio::spawn(async move { scanner.start().await });
 
     for _ in 0..expected_incr_events {
         contract.increase().send().await?.watch().await?;
@@ -223,11 +223,11 @@ async fn signature_matching_ignores_irrelevant_events() -> anyhow::Result<()> {
 
     let num_of_events = 3;
 
-    let mut client = EventScanner::live().connect_ws::<Ethereum>(anvil.ws_endpoint_url()).await?;
+    let mut scanner = EventScanner::live().connect_ws::<Ethereum>(anvil.ws_endpoint_url()).await?;
 
-    let mut stream = client.create_event_stream(filter).take(num_of_events);
+    let mut stream = scanner.create_event_stream(filter).take(num_of_events);
 
-    tokio::spawn(async move { client.start().await });
+    tokio::spawn(async move { scanner.start().await });
 
     for _ in 0..num_of_events {
         contract.increase().send().await?.watch().await?;
@@ -256,11 +256,11 @@ async fn live_filters_malformed_signature_graceful() -> anyhow::Result<()> {
 
     let num_of_events = 3;
 
-    let mut client = EventScanner::live().connect_ws::<Ethereum>(anvil.ws_endpoint_url()).await?;
+    let mut scanner = EventScanner::live().connect_ws::<Ethereum>(anvil.ws_endpoint_url()).await?;
 
-    let mut stream = client.create_event_stream(filter).take(num_of_events);
+    let mut stream = scanner.create_event_stream(filter).take(num_of_events);
 
-    tokio::spawn(async move { client.start().await });
+    tokio::spawn(async move { scanner.start().await });
 
     for _ in 0..num_of_events {
         contract.increase().send().await?.watch().await?;

tests/live_mode/optional_fields.rs

@@ -19,15 +19,15 @@ async fn track_all_events_from_contract() -> anyhow::Result<()> {
     let contract = deploy_counter(provider.clone()).await?;
     let contract_address = *contract.address();
 
-    let mut client = EventScanner::live().connect_ws::<Ethereum>(anvil.ws_endpoint_url()).await?;
+    let mut scanner = EventScanner::live().connect_ws::<Ethereum>(anvil.ws_endpoint_url()).await?;
 
     // Create filter that tracks ALL events from a specific contract (no event signature specified)
     let filter = EventFilter::new().with_contract_address(contract_address);
     let expected_event_count = 5;
 
-    let mut stream = client.create_event_stream(filter).take(expected_event_count);
+    let mut stream = scanner.create_event_stream(filter).take(expected_event_count);
 
-    tokio::spawn(async move { client.start().await });
+    tokio::spawn(async move { scanner.start().await });
 
     // Generate both increase and decrease events
     for _ in 0..expected_event_count {
@@ -63,11 +63,11 @@ async fn track_all_events_in_block_range() -> anyhow::Result<()> {
     let filter = EventFilter::new();
     let expected_event_count = 3;
 
-    let mut client = EventScanner::live().connect_ws::<Ethereum>(anvil.ws_endpoint_url()).await?;
+    let mut scanner = EventScanner::live().connect_ws::<Ethereum>(anvil.ws_endpoint_url()).await?;
 
-    let mut stream = client.create_event_stream(filter).take(expected_event_count);
+    let mut stream = scanner.create_event_stream(filter).take(expected_event_count);
 
-    tokio::spawn(async move { client.start().await });
+    tokio::spawn(async move { scanner.start().await });
 
     // Generate events from our contract
     for _ in 0..expected_event_count {
@@ -106,13 +106,13 @@ async fn mixed_optional_and_required_filters() -> anyhow::Result<()> {
     let all_events_filter = EventFilter::new();
     let expected_all_count = 3;
 
-    let mut client = EventScanner::live().connect_ws::<Ethereum>(anvil.ws_endpoint_url()).await?;
+    let mut scanner = EventScanner::live().connect_ws::<Ethereum>(anvil.ws_endpoint_url()).await?;
 
     let mut specific_stream =
-        client.create_event_stream(specific_filter).take(expected_specific_count);
-    let mut all_stream = client.create_event_stream(all_events_filter).take(expected_all_count);
+        scanner.create_event_stream(specific_filter).take(expected_specific_count);
+    let mut all_stream = scanner.create_event_stream(all_events_filter).take(expected_all_count);
 
-    tokio::spawn(async move { client.start().await });
+    tokio::spawn(async move { scanner.start().await });
 
     // First increase the counter to have some balance
     for _ in 0..expected_all_count {

tests/live_mode/performance.rs

@@ -24,11 +24,11 @@ async fn high_event_volume_no_loss() -> anyhow::Result<()> {
         .with_event(TestCounter::CountIncreased::SIGNATURE);
     let expected_event_count = 100;
 
-    let mut client = EventScanner::live().connect_ws::<Ethereum>(anvil.ws_endpoint_url()).await?;
+    let mut scanner = EventScanner::live().connect_ws::<Ethereum>(anvil.ws_endpoint_url()).await?;
 
-    let mut stream = client.create_event_stream(filter).take(expected_event_count);
+    let mut stream = scanner.create_event_stream(filter).take(expected_event_count);
 
-    tokio::spawn(async move { client.start().await });
+    tokio::spawn(async move { scanner.start().await });
 
     for _ in 0..expected_event_count {
         contract.increase().send().await?.watch().await?;