echonet: refactor, remove class log (#10580)

* echonet: add l1 manager class, functions with default results

* echonet: refactor, remove class log

Author: ayeletstarkware

echonet/l1_blocks.py

@@ -39,10 +39,11 @@ def find_l1_block_for_tx(
             l1_event = L1Events.parse_event(log)
 
             if L1Events.l1_event_matches_feeder_tx(l1_event, feeder_tx):
+                # TODO(Ayelet): Add blockNumber to L1Event.
                 logger.info(
-                    f"Found matching L1 block: {log.block_number} for L1 tx: {feeder_tx['transaction_hash']}"
+                    f"Found matching L1 block: {log['blockNumber']} for L1 tx: {feeder_tx['transaction_hash']}"
                 )
-                return log.block_number
+                return int(log["blockNumber"], 16)
 
         # Not found in this range
         logger.info(f"No matching L1 block found for L1 tx: {feeder_tx['transaction_hash']}")

echonet/l1_client.py

@@ -1,4 +1,3 @@
-from dataclasses import dataclass
 from datetime import datetime, timezone
 from typing import Any, Callable, Dict, List, Optional
 
@@ -15,23 +14,6 @@ class L1Client:
         "https://api.g.alchemy.com/data/v1/{api_key}/utility/blocks/by-timestamp"
     )
 
-    @dataclass(frozen=True)
-    class Log:
-        """
-        Ethereum log entry
-        """
-
-        address: str
-        topics: List[str]
-        data: str
-        block_number: int
-        block_hash: str
-        transaction_hash: str
-        transaction_index: int
-        log_index: int
-        removed: bool
-        block_timestamp: int
-
     def __init__(
         self,
         api_key: str,
@@ -76,7 +58,7 @@ def _run_request_with_retry(
 
         return None
 
-    def get_logs(self, from_block: int, to_block: int) -> List["L1Client.Log"]:
+    def get_logs(self, from_block: int, to_block: int) -> List[dict]:
         """
         Get logs from Ethereum using eth_getLogs RPC method.
         Tries up to retries_count times. On failure, logs an error and returns [].
@@ -112,22 +94,7 @@ def get_logs(self, from_block: int, to_block: int) -> List["L1Client.Log"]:
             return []
 
         results = data.get("result", [])
-
-        return [
-            L1Client.Log(
-                address=result["address"],
-                topics=result["topics"],
-                data=result["data"],
-                block_number=int(result["blockNumber"], 16),
-                block_hash=result["blockHash"],
-                transaction_hash=result["transactionHash"],
-                transaction_index=int(result["transactionIndex"], 16),
-                log_index=int(result["logIndex"], 16),
-                removed=result["removed"],
-                block_timestamp=int(result["blockTimestamp"], 16),
-            )
-            for result in results
-        ]
+        return results
 
     def get_block_by_number(self, block_number: int) -> Optional[Dict]:
         """

echonet/l1_events.py

@@ -6,7 +6,6 @@
 from typing import List
 
 import eth_abi
-from l1_client import L1Client
 from l1_constants import LOG_MESSAGE_TO_L2_EVENT_SIGNATURE
 
 
@@ -40,14 +39,17 @@ class L1Event:
         l1_tx_hash: str
         block_timestamp: int
 
-    def decode_log(log: L1Client.Log) -> DecodedLogMessageToL2:
+    def decode_log(log: dict) -> DecodedLogMessageToL2:
         """
         Decodes Ethereum log from Starknet L1 contract into DecodedLogMessageToL2 event.
         Event structure defined in: crates/papyrus_base_layer/resources/Starknet-0.10.3.4.json
         """
-        topics = log.topics
+        if not all(key in log for key in ("topics", "data", "transactionHash", "blockTimestamp")):
+            raise ValueError("Log is missing required fields for decoding")
+
+        topics = log["topics"]
         if len(topics) < 4:
-            raise ValueError("Log has no topics or insufficient topics for LogMessageToL2 event")
+            raise ValueError("Log has insufficient topics for LogMessageToL2 event")
         event_signature = topics[0]
         if event_signature != LOG_MESSAGE_TO_L2_EVENT_SIGNATURE:
             raise ValueError(f"Unhandled event signature: {event_signature}")
@@ -58,9 +60,10 @@ def decode_log(log: L1Client.Log) -> DecodedLogMessageToL2:
         selector = int(topics[3], 16)
 
         # Non-indexed params (data): payload[], nonce, fee
-        if not log.data.startswith("0x"):
+        data = log["data"]
+        if not data.startswith("0x"):
             raise ValueError("Log data must start with '0x'")
-        data_bytes = bytes.fromhex(log.data[2:])  # Remove 0x prefix and convert to bytes
+        data_bytes = bytes.fromhex(data[2:])  # Remove 0x prefix and convert to bytes
         payload, nonce, fee = eth_abi.decode(["uint256[]", "uint256", "uint256"], data_bytes)
 
         return L1Events.DecodedLogMessageToL2(
@@ -70,12 +73,12 @@ def decode_log(log: L1Client.Log) -> DecodedLogMessageToL2:
             payload=list(payload),
             nonce=nonce,
             fee=fee,
-            l1_tx_hash=log.transaction_hash,
-            block_timestamp=log.block_timestamp,
+            l1_tx_hash=log["transactionHash"],
+            block_timestamp=int(log["blockTimestamp"], 16),
         )
 
     @staticmethod
-    def parse_event(log: L1Client.Log) -> "L1Events.L1Event":
+    def parse_event(log: dict) -> "L1Events.L1Event":
         decoded = L1Events.decode_log(log)
         calldata = [int(decoded.from_address, 16)] + decoded.payload
 

echonet/tests/test_l1_blocks.py

@@ -28,32 +28,32 @@ class TestFindL1BlockForTx(unittest.TestCase):
         "type": "L1_HANDLER",
     }
 
-    def mock_log(self, block_number: int, nonce: int) -> Mock:
-        mock_log = Mock()
-        mock_log.block_number = block_number
-        mock_log.topics = [
-            "0xdb80dd488acf86d17c747445b0eabb5d57c541d3bd7b6b87af987858e5066b2b",
-            "0x000000000000000000000000f5b6ee2caeb6769659f6c091d209dfdcaf3f69eb",
-            "0x0616757a151c21f9be8775098d591c2807316d992bbc3bb1a5c1821630589256",
-            "0x01b64b1b3b690b43b9b514fb81377518f4039cd3e4f4914d8a6bdf01d679fb19",
-        ]
+    def mock_log(self, block_number: int, nonce: int) -> dict:
         nonce_hex = f"{nonce:064x}"
-        mock_log.data = (
-            "0x0000000000000000000000000000000000000000000000000000000000000060"
-            f"{nonce_hex}"
-            "00000000000000000000000000000000000000000000000000001308aba4ade2"
-            "0000000000000000000000000000000000000000000000000000000000000005"
-            "00000000000000000000000004c46e830bb56ce22735d5d8fc9cb90309317d0f"
-            "000000000000000000000000c50a951c4426760ba75c5253985a16196b342168"
-            "011bf9dbebdd770c31ff13808c96a1cb2de15a240274dc527e7d809bb2bf38df"
-            "0000000000000000000000000000000000000000000000956dfdeac59085edc3"
-            "0000000000000000000000000000000000000000000000000000000000000000"
-        )
-        mock_log.transaction_hash = (
-            "0x66c2ef5ae6708ede5e47daaabfc4b54a53c423160ec27eac06524ea3cd939622"
-        )
-        mock_log.block_timestamp = 1727673743
-        return mock_log
+        return {
+            "blockNumber": hex(block_number),
+            "topics": [
+                "0xdb80dd488acf86d17c747445b0eabb5d57c541d3bd7b6b87af987858e5066b2b",
+                "0x000000000000000000000000f5b6ee2caeb6769659f6c091d209dfdcaf3f69eb",
+                "0x0616757a151c21f9be8775098d591c2807316d992bbc3bb1a5c1821630589256",
+                "0x01b64b1b3b690b43b9b514fb81377518f4039cd3e4f4914d8a6bdf01d679fb19",
+            ],
+            "data": (
+                "0x0000000000000000000000000000000000000000000000000000000000000060"
+                f"{nonce_hex}"
+                "00000000000000000000000000000000000000000000000000001308aba4ade2"
+                "0000000000000000000000000000000000000000000000000000000000000005"
+                "00000000000000000000000004c46e830bb56ce22735d5d8fc9cb90309317d0f"
+                "000000000000000000000000c50a951c4426760ba75c5253985a16196b342168"
+                "011bf9dbebdd770c31ff13808c96a1cb2de15a240274dc527e7d809bb2bf38df"
+                "0000000000000000000000000000000000000000000000956dfdeac59085edc3"
+                "0000000000000000000000000000000000000000000000000000000000000000"
+            ),
+            "transactionHash": (
+                "0x66c2ef5ae6708ede5e47daaabfc4b54a53c423160ec27eac06524ea3cd939622"
+            ),
+            "blockTimestamp": hex(1727673743),
+        }
 
     def test_find_l1_block_for_tx_success(self):
         mock_client = Mock(spec=L1Client)

echonet/tests/test_l1_client.py

@@ -38,19 +38,6 @@ class TestL1Client(unittest.TestCase):
         "blockTimestamp": hex(1_727_673_743),
     }
 
-    EXPECTED_LOG_SAMPLE = L1Client.Log(
-        address=RPC_LOG_RESULT_SAMPLE["address"],
-        topics=RPC_LOG_RESULT_SAMPLE["topics"],
-        data=RPC_LOG_RESULT_SAMPLE["data"],
-        block_number=BLOCK_NUMBER_SAMPLE,
-        block_hash=RPC_LOG_RESULT_SAMPLE["blockHash"],
-        transaction_hash=RPC_LOG_RESULT_SAMPLE["transactionHash"],
-        transaction_index=int(RPC_LOG_RESULT_SAMPLE["transactionIndex"], 16),
-        log_index=int(RPC_LOG_RESULT_SAMPLE["logIndex"], 16),
-        removed=RPC_LOG_RESULT_SAMPLE["removed"],
-        block_timestamp=int(RPC_LOG_RESULT_SAMPLE["blockTimestamp"], 16),
-    )
-
     @patch("l1_client.requests.post")
     def test_get_logs_retries_after_exception_and_succeeds_on_second_attempt(self, mock_post):
         request_exception = requests.RequestException("some error")
@@ -68,7 +55,7 @@ def test_get_logs_retries_after_exception_and_succeeds_on_second_attempt(self, m
         )
 
         self.assertEqual(mock_post.call_count, 2)
-        self.assertEqual(logs, [self.EXPECTED_LOG_SAMPLE])
+        self.assertEqual(logs, [self.RPC_LOG_RESULT_SAMPLE])
 
     def test_get_logs_raises_on_invalid_block_range(self):
         client = L1Client(api_key="api_key")
@@ -81,78 +68,6 @@ def test_get_logs_raises_on_invalid_block_range(self):
                 to_block=10,
             )
 
