Finish Ethereum ScannerFeed

processor/ethereum/src/rpc.rs

@@ -1,6 +1,7 @@
 use core::future::Future;
-use std::sync::Arc;
+use std::{sync::Arc, collections::HashSet};
 
+use alloy_core::primitives::B256;
 use alloy_rpc_types_eth::{BlockTransactionsKind, BlockNumberOrTag};
 use alloy_transport::{RpcError, TransportErrorKind};
 use alloy_simple_request_transport::SimpleRequest;
@@ -8,16 +9,26 @@ use alloy_provider::{Provider, RootProvider};
 
 use serai_client::primitives::{NetworkId, Coin, Amount};
 
+use serai_db::Db;
+
 use scanner::ScannerFeed;
 
-use crate::block::{Epoch, FullEpoch};
+use ethereum_schnorr::PublicKey;
+use ethereum_erc20::{TopLevelTransfer, Erc20};
+use ethereum_router::{Coin as EthereumCoin, InInstruction as EthereumInInstruction, Router};
+
+use crate::{
+  TOKENS, InitialSeraiKey,
+  block::{Epoch, FullEpoch},
+};
 
 #[derive(Clone)]
-pub(crate) struct Rpc {
+pub(crate) struct Rpc<D: Db> {
+  pub(crate) db: D,
   pub(crate) provider: Arc<RootProvider<SimpleRequest>>,
 }
 
-impl ScannerFeed for Rpc {
+impl<D: Db> ScannerFeed for Rpc<D> {
   const NETWORK: NetworkId = NetworkId::Ethereum;
 
   // We only need one confirmation as Ethereum properly finalizes
@@ -62,7 +73,22 @@ impl ScannerFeed for Rpc {
     &self,
     number: u64,
   ) -> impl Send + Future<Output = Result<u64, Self::EphemeralError>> {
-    async move { todo!("TODO") }
+    async move {
+      let header = self
+        .provider
+        .get_block(BlockNumberOrTag::Number(number).into(), BlockTransactionsKind::Hashes)
+        .await?
+        .ok_or_else(|| {
+          TransportErrorKind::Custom(
+            "asked for time of a block our node doesn't have".to_string().into(),
+          )
+        })?
+        .header;
+      // This is monotonic ever since the merge
+      // https://github.com/ethereum/consensus-specs/blob/4afe39822c9ad9747e0f5635cca117c18441ec1b
+      //   /specs/bellatrix/beacon-chain.md?plain=1#L393-L394
+      Ok(header.timestamp)
+    }
   }
 
   fn unchecked_block_header_by_number(
@@ -104,25 +130,91 @@ impl ScannerFeed for Rpc {
         .header;
 
       let end_hash = end_header.hash.into();
-      let time = end_header.timestamp;
 
-      Ok(Epoch { prior_end_hash, start, end_hash, time })
+      Ok(Epoch { prior_end_hash, start, end_hash })
     }
   }
 
-  #[rustfmt::skip] // It wants to improperly format the `async move` to a single line
   fn unchecked_block_by_number(
     &self,
     number: u64,
   ) -> impl Send + Future<Output = Result<Self::Block, Self::EphemeralError>> {
     async move {
-      todo!("TODO")
+      let epoch = self.unchecked_block_header_by_number(number).await?;
+      let mut instructions = vec![];
+      let mut executed = vec![];
+
+      let Some(router) = Router::new(
+        self.provider.clone(),
+        &PublicKey::new(
+          InitialSeraiKey::get(&self.db).expect("fetching a block yet never confirmed a key").0,
+        )
+        .expect("initial key used by Serai wasn't representable on Ethereum"),
+      )
+      .await?
+      else {
+        // The Router wasn't deployed yet so we cannot have any on-chain interactions
+        // If the Router has been deployed by the block we've synced to, it won't have any events
+        // for these blocks anways, so this doesn't risk a consensus split
+        // TODO: This does as we can have top-level transfers to the router before it's deployed
+        return Ok(FullEpoch { epoch, instructions, executed });
+      };
+
+      let mut to_check = epoch.end_hash;
+      while to_check != epoch.prior_end_hash {
+        let to_check_block = self
+          .provider
+          .get_block(B256::from(to_check).into(), BlockTransactionsKind::Hashes)
+          .await?
+          .ok_or_else(|| {
+            TransportErrorKind::Custom(
+              format!(
+                "ethereum node didn't have requested block: {}. was the node reset?",
+                hex::encode(to_check)
+              )
+              .into(),
+            )
+          })?
+          .header;
+
+        instructions.append(
+          &mut router.in_instructions(to_check_block.number, &HashSet::from(TOKENS)).await?,
+        );
+        for token in TOKENS {
+          for TopLevelTransfer { id, from, amount, data } in
+            Erc20::new(self.provider.clone(), token)
+              .top_level_transfers(to_check_block.number, router.address())
+              .await?
+          {
+            instructions.push(EthereumInInstruction {
+              id: (id, u64::MAX),
+              from,
+              coin: EthereumCoin::Erc20(token),
+              amount,
+              data,
+            });
+          }
+        }
+
+        executed.append(&mut router.executed(to_check_block.number).await?);
+
+        to_check = *to_check_block.parent_hash;
+      }
+
+      Ok(FullEpoch { epoch, instructions, executed })
     }
   }
 
   fn dust(coin: Coin) -> Amount {
     assert_eq!(coin.network(), NetworkId::Ethereum);
-    todo!("TODO")
+    #[allow(clippy::inconsistent_digit_grouping)]
+    match coin {
+      // 5 USD if Ether is ~3300 USD
+      Coin::Ether => Amount(1_500_00),
+      // 5 DAI
+      Coin::Dai => Amount(5_000_000_00),
+      _ => unreachable!(),
+    }
   }
 
   fn cost_to_aggregate(
@@ -132,7 +224,7 @@ impl ScannerFeed for Rpc {
   ) -> impl Send + Future<Output = Result<Amount, Self::EphemeralError>> {
     async move {
       assert_eq!(coin.network(), NetworkId::Ethereum);
-      // TODO
+      // There is no cost to aggregate as we receive to an account
       Ok(Amount(0))
     }
   }