do not compile test fillers source code while loading the models

Author: winsvega

Diff for: src/ethereum_test_specs/static_state/account.py

@@ -19,3 +19,4 @@ class Config:
         """Model Config."""
 
         extra = "forbid"
+        arbitrary_types_allowed = True

Diff for: src/ethereum_test_specs/static_state/common/common.py

@@ -3,15 +3,15 @@
 import re
 import subprocess
 import tempfile
-from typing import Tuple
+from functools import cached_property
+from typing import Any
 
 from eth_abi import encode
 from eth_utils import function_signature_to_4byte_selector
-from pydantic import BaseModel, Field
 from pydantic.functional_validators import BeforeValidator
 from typing_extensions import Annotated
 
-from ethereum_test_base_types import Address, Bytes, Hash, HexNumber
+from ethereum_test_base_types import Address, Hash, HexNumber
 
 from .compile_yul import compile_yul
 
@@ -30,12 +30,6 @@ def parse_hex_number(i: str | int) -> int:
     return int(i, 10)
 
 
-class CodeOptions(BaseModel):
-    """Define options of the code."""
-
-    label: str = Field("")
-
-
 def parse_args_from_string_into_array(stream: str, pos: int, delim: str = " "):
     """Parse YUL options into array."""
     args = []
@@ -53,116 +47,135 @@ def parse_args_from_string_into_array(stream: str, pos: int, delim: str = " "):
     return args, pos
 
 
-def parse_code(code: str) -> Tuple[bytes, CodeOptions]:
-    """Check if the given string is a valid code."""
-    # print("parse `" + str(code) + "`")
-    if isinstance(code, int):
-        # Users pass code as int (very bad)
-        hex_str = format(code, "02x")
-        return (bytes.fromhex(hex_str), CodeOptions())
-    if not isinstance(code, str):
-        raise ValueError(f"parse_code(code: str) code is not string: {code}")
-    if len(code) == 0:
-        return (bytes.fromhex(""), CodeOptions())
-
-    compiled_code = ""
-    code_options: CodeOptions = CodeOptions()
-
-    raw_marker = ":raw 0x"
-    raw_index = code.find(raw_marker)
-    abi_marker = ":abi"
-    abi_index = code.find(abi_marker)
+class CodeInFillerSource:
+    """Not compiled code source in test filler."""
+
+    code_label: str | None
+    code_raw: Any
+
+    def __init__(self, code: Any, label: str | None = None):
+        """Instantiate."""
+        self.code_label = label
+        self.code_raw = code
+
+    @cached_property
+    def compiled(self) -> bytes:
+        """Compile the code from source to bytes."""
+        if isinstance(self.code_raw, int):
+            # Users pass code as int (very bad)
+            hex_str = format(self.code_raw, "02x")
+            return bytes.fromhex(hex_str)
+
+        if not isinstance(self.code_raw, str):
+            raise ValueError(f"parse_code(code: str) code is not string: {self.code_raw}")
+        if len(self.code_raw) == 0:
+            return bytes.fromhex("")
+
+        compiled_code = ""
+
+        raw_marker = ":raw 0x"
+        raw_index = self.code_raw.find(raw_marker)
+        abi_marker = ":abi"
+        abi_index = self.code_raw.find(abi_marker)
+        yul_marker = ":yul"
+        yul_index = self.code_raw.find(yul_marker)
+
+        # Prase :raw
+        if raw_index != -1:
+            compiled_code = self.code_raw[raw_index + len(raw_marker) :]
+
+        # Prase :yul
+        elif yul_index != -1:
+            option_start = yul_index + len(yul_marker)
+            options: list[str] = []
+            native_yul_options: str = ""
+
+            if self.code_raw[option_start:].lstrip().startswith("{"):
+                # No yul options, proceed to code parsing
+                source_start = option_start
+            else:
+                opt, source_start = parse_args_from_string_into_array(
+                    self.code_raw, option_start + 1
+                )
+                for arg in opt:
+                    if arg == "object" or arg == '"C"':
+                        native_yul_options += arg + " "
+                    else:
+                        options.append(arg)
+
+                with tempfile.NamedTemporaryFile(mode="w+", delete=False) as tmp:
+                    tmp.write(native_yul_options + self.code_raw[source_start:])
+                    tmp_path = tmp.name
+                compiled_code = compile_yul(
+                    source_file=tmp_path,
+                    evm_version=options[0] if len(options) >= 1 else None,
+                    optimize=options[1] if len(options) >= 2 else None,
+                )[2:]
+
+        # Prase :abi
+        elif abi_index != -1:
+            abi_encoding = self.code_raw[abi_index + len(abi_marker) + 1 :]
+            tokens = abi_encoding.strip().split()
+            abi = tokens[0]
+            function_signature = function_signature_to_4byte_selector(abi)
+            parameter_str = re.sub(r"^\w+", "", abi).strip()
+
+            parameter_types = parameter_str.strip("()").split(",")
+            if len(tokens) > 1:
+                function_parameters = encode(
+                    [parameter_str],
+                    [
+                        [
+                            int(t.lower(), 0) & ((1 << 256) - 1)  # treat big ints as 256bits
+                            if parameter_types[t_index] == "uint"
+                            else int(t.lower(), 0) > 0  # treat positive values as True
+                            if parameter_types[t_index] == "bool"
+                            else False and ValueError("unhandled parameter_types")
+                            for t_index, t in enumerate(tokens[1:])
+                        ]
+                    ],
+                )
+                return function_signature + function_parameters
+            return function_signature
+
+        # Prase plain code 0x
+        elif self.code_raw.lstrip().startswith("0x"):
+            compiled_code = self.code_raw[2:].lower()
+
+        # Prase lllc code
+        elif self.code_raw.lstrip().startswith("{") or self.code_raw.lstrip().startswith("(asm"):
+            binary_path = "lllc"
+            with tempfile.NamedTemporaryFile(mode="w+", delete=False) as tmp:
+                tmp.write(self.code_raw)
+                tmp_path = tmp.name
+            result = subprocess.run([binary_path, tmp_path], capture_output=True, text=True)
+            compiled_code = "".join(result.stdout.splitlines())
+        else:
+            raise Exception(f'Error parsing code: "{self.code_raw}"')
+
+        try:
+            return bytes.fromhex(compiled_code)
+        except ValueError as e:
+            raise Exception(f'Error parsing compile code: "{self.code_raw}"') from e
+
+
+def parse_code_label(code) -> CodeInFillerSource:
+    """Parse label from code."""
     label_marker = ":label"
     label_index = code.find(label_marker)
-    yul_marker = ":yul"
-    yul_index = code.find(yul_marker)
 
     # Parse :label into code options
+    label = None
     if label_index != -1:
         space_index = code.find(" ", label_index + len(label_marker) + 1)
         if space_index == -1:
             label = code[label_index + len(label_marker) + 1 :]
         else:
             label = code[label_index + len(label_marker) + 1 : space_index]
-        code_options.label = label
-
-    # Prase :raw
-    if raw_index != -1:
-        compiled_code = code[raw_index + len(raw_marker) :]
-
-    elif yul_index != -1:
-        option_start = yul_index + len(yul_marker)
-        options: list[str] = []
-        native_yul_options: str = ""
-
-        if code[option_start:].lstrip().startswith("{"):
-            # No yul options, proceed to code parsing
-            source_start = option_start
-        else:
-            opt, source_start = parse_args_from_string_into_array(code, option_start + 1)
-            for arg in opt:
-                if arg == "object" or arg == '"C"':
-                    native_yul_options += arg + " "
-                else:
-                    options.append(arg)
-
-        with tempfile.NamedTemporaryFile(mode="w+", delete=False) as tmp:
-            tmp.write(native_yul_options + code[source_start:])
-            tmp_path = tmp.name
-        compiled_code = compile_yul(
-            source_file=tmp_path,
-            evm_version=options[0] if len(options) >= 1 else None,
-            optimize=options[1] if len(options) >= 2 else None,
-        )[2:]
-
-    # Prase :abi
-    elif abi_index != -1:
-        abi_encoding = code[abi_index + len(abi_marker) + 1 :]
-        tokens = abi_encoding.strip().split()
-        abi = tokens[0]
-        function_signature = function_signature_to_4byte_selector(abi)
-        parameter_str = re.sub(r"^\w+", "", abi).strip()
-
-        parameter_types = parameter_str.strip("()").split(",")
-        if len(tokens) > 1:
-            function_parameters = encode(
-                [parameter_str],
-                [
-                    [
-                        int(t.lower(), 0) & ((1 << 256) - 1)  # treat big ints as 256bits
-                        if parameter_types[t_index] == "uint"
-                        else int(t.lower(), 0) > 0  # treat positive values as True
-                        if parameter_types[t_index] == "bool"
-                        else False and ValueError("unhandled parameter_types")
-                        for t_index, t in enumerate(tokens[1:])
-                    ]
-                ],
-            )
-            return (function_signature + function_parameters, code_options)
-        return (function_signature, code_options)
-
-    # Prase plain code 0x
-    elif code.lstrip().startswith("0x"):
-        compiled_code = code[2:].lower()
-
-    # Prase lllc code
-    elif code.lstrip().startswith("{") or code.lstrip().startswith("(asm"):
-        binary_path = "lllc"
-        with tempfile.NamedTemporaryFile(mode="w+", delete=False) as tmp:
-            tmp.write(code)
-            tmp_path = tmp.name
-        result = subprocess.run([binary_path, tmp_path], capture_output=True, text=True)
-        compiled_code = "".join(result.stdout.splitlines())
-    else:
-        raise Exception(f'Error parsing code: "{code}"')
-
-    try:
-        return (bytes.fromhex(compiled_code), code_options)
-    except ValueError as e:
-        raise Exception(f'Error parsing compile code: "{code}"') from e
+    return CodeInFillerSource(code, label)
 
 
 AddressInFiller = Annotated[Address, BeforeValidator(lambda a: Address(a, left_padding=True))]
 ValueInFiller = Annotated[HexNumber, BeforeValidator(parse_hex_number)]