-    @patch("l1_client.requests.post")
-    def test_get_logs_parses_several_results(self, mock_post):
-        response_ok = Mock()
-        response_ok.raise_for_status.return_value = None
-        response_ok.json.return_value = {
-            "result": [
-                {
-                    "address": "0x1",
-                    "topics": [],
-                    "data": "0x01",
-                    "blockNumber": "0x1",
-                    "blockHash": "0xaa",
-                    "transactionHash": "0xa1",
-                    "transactionIndex": "0x0",
-                    "logIndex": "0x0",
-                    "removed": False,
-                    "blockTimestamp": "0x10",
-                },
-                {
-                    "address": "0x2",
-                    "topics": ["0xdead"],
-                    "data": "0x02",
-                    "blockNumber": "0x2",
-                    "blockHash": "0xbb",
-                    "transactionHash": "0xb2",
-                    "transactionIndex": "0x1",
-                    "logIndex": "0x1",
-                    "removed": False,
-                    "blockTimestamp": "0x20",
-                },
-            ]
-        }
-
-        mock_post.return_value = response_ok
-
-        client = L1Client(api_key="api_key")
-        logs = client.get_logs(
-            from_block=1,
-            to_block=2,
-        )
-
-        self.assertEqual(mock_post.call_count, 1)
-
-        expected_logs = [
-            L1Client.Log(
-                address="0x1",
-                topics=[],
-                data="0x01",
-                block_number=1,
-                block_hash="0xaa",
-                transaction_hash="0xa1",
-                transaction_index=0,
-                log_index=0,
-                removed=False,
-                block_timestamp=0x10,
-            ),
-            L1Client.Log(
-                address="0x2",
-                topics=["0xdead"],
-                data="0x02",
-                block_number=2,
-                block_hash="0xbb",
-                transaction_hash="0xb2",
-                transaction_index=1,
-                log_index=1,
-                removed=False,
-                block_timestamp=0x20,
-            ),
-        ]
-
-        self.assertEqual(logs, expected_logs)
-
     @patch("l1_client.requests.post")
     def test_get_logs_when_rpc_result_is_empty(self, mock_post):
         response_ok = Mock()

echonet/tests/test_l1_events.py

@@ -6,7 +6,6 @@
 
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
 
-from l1_client import L1Client
 from l1_events import L1Events
 
 
@@ -37,32 +36,6 @@ class TestL1Events(unittest.TestCase):
         "removed": False,
     }
 
-    L1_CLIENT_LOG = L1Client.Log(
-        address="0xc662c410c0ecf747543f5ba90660f6abebd9c8c4",
-        topics=[
-            "0xdb80dd488acf86d17c747445b0eabb5d57c541d3bd7b6b87af987858e5066b2b",
-            "0x000000000000000000000000f5b6ee2caeb6769659f6c091d209dfdcaf3f69eb",
-            "0x0616757a151c21f9be8775098d591c2807316d992bbc3bb1a5c1821630589256",
-            "0x01b64b1b3b690b43b9b514fb81377518f4039cd3e4f4914d8a6bdf01d679fb19",
-        ],
-        data="0x0000000000000000000000000000000000000000000000000000000000000060"
-        "000000000000000000000000000000000000000000000000000000000019b255"
-        "00000000000000000000000000000000000000000000000000001308aba4ade2"
-        "0000000000000000000000000000000000000000000000000000000000000005"
-        "00000000000000000000000004c46e830bb56ce22735d5d8fc9cb90309317d0f"
-        "000000000000000000000000c50a951c4426760ba75c5253985a16196b342168"
-        "011bf9dbebdd770c31ff13808c96a1cb2de15a240274dc527e7d809bb2bf38df"
-        "0000000000000000000000000000000000000000000000956dfdeac59085edc3"
-        "0000000000000000000000000000000000000000000000000000000000000000",
-        block_number=23911042,
-        block_hash="0xb33512d13e1a2ff4f3aa6e799a4a2455249be5198760a3f41300a8362d802bf8",
-        transaction_hash="0x726df509fdd23a944f923a6fc18e80cbe7300a54aa34f8e6bd77e9961ca6ce52",
-        transaction_index=79,
-        log_index=123,
-        removed=False,
-        block_timestamp=1764500447,
-    )
-
     DECODED_LOG = L1Events.DecodedLogMessageToL2(
         from_address="0xf5b6ee2caeb6769659f6c091d209dfdcaf3f69eb",
         to_address="0x616757a151c21f9be8775098d591c2807316d992bbc3bb1a5c1821630589256",
@@ -118,37 +91,27 @@ class TestL1Events(unittest.TestCase):
     }
 
     def test_decode_log_success(self):
-        decoded_log_result = L1Events.decode_log(self.L1_CLIENT_LOG)
+        decoded_log_result = L1Events.decode_log(self.RAW_JSON_LOG)
 
         self.assertIsInstance(decoded_log_result, L1Events.DecodedLogMessageToL2)
         self.assertEqual(decoded_log_result, self.DECODED_LOG)
 
     def test_decode_log_invalid_topics_raises_error(self):
         with self.assertRaisesRegex(
-            ValueError, "Log has no topics or insufficient topics for LogMessageToL2 event"
+            ValueError, "Log has insufficient topics for LogMessageToL2 event"
         ):
-            log = L1Client.Log(
-                address="0x0",
-                topics=[],
-                data="0x",
-                block_number=0,
-                block_hash="0x0",
-                transaction_hash="0x0",
-                transaction_index=0,
-                log_index=0,
-                removed=False,
-                block_timestamp=0,
-            )
+            log = copy.deepcopy(self.RAW_JSON_LOG)
+            log["topics"] = ["0x1", "0x2"]
             L1Events.decode_log(log)
 
     def test_decode_log_wrong_signature_raises_error(self):
-        log = copy.deepcopy(self.L1_CLIENT_LOG)
-        log.topics[0] = "0x0000000000000000000000000000000000000000000000000000000000000001"
+        log = copy.deepcopy(self.RAW_JSON_LOG)
+        log["topics"][0] = "0x0000000000000000000000000000000000000000000000000000000000000001"
         with self.assertRaisesRegex(ValueError, "Unhandled event signature"):
             L1Events.decode_log(log)
 
     def test_parse_event_success(self):
-        result = L1Events.parse_event(self.L1_CLIENT_LOG)
+        result = L1Events.parse_event(self.RAW_JSON_LOG)
         self.assertIsInstance(result, L1Events.L1Event)
 
         self.assertEqual(result, self.L1_EVENT)