fix(update-validator-rewards): pulling mev blocks

current API was dropped. switched to new API to get the same
information.

Author: alextes

src/bin/update-validator-rewards/mev_blocks.rs

@@ -23,15 +23,15 @@ pub async fn sync_mev_blocks(
     let mut start_slot = last_synced_slot.map_or(EARLIEST_AVAILABLE_SLOT, |slot| slot.0 + 1);
 
     while start_slot < last_header.slot().0 {
-        let end_slot = start_slot + 199;
+        let end_slot = start_slot + 200;
 
-        let blocks = relay_api.fetch_mev_blocks(start_slot, end_slot).await;
+        let blocks = relay_api.fetch_mev_blocks(start_slot..end_slot).await;
 
         debug!(start_slot, end_slot, "got {} blocks", blocks.len());
 
         mev_blocks_store.store_blocks(&blocks).await;
 
-        start_slot = end_slot + 1;
+        start_slot = end_slot;
     }
 
     info!(start_slot, "no more blocks to process");
@@ -117,9 +117,9 @@ mod tests {
 
         mock_relay
             .expect_fetch_mev_blocks()
-            .with(eq(1), eq(1 + 199))
+            .with(eq(1..(1 + 200)))
             .times(1)
-            .return_once(move |_start, _end| fetched_blocks);
+            .return_once(move |_slots| fetched_blocks);
 
         mock_store
             .expect_store_blocks()

src/mev_blocks/relay_api.rs

@@ -1,3 +1,5 @@
+use std::ops::Range;
+
 use async_trait::async_trait;
 use mockall::{automock, predicate::*};
 use serde::Deserialize;
@@ -12,11 +14,8 @@ pub const EARLIEST_AVAILABLE_SLOT: i32 = 5616303;
 // These are accepted blocks only.
 #[derive(Deserialize)]
 pub struct MaybeMevBlock {
-    #[serde(rename = "slotNumber")]
-    slot_number: i32,
-    #[serde(rename = "blockNumber")]
+    slot: i32,
     block_number: i32,
-    #[serde(rename = "blockHash")]
     block_hash: String,
     #[serde(rename = "value")]
     bid: Option<WeiNewtype>,
@@ -28,7 +27,7 @@ impl TryFrom<MaybeMevBlock> for MevBlock {
     fn try_from(raw: MaybeMevBlock) -> Result<Self, Self::Error> {
         match raw.bid {
             Some(bid) => Ok(MevBlock {
-                slot: raw.slot_number,
+                slot: raw.slot,
                 block_number: raw.block_number,
                 block_hash: raw.block_hash,
                 bid,
@@ -41,7 +40,8 @@ impl TryFrom<MaybeMevBlock> for MevBlock {
 #[automock]
 #[async_trait]
 pub trait RelayApi {
-    async fn fetch_mev_blocks(&self, start_slot: i32, end_slot: i32) -> Vec<MevBlock>;
+    async fn fetch_mev_block(&self, slot: i32) -> Option<MevBlock>;
+    async fn fetch_mev_blocks(&self, slots: Range<i32>) -> Vec<MevBlock>;
 }
 
 pub struct RelayApiHttp {
@@ -52,7 +52,7 @@ pub struct RelayApiHttp {
 impl RelayApiHttp {
     pub fn new() -> Self {
         Self {
-            server_url: "https://relay.ultrasound.money".into(),
+            server_url: "https://relay-analytics.ultrasound.money".into(),
             client: reqwest::Client::new(),
         }
     }
@@ -73,21 +73,36 @@ impl Default for RelayApiHttp {
 
 #[async_trait]
 impl RelayApi for RelayApiHttp {
-    async fn fetch_mev_blocks(&self, start_slot: i32, end_slot: i32) -> Vec<MevBlock> {
+    async fn fetch_mev_block(&self, slot: i32) -> Option<MevBlock> {
+        let url = format!(
+            "{}/relay/v1/data/bidtraces/proposer_payload_delivered?slot={}",
+            self.server_url, slot
+        );
         self.client
-            .get(format!(
-                "{}/api/block-production?start_slot={}&end_slot={}",
-                self.server_url, start_slot, end_slot
-            ))
+            .get(url)
             .send()
             .await
             .unwrap()
             .json::<Vec<MaybeMevBlock>>()
             .await
-            .unwrap()
-            .into_iter()
-            .filter_map(|block| block.try_into().ok())
-            .collect()
+            .ok()
+            .and_then(|blocks| blocks.into_iter().next())
+            .and_then(|block| block.try_into().ok())
+    }
+
+    async fn fetch_mev_blocks(&self, slots: Range<i32>) -> Vec<MevBlock> {
+        let mut blocks = Vec::new();
+
+        for slot in slots {
+            if let Some(block) = self.fetch_mev_block(slot).await {
+                blocks.push(block);
+            }
+
+            // add small delay to avoid rate limiting
+            tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
+        }
+
+        blocks
     }
 }
 
@@ -101,13 +116,16 @@ mod tests {
     async fn fetch_mev_blocks_test() {
         let mut server = mockito::Server::new();
         server
-            .mock("GET", "/api/block-production?start_slot=0&end_slot=10")
+            .mock(
+                "GET",
+                "/relay/v1/data/bidtraces/proposer_payload_delivered?slot=0",
+            )
             .with_status(200)
             .with_body(
                 json!([{
-                    "slotNumber": 1,
-                    "blockNumber": 9191911,
-                    "blockHash": "abc",
+                    "slot": 0,
+                    "block_number": 9191911,
+                    "block_hash": "abc",
                     "value": "100"
                 }])
                 .to_string(),
@@ -116,11 +134,11 @@ mod tests {
 
         let relay_api = RelayApiHttp::new_with_url(&server.url());
 
-        let blocks = relay_api.fetch_mev_blocks(0, 10).await;
+        let blocks = relay_api.fetch_mev_blocks(0..1).await;
         assert_eq!(blocks.len(), 1);
 
         let block = &blocks[0];
-        assert_eq!(block.slot, 1);
+        assert_eq!(block.slot, 0);
         assert_eq!(block.block_number, 9191911);
         assert_eq!(block.block_hash, "abc");
         assert_eq!(block.bid.0, 100);