fix(tests/static): Fine tune addr tag script, turn on more static tests for tagging.

- Wrap up stTransaction tests fine-tuning
- [fine-tuning] Replace 0 address in CALL code if in pre
- Changes from comments on PR ethereum#1781:
  - Use Prague.precompiles() for precompile addresses in convert_addresses.py
- Revamp script, simplify Claude code over-engineering.
- fine tune by not tagging some addrs, add short name tag compat for selected tests

Author: fselmo

convert_addresses.py

@@ -32,7 +32,7 @@ def parse_hex_number(i: str | int) -> int:
     return int(i, 10)
 
 
-def parse_value_or_address_tag(value: Any) -> Union[HexNumber, str]:
+def parse_value_or_address_tag(value: Union[HexNumber, str]) -> Union[HexNumber, str]:
     """Parse either a hex number or an address tag for storage values."""
     if not isinstance(value, str):
         # Non-string values should be converted to HexNumber normally
@@ -121,7 +121,7 @@ def compiled(self) -> bytes:
                     else:
                         options.append(arg)
 
-            with tempfile.NamedTemporaryFile(mode="w+", delete=False) as tmp:
+            with tempfile.NamedTemporaryFile(mode="w+", delete=False, suffix=".yul") as tmp:
                 tmp.write(native_yul_options + self.code_raw[source_start:])
                 tmp_path = tmp.name
             compiled_code = compile_yul(
@@ -205,12 +205,17 @@ def parse_code_label(code) -> CodeInFillerSource:
 
 
 class AddressTag:
-    """Represents an address tag like <eoa:sender> or <contract:token>."""
+    """
+    Represents an address tag like:
+        - <eoa:sender:0x...>.
+        - <contract:target:0x...>.
+        - <coinbase:0x...>.
+    """
 
     def __init__(self, tag_type: str, tag_name: str, original_string: str):
         """Initialize address tag."""
-        self.tag_type = tag_type  # "eoa" or "contract"
-        self.tag_name = tag_name  # e.g., "sender", "token"
+        self.tag_type = tag_type  # "eoa", "contract", or "coinbase"
+        self.tag_name = tag_name  # e.g., "sender", "target", or address for 2-part tags
         self.original_string = original_string
 
     def __str__(self) -> str:
@@ -244,21 +249,32 @@ def parse_address_or_tag(value: Any) -> Union[Address, AddressTag]:
         return Address(value, left_padding=True)
 
     # Check if it matches tag pattern:
-    # - <eoa:0x...> or <contract:0x...>
-    # - <eoa:name:0x...> or <contract:name:0x...>
-    tag_pattern = r"^<(eoa|contract):(.+)>$"
-    match = re.match(tag_pattern, value.strip())
+    # - <eoa:0x...>, <contract:0x...>, <coinbase:0x...>
+    # - <eoa:name:0x...>, <contract:name:0x...>
+
+    # Try 3-part pattern first (type:name:address)
+    tag_pattern_3_part = r"^<(eoa|contract|coinbase):([^:]+):(.+)>$"
+    match = re.match(tag_pattern_3_part, value.strip())
 
     if match:
         tag_type = match.group(1)
-        # The tag_name is everything after the type and colon
-        # Could be "0x1234..." or "sender:0x1234..."
         tag_name = match.group(2)
-
+        address_part = match.group(3)
+        # For 3-part tags, the tag_name is the middle part
         return AddressTag(tag_type, tag_name, value.strip())
-    else:
-        # Regular address string
-        return Address(value, left_padding=True)
+
+    # Try 2-part pattern (type:address)
+    tag_pattern_2_part = r"^<(eoa|contract|coinbase):(.+)>$"
+    match = re.match(tag_pattern_2_part, value.strip())
+
+    if match:
+        tag_type = match.group(1)
+        address_part = match.group(2)
+        # For 2-part tags, use the address as the tag_name
+        return AddressTag(tag_type, address_part, value.strip())
+
+    # Regular address string
+    return Address(value, left_padding=True)
 
 
 def parse_address_or_tag_for_access_list(value: Any) -> Union[Address, str]:
@@ -271,7 +287,7 @@ def parse_address_or_tag_for_access_list(value: Any) -> Union[Address, str]:
         return Address(value, left_padding=True)
 
     # Check if it matches a tag pattern
-    tag_pattern = r"^<(eoa|contract):.+>$"
+    tag_pattern = r"^<(eoa|contract|coinbase):.+>$"
     if re.match(tag_pattern, value.strip()):
         # Return the tag string as-is for later resolution
         return value.strip()

failed_tests_output.txt

@@ -2,13 +2,13 @@
 
 from pydantic import BaseModel, Field, model_validator
 
-from .common import AddressInFiller, ValueInFiller
+from .common import AddressOrTagInFiller, ValueInFiller
 
 
 class EnvironmentInStateTestFiller(BaseModel):
     """Class that represents an environment filler."""
 
-    current_coinbase: AddressInFiller = Field(..., alias="currentCoinbase")
+    current_coinbase: AddressOrTagInFiller = Field(..., alias="currentCoinbase")
     current_gas_limit: ValueInFiller = Field(..., alias="currentGasLimit")
     current_number: ValueInFiller = Field(..., alias="currentNumber")
     current_timestamp: ValueInFiller = Field(..., alias="currentTimestamp")

scripts/convert_addresses.py

@@ -108,9 +108,15 @@ def _resolve_address_or_tag(self, value: Any, test_id: str, fork: Fork) -> Any:
                 if parsed.tag_type == "contract":
                     # Use deploy_contract to get next contract address
                     # We'll deploy with empty code for now, just to reserve the address
-                    address = alloc.deploy_contract(code=b"")
-                    self._tag_to_address_map[test_id][parsed.original_string] = address
-                    return address
+                    if parsed.tag_name == "sender":
+                        eoa = alloc.fund_eoa(amount=0)
+                        self._tag_to_address_map[test_id][parsed.original_string] = Address(eoa)
+                        self._tag_to_eoa_map[test_id][parsed.original_string] = eoa
+                        return Address(eoa)
+                    else:
+                        address = alloc.deploy_contract(code=b"")
+                        self._tag_to_address_map[test_id][parsed.original_string] = address
+                        return address
                 elif parsed.tag_type == "eoa":
                     # Use fund_eoa to get next EOA
                     eoa = alloc.fund_eoa(amount=0)  # Don't fund yet, just get the address
@@ -126,30 +132,21 @@ def _resolve_address_or_tag(self, value: Any, test_id: str, fork: Fork) -> Any:
     def _resolve_tags_in_code(self, code_str: str, test_id: str, fork: Fork) -> str:
         """Resolve address tags in code strings before compilation."""
         tag_pattern = r"<(eoa|contract):[^>]+>"
-        is_raw_hex = ":raw" in code_str
 
         def replace_tag(match):
             tag_str = match.group(0)
             parsed = parse_address_or_tag(tag_str)
             if isinstance(parsed, AddressTag):
                 address = self._resolve_address_or_tag(tag_str, test_id, fork)
-
-                # For :raw format, always return address without 0x prefix
-                if is_raw_hex:
-                    return str(address)[2:]
-
-                # For other formats, check if we're inside a hex string
                 start_pos = match.start()
-                # Find the last occurrence of '0x' before the tag
-                prefix_pos = code_str.rfind("0x", 0, start_pos)
-                if prefix_pos != -1:
-                    # Check if all characters between '0x' and the tag are hex digits
-                    between_content = code_str[prefix_pos + 2 : start_pos]
-                    if all(c in "0123456789abcdefABCDEF" for c in between_content):
-                        # We're inside bytecode, return address without 0x prefix
-                        return str(address)[2:]
-
-                # Default: return the address as hex string with 0x prefix
+                preceeding_2chars = code_str[start_pos - 2 : start_pos]
+                if not (
+                    preceeding_2chars == "0x" or any(kw in preceeding_2chars for kw in [" ", "("])
+                ):
+                    # - If the tag is not preceded by 0x, we're inside a hex string
+                    # - If the tag is preceded by a space, we'd need the 0x prefix
+                    # return the address without the 0x prefix
+                    return str(address)[2:]
                 return str(address)
             return tag_str
 
@@ -322,7 +319,7 @@ def _make_vector(
         # Get the same registry key logic as _get_alloc_for_test
         for addr_str in self.pre.keys():
             parsed = parse_address_or_tag(addr_str)
-            if isinstance(parsed, AddressTag) and parsed.tag_type == "eoa":
+            if isinstance(parsed, AddressTag) and parsed.tag_name == "sender":
                 # Found the sender EOA - get it from our registry
                 if parsed.original_string in self._tag_to_eoa_map.get(test_id, {}):
                     sender_eoa = self._tag_to_eoa_map[test_id][parsed.original_string]
@@ -335,10 +332,13 @@ def _make_vector(
             if isinstance(general_tr.secret_key, str) and general_tr.secret_key.startswith(
                 "<sender:key:"
             ):
-                # This should not never happen so fail hard here as a sanity check
-                raise ValueError(
-                    "Test has sender key tag but no corresponding EOA tag in pre state"
-                )
+                # Perhaps this is a test that is trying to test non-existing accounts,
+                # use a generated EOA's key anyhow, funded as `0` (since not in pre state)
+                sender_eoa = self._get_alloc_for_test(test_id, fork).fund_eoa(amount=0)
+                if sender_eoa.key is not None:
+                    secret_key_to_use = sender_eoa.key
+                else:
+                    raise ValueError(f"Sender EOA has no key: {sender_eoa}")
             else:
                 # This is a test that has not been converted to use tagging either
                 # because it needs hard-coded addresses or because of some other reason.