echonet: refactor alchemy get_block_by_number, return raw value (#10659)

Author: ayeletstarkware

echonet/l1_client.py

@@ -119,22 +119,21 @@ def get_block_by_number(self, block_number: str) -> Optional[Dict]:
         }
 
         request_func = functools.partial(requests.post, self.rpc_url, json=payload)
-        result = self._run_request_with_retry(
+        return self._run_request_with_retry(
             request_func=request_func,
             additional_log_context={"url": self.rpc_url, "block_number": block_number},
         )
 
-        if result is None:
-            return None
-
-        return result.get("result")
-
     def get_timestamp_of_block(self, block_number: str) -> Optional[int]:
         """
         Get block timestamp by block number using eth_getBlockByNumber RPC method.
         Tries up to retries_count times. On failure, logs an error and returns None.
         """
-        block = self.get_block_by_number(block_number)
+        response = self.get_block_by_number(block_number)
+        if response is None:
+            return None
+
+        block = response.get("result")
         if block is None:
             # Block not found
             return None

echonet/tests/test_l1_client.py

@@ -57,82 +57,45 @@ def test_get_logs_when_rpc_result_is_empty(self, mock_post):
         self.assertEqual(mock_post.call_count, 1)
         self.assertEqual(logs, empty_response)
 
-    @patch("l1_client.requests.post")
-    def test_get_timestamp_of_block_retries_after_failure_and_succeeds(self, mock_post):
-        request_exception = requests.RequestException("some error")
-
-        successful_response = Mock()
-        successful_response.raise_for_status.return_value = None
-        successful_response.json.return_value = {"result": {"timestamp": "0x20"}}  # 32
-
-        mock_post.side_effect = [request_exception, successful_response]
-
-        client = L1Client(api_key="api_key")
-        result = client.get_timestamp_of_block(
-            block_number=L1TestUtils.BLOCK_NUMBER_HEX,
-        )
-
-        self.assertEqual(mock_post.call_count, 2)
-        self.assertEqual(result, 32)
-
-    @patch("l1_client.requests.post")
-    def test_get_timestamp_of_block_returns_none_when_rpc_result_is_empty(self, mock_post):
-        response_ok = Mock()
-        response_ok.raise_for_status.return_value = None
-        response_ok.json.return_value = {"result": None}
-
-        mock_post.return_value = response_ok
-
-        client = L1Client(api_key="api_key")
-        result = client.get_timestamp_of_block(
-            block_number=L1TestUtils.BLOCK_NUMBER_HEX,
-        )
-
-        self.assertEqual(mock_post.call_count, 1)
-        self.assertIsNone(result)
-
     @patch("l1_client.requests.post")
     def test_get_block_by_number_retries_after_failure_and_succeeds(self, mock_post):
         request_exception = requests.RequestException("some error")
-        block_info = {
-            "number": L1TestUtils.BLOCK_NUMBER_HEX,
-            "timestamp": "0x5f5e100",
-        }
 
         successful_response = Mock()
         successful_response.raise_for_status.return_value = None
-        successful_response.json.return_value = {"result": block_info}
+        successful_response.json.return_value = L1TestUtils.BLOCK_RPC_RESPONSE
 
         mock_post.side_effect = [request_exception, successful_response]
 
         client = L1Client(api_key="api_key")
         result = client.get_block_by_number(L1TestUtils.BLOCK_NUMBER_HEX)
 
         self.assertEqual(mock_post.call_count, 2)
-        self.assertEqual(result, block_info)
+        self.assertEqual(result, L1TestUtils.BLOCK_RPC_RESPONSE)
 
     @patch("l1_client.requests.post")
     def test_get_block_by_number_returns_none_when_rpc_result_is_empty(self, mock_post):
+        empty_response = L1TestUtils.block_rpc_response_with_block(None)
         response_ok = Mock()
         response_ok.raise_for_status.return_value = None
-        response_ok.json.return_value = {"result": None}
+        response_ok.json.return_value = empty_response
 
         mock_post.return_value = response_ok
 
         client = L1Client(api_key="api_key")
         result = client.get_block_by_number(block_number=L1TestUtils.BLOCK_NUMBER_HEX)
 
         self.assertEqual(mock_post.call_count, 1)
-        self.assertIsNone(result)
+        self.assertEqual(result, empty_response)
 
     @patch.object(L1Client, "get_block_by_number")
     def test_get_timestamp_of_block_returns_int_timestamp(self, mock_get_block_by_number):
-        mock_get_block_by_number.return_value = {"timestamp": "0x5f5e100"}
+        mock_get_block_by_number.return_value = L1TestUtils.BLOCK_RPC_RESPONSE
 
         client = L1Client(api_key="api_key")
         result = client.get_timestamp_of_block(L1TestUtils.BLOCK_NUMBER_HEX)
 
-        self.assertEqual(result, int("0x5f5e100", 16))
+        self.assertEqual(result, L1TestUtils.BLOCK_TIMESTAMP)
         mock_get_block_by_number.assert_called_once_with(L1TestUtils.BLOCK_NUMBER_HEX)
 
     @patch.object(L1Client, "get_block_by_number")
@@ -146,6 +109,17 @@ def test_get_timestamp_of_block_returns_none_when_block_not_found(
 
         self.assertIsNone(result)
 
+    @patch.object(L1Client, "get_block_by_number")
+    def test_get_timestamp_of_block_returns_none_when_result_is_none(
+        self, mock_get_block_by_number
+    ):
+        mock_get_block_by_number.return_value = L1TestUtils.block_rpc_response_with_block(None)
+
+        client = L1Client(api_key="api_key")
+        result = client.get_timestamp_of_block(block_number=L1TestUtils.BLOCK_NUMBER_HEX)
+
+        self.assertIsNone(result)
+
     def test_decode_log_success(self):
         result = L1Client.decode_log_response(L1TestUtils.LOG)
 

echonet/tests/test_utils.py

@@ -7,6 +7,8 @@ class L1TestUtils:
 
     BLOCK_NUMBER = 23911042
     BLOCK_NUMBER_HEX = hex(BLOCK_NUMBER)
+    BLOCK_TIMESTAMP = 1764500447
+    BLOCK_TIMESTAMP_HEX = hex(BLOCK_TIMESTAMP)
     BLOCK_RANGE = [BLOCK_NUMBER - 10, BLOCK_NUMBER + 10]
     NONCE = 0x19B255
 
@@ -30,7 +32,7 @@ class L1TestUtils:
         "0000000000000000000000000000000000000000000000000000000000000000",
         "blockHash": "0xb33512d13e1a2ff4f3aa6e799a4a2455249be5198760a3f41300a8362d802bf8",
         "blockNumber": BLOCK_NUMBER_HEX,
-        "blockTimestamp": "0x692c23df",
+        "blockTimestamp": BLOCK_TIMESTAMP_HEX,
         "transactionHash": "0x726df509fdd23a944f923a6fc18e80cbe7300a54aa34f8e6bd77e9961ca6ce52",
         "transactionIndex": "0x4f",
         "logIndex": "0x7b",
@@ -44,6 +46,19 @@ class L1TestUtils:
         "result": [LOG],
     }
 
+    # Block entry (the "result" content)
+    BLOCK = {
+        "number": BLOCK_NUMBER_HEX,
+        "timestamp": BLOCK_TIMESTAMP_HEX,
+    }
+
+    # Full JSON-RPC response from get_block_by_number
+    BLOCK_RPC_RESPONSE = {
+        "jsonrpc": "2.0",
+        "id": "1",
+        "result": BLOCK,
+    }
+
     L1_EVENT = L1Client.L1Event(
         contract_address="0x616757a151c21f9be8775098d591c2807316d992bbc3bb1a5c1821630589256",
         entry_point_selector=0x1B64B1B3B690B43B9B514FB81377518F4039CD3E4F4914D8A6BDF01D679FB19,
@@ -58,8 +73,8 @@ class L1TestUtils:
         nonce=NONCE,
         fee=0x1308ABA4ADE2,
         l1_tx_hash="0x726df509fdd23a944f923a6fc18e80cbe7300a54aa34f8e6bd77e9961ca6ce52",
-        block_timestamp=1764500447,
-        block_number=23911042,
+        block_timestamp=BLOCK_TIMESTAMP,
+        block_number=BLOCK_NUMBER,
     )
 
     # L1_HANDLER tx from feeder gateway, expected to match the L1_EVENT.
@@ -105,3 +120,12 @@ def logs_rpc_response_with_logs(logs: list) -> dict:
             "id": "1",
             "result": logs,
         }
+
+    @staticmethod
+    def block_rpc_response_with_block(block: dict) -> dict:
+        """Returns a full JSON-RPC response with the given block."""
+        return {
+            "jsonrpc": "2.0",
+            "id": "1",
+            "result": block,
+        }