-CodeInFiller = Annotated[Tuple[Bytes, CodeOptions], BeforeValidator(parse_code)]
+CodeInFiller = Annotated[CodeInFillerSource, BeforeValidator(parse_code_label)]
 Hash32InFiller = Annotated[Hash, BeforeValidator(lambda h: Hash(h, left_padding=True))]

Diff for: src/ethereum_test_specs/static_state/expect_section.py

@@ -38,6 +38,7 @@ class Config:
         """Model Config."""
 
         extra = "forbid"
+        arbitrary_types_allowed = True  # For CodeInFiller
 
 
 class CMP(Enum):

Diff for: src/ethereum_test_specs/static_state/general_transaction.py

@@ -19,6 +19,7 @@ class Config:
         """Model Config."""
 
         extra = "forbid"
+        arbitrary_types_allowed = True  # For CodeInFiller
 
     @field_validator("access_list", mode="before")
     def convert_keys_to_hash(cls, access_list):  # noqa: N805

Diff for: src/ethereum_test_specs/static_state/state_static.py

@@ -110,11 +110,10 @@ def _get_pre(self) -> Alloc:
             for key, value in account.storage.items():
                 storage[key] = value
 
-            acc_code, acc_code_opt = account.code
             pre[account_address] = Account(
                 balance=account.balance,
                 nonce=account.nonce,
-                code=acc_code,
+                code=account.code.compiled,
                 storage=storage,
             )
         return pre
@@ -129,13 +128,11 @@ def _make_vector(
     ) -> Tuple[Alloc, Transaction]:
         """Compose test vector from test data."""
         general_tr = self.transaction
-        data = general_tr.data[d]
-
-        data_code, options = data.data
+        data_box = general_tr.data[d]
 
         tr: Transaction = Transaction(
-            data=data_code,
-            access_list=data.access_list,
+            data=data_box.data.compiled,
+            access_list=data_box.access_list,
             gas_limit=HexNumber(general_tr.gas_limit[g]),
             value=HexNumber(general_tr.value[v]),
             gas_price=general_tr.gas_price,
@@ -165,8 +162,7 @@ def _make_vector(
                         storage.set_expect_any(key)
                 account_kwargs["storage"] = storage
             if account.code is not None:
-                code_bytes, code_options = account.code
-                account_kwargs["code"] = code_bytes
+                account_kwargs["code"] = account.code.compiled
             if account.balance is not None:
                 account_kwargs["balance"] = account.balance
             if account.nonce is not None:

Diff for: src/ethereum_test_specs/static_state/state_test_filler.py

@@ -46,8 +46,7 @@ def parse_string_indexes(indexes: str) -> List[int]:
                 indexes = indexes.replace(":label ", "")
                 tx_matches: List[int] = []
                 for idx, d in enumerate(self.transaction.data):
-                    _, code_opt = d.data
-                    if indexes == code_opt.label:
+                    if indexes == d.data.code_label:
                         tx_matches.append(idx)
                 return tx_matches
             else: