Skip to content

Commit 1482393

Browse files
LeoPatOZLeoPatOZ
authored
Remove pending block support (#248)
1 parent 0bfd0c9 commit 1482393

File tree

2 files changed

+202
-4
lines changed

2 files changed

+202
-4
lines changed

‎src/event_scanner/scanner/historic.rs‎

Lines changed: 101 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -12,12 +12,24 @@ use crate::{
1212
};
1313

1414
impl EventScannerBuilder<Historic> {
15+
/// Sets the starting block for the historic scan.
16+
///
17+
/// # Note
18+
///
19+
/// Although passing `BlockNumberOrTag::Pending` will compile, the subsequent call to
20+
/// `connect` will fail at runtime. See issue <https://github.com/OpenZeppelin/Event-Scanner/issues/244>
1521
#[must_use]
1622
pub fn from_block(mut self, block_id: impl Into<BlockId>) -> Self {
1723
self.config.from_block = block_id.into();
1824
self
1925
}
2026

27+
/// Sets the starting block for the historic scan.
28+
///
29+
/// # Note
30+
///
31+
/// Although passing `BlockNumberOrTag::Pending` will compile, the subsequent call to
32+
/// `connect` will fail at runtime. See issue <https://github.com/OpenZeppelin/Event-Scanner/issues/244>
2133
#[must_use]
2234
pub fn to_block(mut self, block_id: impl Into<BlockId>) -> Self {
2335
self.config.to_block = block_id.into();
@@ -45,7 +57,17 @@ impl EventScannerBuilder<Historic> {
4557
let latest_block = provider.get_block_number().await?;
4658

4759
let from_num = match scanner.config.from_block {
48-
BlockId::Number(from_block) => from_block.as_number().unwrap_or(0),
60+
BlockId::Number(from_block) => {
61+
if from_block.is_pending() {
62+
return Err(ScannerError::BlockExceedsLatest(
63+
"from_block",
64+
latest_block + 1,
65+
latest_block,
66+
));
67+
}
68+
// can safely unwrap to 0 because any other tag < latest block
69+
from_block.as_number().unwrap_or(0)
70+
}
4971
BlockId::Hash(from_hash) => {
5072
provider.get_block_by_hash(from_hash.into()).await?.header().number()
5173
}
@@ -56,7 +78,17 @@ impl EventScannerBuilder<Historic> {
5678
}
5779

5880
let to_num = match scanner.config.to_block {
59-
BlockId::Number(to_block) => to_block.as_number().unwrap_or(0),
81+
BlockId::Number(to_block) => {
82+
if to_block.is_pending() {
83+
return Err(ScannerError::BlockExceedsLatest(
84+
"to_block",
85+
latest_block + 1,
86+
latest_block,
87+
));
88+
}
89+
// can safely unwrap to 0 because any other tag < latest block
90+
to_block.as_number().unwrap_or(0)
91+
}
6092
BlockId::Hash(to_hash) => {
6193
provider.get_block_by_hash(to_hash.into()).await?.header().number()
6294
}
@@ -332,4 +364,71 @@ mod tests {
332364

333365
assert!(result.is_ok());
334366
}
367+
368+
#[tokio::test]
369+
async fn test_from_block_pending_returns_error() {
370+
let anvil = Anvil::new().try_spawn().unwrap();
371+
let provider = ProviderBuilder::new().connect_http(anvil.endpoint_url());
372+
373+
let latest_block = provider.get_block_number().await.unwrap();
374+
375+
let result = EventScannerBuilder::historic()
376+
.from_block(BlockNumberOrTag::Pending)
377+
.to_block(latest_block)
378+
.connect(provider)
379+
.await;
380+
381+
match result {
382+
Err(ScannerError::BlockExceedsLatest("from_block", max, latest)) => {
383+
assert_eq!(max, latest_block + 1);
384+
assert_eq!(latest, latest_block);
385+
}
386+
_ => panic!("Expected BlockExceedsLatest error for 'from_block'"),
387+
}
388+
}
389+
390+
#[tokio::test]
391+
async fn test_to_block_pending_returns_error() {
392+
let anvil = Anvil::new().try_spawn().unwrap();
393+
let provider = ProviderBuilder::new().connect_http(anvil.endpoint_url());
394+
395+
let latest_block = provider.get_block_number().await.unwrap();
396+
397+
let result = EventScannerBuilder::historic()
398+
.from_block(0)
399+
.to_block(BlockNumberOrTag::Pending)
400+
.connect(provider)
401+
.await;
402+
403+
match result {
404+
Err(ScannerError::BlockExceedsLatest("to_block", max, latest)) => {
405+
assert_eq!(max, latest_block + 1);
406+
assert_eq!(latest, latest_block);
407+
}
408+
_ => panic!("Expected BlockExceedsLatest error for 'to_block'"),
409+
}
410+
}
411+
412+
#[tokio::test]
413+
async fn test_from_and_to_block_pending_returns_error() {
414+
let anvil = Anvil::new().try_spawn().unwrap();
415+
let provider = ProviderBuilder::new().connect_http(anvil.endpoint_url());
416+
417+
let latest_block = provider.get_block_number().await.unwrap();
418+
419+
let result = EventScannerBuilder::historic()
420+
.from_block(BlockNumberOrTag::Pending)
421+
.to_block(BlockNumberOrTag::Pending)
422+
.connect(provider)
423+
.await;
424+
425+
// from_block is checked first
426+
match result {
427+
Err(ScannerError::BlockExceedsLatest("from_block", max, latest)) => {
428+
assert_eq!(max, latest_block + 1);
429+
assert_eq!(latest, latest_block);
430+
}
431+
_ => panic!("Expected BlockExceedsLatest error for 'from_block'"),
432+
}
433+
}
335434
}

‎src/event_scanner/scanner/latest.rs‎

Lines changed: 101 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -18,12 +18,24 @@ impl EventScannerBuilder<LatestEvents> {
1818
self
1919
}
2020

21+
/// Sets the starting block for the historic scan.
22+
///
23+
/// # Note
24+
///
25+
/// Although passing `BlockNumberOrTag::Pending` will compile, the subsequent call to
26+
/// `connect` will fail at runtime. See issue <https://github.com/OpenZeppelin/Event-Scanner/issues/244>
2127
#[must_use]
2228
pub fn from_block(mut self, block_id: impl Into<BlockId>) -> Self {
2329
self.config.from_block = block_id.into();
2430
self
2531
}
2632

33+
/// Sets the starting block for the historic scan.
34+
///
35+
/// # Note
36+
///
37+
/// Although passing `BlockNumberOrTag::Pending` will compile, the subsequent call to
38+
/// `connect` will fail at runtime. See issue <https://github.com/OpenZeppelin/Event-Scanner/issues/244>
2739
#[must_use]
2840
pub fn to_block(mut self, block_id: impl Into<BlockId>) -> Self {
2941
self.config.to_block = block_id.into();
@@ -52,7 +64,17 @@ impl EventScannerBuilder<LatestEvents> {
5264
let latest_block = provider.get_block_number().await?;
5365

5466
let from_num = match scanner.config.from_block {
55-
BlockId::Number(from_block) => from_block.as_number().unwrap_or(0),
67+
BlockId::Number(from_block) => {
68+
if from_block.is_pending() {
69+
return Err(ScannerError::BlockExceedsLatest(
70+
"from_block",
71+
latest_block + 1,
72+
latest_block,
73+
));
74+
}
75+
// can safely unwrap to 0 because any other tag < latest block
76+
from_block.as_number().unwrap_or(0)
77+
}
5678
BlockId::Hash(from_hash) => {
5779
provider.get_block_by_hash(from_hash.into()).await?.header().number()
5880
}
@@ -63,7 +85,17 @@ impl EventScannerBuilder<LatestEvents> {
6385
}
6486

6587
let to_num = match scanner.config.to_block {
66-
BlockId::Number(to_block) => to_block.as_number().unwrap_or(0),
88+
BlockId::Number(to_block) => {
89+
if to_block.is_pending() {
90+
return Err(ScannerError::BlockExceedsLatest(
91+
"to_block",
92+
latest_block + 1,
93+
latest_block,
94+
));
95+
}
96+
// can safely unwrap to 0 because any other tag < latest block
97+
to_block.as_number().unwrap_or(0)
98+
}
6799
BlockId::Hash(to_hash) => {
68100
provider.get_block_by_hash(to_hash.into()).await?.header().number()
69101
}
@@ -366,4 +398,71 @@ mod tests {
366398
_ => panic!("Expected BlockExceedsLatest error for 'from_block'"),
367399
}
368400
}
401+
402+
#[tokio::test]
403+
async fn test_from_block_pending_returns_error() {
404+
let anvil = Anvil::new().try_spawn().unwrap();
405+
let provider = ProviderBuilder::new().connect_http(anvil.endpoint_url());
406+
407+
let latest_block = provider.get_block_number().await.unwrap();
408+
409+
let result = EventScannerBuilder::latest(1)
410+
.from_block(BlockNumberOrTag::Pending)
411+
.to_block(latest_block)
412+
.connect(provider)
413+
.await;
414+
415+
match result {
416+
Err(ScannerError::BlockExceedsLatest("from_block", max, latest)) => {
417+
assert_eq!(max, latest_block + 1);
418+
assert_eq!(latest, latest_block);
419+
}
420+
_ => panic!("Expected BlockExceedsLatest error for 'from_block'"),
421+
}
422+
}
423+
424+
#[tokio::test]
425+
async fn test_to_block_pending_returns_error() {
426+
let anvil = Anvil::new().try_spawn().unwrap();
427+
let provider = ProviderBuilder::new().connect_http(anvil.endpoint_url());
428+
429+
let latest_block = provider.get_block_number().await.unwrap();
430+
431+
let result = EventScannerBuilder::latest(1)
432+
.from_block(0)
433+
.to_block(BlockNumberOrTag::Pending)
434+
.connect(provider)
435+
.await;
436+
437+
match result {
438+
Err(ScannerError::BlockExceedsLatest("to_block", max, latest)) => {
439+
assert_eq!(max, latest_block + 1);
440+
assert_eq!(latest, latest_block);
441+
}
442+
_ => panic!("Expected BlockExceedsLatest error for 'to_block'"),
443+
}
444+
}
445+
446+
#[tokio::test]
447+
async fn test_from_and_to_block_pending_returns_error() {
448+
let anvil = Anvil::new().try_spawn().unwrap();
449+
let provider = ProviderBuilder::new().connect_http(anvil.endpoint_url());
450+
451+
let latest_block = provider.get_block_number().await.unwrap();
452+
453+
let result = EventScannerBuilder::latest(1)
454+
.from_block(BlockNumberOrTag::Pending)
455+
.to_block(BlockNumberOrTag::Pending)
456+
.connect(provider)
457+
.await;
458+
459+
// from_block is checked first
460+
match result {
461+
Err(ScannerError::BlockExceedsLatest("from_block", max, latest)) => {
462+
assert_eq!(max, latest_block + 1);
463+
assert_eq!(latest, latest_block);
464+
}
465+
_ => panic!("Expected BlockExceedsLatest error for 'from_block'"),
466+
}
467+
}
369468
}

0 commit comments

Comments
 (0)