test: fix currency hex encoding and refactor

Issue #610 fixed: /search/transactions now requires hex-encoded currency symbols.
Updated all tests to comply with this change and fixed several validation issues.

Changes:
- Add symbol_hex field to network_test_data.yaml for native assets
- Convert test_native_asset_filtering_by_ascii_symbol to negative test
  (expects error 5059)
- Unskip test_currency_filter_with_hex_encoded_symbol (issue #610 now fixed)
- Update all currency search tests to use hex symbols instead of ASCII
- Fix test assertions to validate ALL transactions contain filtered asset (not just "at least one")
- Correct tokenBundle validation (native assets live there, not in operation amounts)
- Update peer discovery test for Genesis mode (peer-snapshot.json) with time-based validation
- Refactor token_registry tests: convert assertion helpers to pytest fixtures
- Fix registry metadata extraction to handle v2 API structure ({value,
  source} objects)
- Fix test_rosetta_metadata_matches_registry to compare Rosetta vs Registry (not vs config)
- Add "domain" to valid peer types (Genesis peer-snapshot.json support)

Author: linconvidal

tests/data-endpoints/network_test_data.yaml

@@ -30,6 +30,7 @@ preprod:
     - name: "tTEURO"
       description: "Test Euro stablecoin on preprod - 11,081 transactions"
       symbol: "tTEURO"
+      symbol_hex: "74544555524f"  # Symbol in hexadecimal
       decimals: 6
       policy_id: "e68f1cea19752d1292b4be71b7f5d2b3219a15859c028f7454f66cdf"
 

tests/data-endpoints/test_network_endpoints.py

@@ -1,5 +1,6 @@
 """Tests for Rosetta /network endpoints."""
 
+import time
 import pytest
 import allure
 
@@ -65,18 +66,32 @@ def test_returns_current_network_status(self, client, network):
         assert sync_current >= current_index, "sync progress cannot trail current block"
         assert sync_current <= sync_target, "sync progress cannot exceed target"
 
-        peers = data.get("peers")
-        assert isinstance(peers, list) and peers, "Peers list must not be empty"
+        peers = data.get("peers", [])
+
+        if not peers:
+            max_wait_seconds = 300
+            retry_interval = 30
+            for _ in range(max_wait_seconds // retry_interval):
+                time.sleep(retry_interval)
+                peers = client.network_status(network=network).json().get("peers", [])
+                if peers:
+                    break
+
+        assert isinstance(peers, list), "Peers must be a list"
+        assert peers, "Peers list empty after 5 minutes (peer discovery initial delay)"
+
         for peer in peers:
             peer_id = peer.get("peer_id")
             metadata = peer.get("metadata")
+
             assert isinstance(peer_id, str) and ":" in peer_id, (
                 "peer_id must include hostname and port"
             )
             assert isinstance(metadata, dict) and metadata.get("type") in {
                 "IPv4",
                 "IPv6",
-            }
+                "domain",
+            }, f"Peer type must be IPv4, IPv6, or domain (Genesis mode), got: {metadata.get('type')}"
 
     # Error handling tests moved to test_error_handling.py
 

tests/data-endpoints/test_peer_discovery.py

@@ -1,54 +1,38 @@
 """Peer discovery TTL validation (v1.4.0)."""
-import os
+import time
 import pytest
 import allure
-from pathlib import Path
-
-import yaml
 
 
 @allure.feature("Peer Discovery")
 @allure.story("Dynamic Peer List")
 class TestPeerDiscovery:
     """Validate dynamic peer discovery with TTL."""
 
-    @pytest.mark.nightly
+    @pytest.mark.weekly
     @pytest.mark.requires_peer_discovery
     @pytest.mark.slow
-    @pytest.mark.skip(reason="Peer discovery takes too long to populate dynamic peers (#619)")
-    def test_peer_list_contains_dynamic_entries(self, client, network, has_peer_discovery):
-        """Verify peer discovery returns peers beyond the static bootstrap list."""
+    @pytest.mark.skip(reason="Peer discovery refresh takes 65+ minutes - reserved for weekly tests (#619)")
+    def test_peer_list_changes_over_time(self, client, network, has_peer_discovery):
+        """Verify peer discovery refreshes and peers change over time (60 min refresh cycle)."""
         if not has_peer_discovery:
             pytest.skip("Peer discovery not enabled")
 
-        repo_root = Path(__file__).resolve().parents[2]
-        topology_file = repo_root / "config" / "node" / network / "topology.json"
-        assert topology_file.exists(), f"Bootstrap topology file not found: {topology_file}"
-
-        bootstrap_hosts = set()
-        try:
-            topology = yaml.safe_load(topology_file.read_text(encoding="utf-8"))
-            for peer in topology.get("bootstrapPeers", []):
-                host = peer.get("address")
-                if host:
-                    bootstrap_hosts.add(host)
-        except Exception as exc:
-            pytest.fail(f"Unable to parse bootstrap topology {topology_file}: {exc}")
-        assert bootstrap_hosts, f"Bootstrap topology {topology_file} does not define any bootstrap peers"
+        # Get initial peer list
+        peers_t0 = client.network_status(network=network).json().get("peers", [])
+        assert peers_t0, "Initial peer list should not be empty"
 
-        peers = client.network_status(network=network).json().get("peers", [])
-        peer_hosts = set()
-        for peer in peers:
-            peer_id = peer.get("peer_id", "")
-            if ":" in peer_id:
-                host = peer_id.split(":", 1)[0]
-                if host:
-                    peer_hosts.add(host)
+        # Wait for peer discovery refresh cycle (60 min + 5 min buffer)
+        wait_minutes = 65
+        print(f"Waiting {wait_minutes} minutes for peer discovery refresh...")
+        time.sleep(wait_minutes * 60)
 
-        assert peer_hosts, "Peer discovery should return peers with peer_id host values"
+        # Get peer list after refresh
+        peers_t1 = client.network_status(network=network).json().get("peers", [])
+        assert peers_t1, "Peer list after refresh should not be empty"
 
-        dynamic_hosts = peer_hosts - bootstrap_hosts
-        assert dynamic_hosts, (
-            "Peer discovery did not return any dynamic peers beyond bootstrap list. "
-            f"Bootstrap hosts: {sorted(bootstrap_hosts)}; Reported peers: {sorted(peer_hosts)}"
+        # Verify peers changed (dynamic discovery is working)
+        assert peers_t0 != peers_t1, (
+            f"Peers should change after {wait_minutes} minutes (discovery refresh cycle). "
+            f"T0 peers: {len(peers_t0)}, T1 peers: {len(peers_t1)}"
         )

tests/data-endpoints/test_search_transactions.py

@@ -659,70 +659,75 @@ def test_ada_filter_case_insensitive(self, client, network, symbol):
     @allure.story("Currency Filtering")
     @pytest.mark.pruning_compatible
     def test_native_asset_filtering_by_ascii_symbol(self, client, network, network_data, is_pruned_instance):
-        """Currency filter works with ASCII symbols (backwards compat in v1.3.3)."""
+        """Currency filter with ASCII symbols should return error (negative test for v1.4.1+)."""
         asset = network_data["assets"][0]
-        hex_symbol = asset["symbol"].encode().hex().lower()  # Lowercase hex
 
-        # Search by ASCII symbol (backwards compat)
+        # Search by ASCII symbol (should return error in v1.4.1+)
         response = client.search_transactions(
             network=network,
             currency={"symbol": asset["symbol"], "decimals": asset["decimals"]},
         )
-        assert response.status_code == 200
-
-        # Verify returns transactions
-        txs = response.json()["transactions"]
-        assert len(txs) > 0, "Currency filter should return transactions"
 
-        # Verify transactions contain the asset (in metadata.tokenBundle)
-        for tx in txs:
-            found_asset = False
-            for op in tx["transaction"]["operations"]:
-                # Check metadata.tokenBundle for native assets
-                if "metadata" in op and "tokenBundle" in op["metadata"]:
-                    for bundle in op["metadata"]["tokenBundle"]:
-                        for token in bundle.get("tokens", []):
-                            if token["currency"]["symbol"].lower() == hex_symbol:
-                                found_asset = True
-                                break
+        # API should return error for non-hex-encoded symbols
+        assert response.status_code == 500, (
+            f"Expected error status code when using ASCII symbol '{asset['symbol']}'"
+        )
 
-            assert found_asset, (
-                f"Transaction must contain native asset with hex symbol {hex_symbol}"
-            )
+        error_data = response.json()
+        assert error_data["code"] == 5059, "Expected error code 5059 for non-hex symbol"
+        assert "hex-encoded" in error_data["message"].lower(), (
+            "Error message should mention hex encoding requirement"
+        )
+        assert asset["symbol"] in error_data.get("details", {}).get("message", ""), (
+            f"Error details should mention the invalid symbol '{asset['symbol']}'"
+        )
 
     @allure.feature("Search Transactions")
     @allure.story("Currency Filtering")
-    @pytest.mark.skip(
-        reason="Currency filter + limit parameter causes timeout (#615)"
-    )
+    # TODO: investigate and update the ticket; seems to be working now, although response time is ~2min
+    # @pytest.mark.skip(
+    #     reason="Currency filter + limit parameter causes timeout (#615)"
+    # )
     def test_currency_filter_with_limit_parameter(self, client, network, network_data):
         """Currency filter with explicit limit should not cause timeout."""
         asset = network_data["assets"][0]
 
         # This combination causes 600s+ timeout in v1.3.3
         response = client.search_transactions(
             network=network,
-            currency={"symbol": asset["symbol"], "decimals": asset["decimals"]},
+            currency={"symbol": asset["symbol_hex"], "decimals": asset["decimals"]},
             limit=1,
         )
         assert response.status_code == 200
 
         txs = response.json()["transactions"]
-        assert len(txs) <= 1, "Should respect limit parameter"
+        assert len(txs) == 1, "Should respect limit parameter"
+
+        # Verify the returned transaction contains the filtered asset
+        tx = txs[0]
+        currencies_in_tx = []
+        for op in tx["transaction"]["operations"]:
+            if "metadata" in op and "tokenBundle" in op["metadata"]:
+                for bundle in op["metadata"]["tokenBundle"]:
+                    for token in bundle.get("tokens", []):
+                        currencies_in_tx.append(token["currency"]["symbol"].lower())
+
+        assert asset["symbol_hex"].lower() in currencies_in_tx, (
+            f"Transaction must contain filtered asset {asset['symbol_hex']}. "
+            f"Found currencies: {currencies_in_tx}"
+        )
 
     @allure.feature("Search Transactions")
     @allure.story("Currency Filtering")
-    @pytest.mark.skip(
-        reason="Hex symbol search not working until v1.4.x (#610)"
-    )
-    def test_currency_filter_with_hex_encoded_symbol(self, client, network, network_data):
-        """Currency filter should accept hex-encoded symbols (canonical format in v1.4.x+)."""
+    @pytest.mark.pruning_compatible
+    def test_currency_filter_with_hex_encoded_symbol(self, client, network, network_data, is_pruned_instance):
+        """Currency filter accepts hex-encoded symbols (canonical format in v1.4.x+, issue #610 fixed)."""
         asset = network_data["assets"][0]
 
-        # Convert ASCII symbol to hex (canonical format)
-        hex_symbol = asset["symbol"].encode().hex().upper()  # "tTEURO" → "74544555524F"
+        # Use hex-encoded symbol from test data (canonical format)
+        hex_symbol = asset["symbol_hex"]  # e.g., "74544555524f"
 
-        # Search by hex-encoded symbol (will work in v1.4.x when #610 is fixed)
+        # Search by hex-encoded symbol (supported in v1.4.x+ after #610 fix)
         response = client.search_transactions(
             network=network,
             currency={"symbol": hex_symbol, "decimals": asset["decimals"]},
@@ -732,49 +737,59 @@ def test_currency_filter_with_hex_encoded_symbol(self, client, network, network_
         txs = response.json()["transactions"]
         assert len(txs) > 0, "Hex symbol search should return transactions"
 
-        # Verify transactions contain the asset
+        # Verify ALL transactions contain the filtered asset (currency filter was applied)
         for tx in txs:
-            currencies = [
-                op["amount"]["currency"]["symbol"]
-                for op in tx.get("operations", [])
-                if "amount" in op and "currency" in op["amount"]
-            ]
-            # In v1.4.x+, API will return hex symbols
-            assert hex_symbol in currencies, \
-                "Currency filter with hex symbol should return matching transactions"
+            # Collect all currency symbols from tokenBundle across all operations
+            currencies_in_tx = []
+            for op in tx["transaction"]["operations"]:
+                # Native assets are always in tokenBundle (they sit in UTXOs with ADA)
+                if "metadata" in op and "tokenBundle" in op["metadata"]:
+                    for bundle in op["metadata"]["tokenBundle"]:
+                        for token in bundle.get("tokens", []):
+                            currencies_in_tx.append(token["currency"]["symbol"].lower())
+
+            # Assert filtered currency is in this transaction
+            assert hex_symbol.lower() in currencies_in_tx, (
+                f"Transaction must contain native asset with hex symbol {hex_symbol} in tokenBundle. "
+                f"Found currencies: {currencies_in_tx}"
+            )
 
     @allure.feature("Search Transactions")
     @allure.story("Currency Filtering")
     @pytest.mark.pruning_compatible
     def test_native_asset_filtering_with_policy_id(self, client, network, network_data, is_pruned_instance):
-        """Test currency filtering with metadata.policyId."""
+        """Test currency filtering with hex-encoded symbol and metadata.policyId."""
         asset = network_data["assets"][0]
 
-        # Search by asset with policyId in metadata
+        # Search by hex-encoded asset symbol with policyId in metadata
         response = client.search_transactions(
             network=network,
             currency={
-                "symbol": asset["symbol"],
+                "symbol": asset["symbol_hex"],
                 "decimals": asset["decimals"],
                 "metadata": {"policyId": asset["policy_id"]}
             },
         )
         assert response.status_code == 200
 
-        # Verify all returned transactions contain this specific asset with policyId
+        # Verify ALL transactions contain the filtered asset with matching policyId and symbol
         txs = response.json()["transactions"]
         assert len(txs) > 0, "Currency filter with policyId should return transactions"
 
         for tx in txs:
-            # Check metadata.tokenBundle for matching policyId
-            found_asset = False
+            # Collect all (policyId, symbol) pairs from tokenBundle across all operations
+            assets_in_tx = []
             for op in tx["transaction"]["operations"]:
                 if "metadata" in op and "tokenBundle" in op["metadata"]:
                     for bundle in op["metadata"]["tokenBundle"]:
-                        if bundle.get("policyId") == asset["policy_id"]:
-                            found_asset = True
-                            break
-
-            assert found_asset, (
-                f"Transaction must contain asset with policyId {asset['policy_id']}"
+                        policy_id = bundle.get("policyId")
+                        for token in bundle.get("tokens", []):
+                            symbol = token["currency"]["symbol"].lower()
+                            assets_in_tx.append((policy_id, symbol))
+
+            # Assert filtered asset (policyId + symbol) is in this transaction
+            expected_asset = (asset["policy_id"], asset["symbol_hex"].lower())
+            assert expected_asset in assets_in_tx, (
+                f"Transaction must contain asset with policyId {asset['policy_id']} "
+                f"and symbol {asset['symbol_hex']}. Found assets: {assets_in_tx}"
             )

tests/data-endpoints/test_smoke_network_data.py

@@ -54,7 +54,7 @@ def test_configured_assets_have_transactions(self, client, network, network_data
             # Note: Do NOT add limit parameter - currency filter + limit causes timeout (#615)
             response = client.search_transactions(
                 network=network,
-                currency={"symbol": asset["symbol"], "decimals": asset["decimals"]},
+                currency={"symbol": asset["symbol_hex"], "decimals": asset["decimals"]},
             )
             assert response.status_code == 200
 
@@ -64,6 +64,24 @@ def test_configured_assets_have_transactions(self, client, network, network_data
                 f"Network may have changed or asset data is wrong - update network_test_data.yaml"
             )
 
+            # Verify ALL transactions contain the filtered asset (currency filter was applied)
+            for tx in txs:
+                # Collect all currency symbols from tokenBundle across all operations
+                currencies_in_tx = []
+                for op in tx["transaction"]["operations"]:
+                    # Native assets are always in tokenBundle (they sit in UTXOs with ADA)
+                    if "metadata" in op and "tokenBundle" in op["metadata"]:
+                        for bundle in op["metadata"]["tokenBundle"]:
+                            for token in bundle.get("tokens", []):
+                                currencies_in_tx.append(token["currency"]["symbol"].lower())
+
+                # Assert filtered currency is in this transaction
+                assert asset["symbol_hex"].lower() in currencies_in_tx, (
+                    f"Asset '{asset['name']}' with hex symbol {asset['symbol_hex']} not found in transaction. "
+                    f"Currency filter should return only transactions containing the filtered asset. "
+                    f"Found currencies: {currencies_in_tx}"
+                )
+
     def test_asset_policy_ids_are_valid(self, client, network, network_data):
         """Asset policy IDs should be valid hex strings."""
         for asset in network_data["assets"]: