refactor: ♻️ Simplify the configs into one

Author: timbrinded

src/hl_api/evm/client.py

@@ -34,13 +34,11 @@
 from .bridge import CCTPBridge
 from .config import (
     DEFAULT_CCTP_FINALITY_THRESHOLD,
-    DEFAULT_FLEXIBLE_VAULT_PROOF_URL,
     DEFAULT_IRIS_MAX_POLLS,
     DEFAULT_IRIS_POLL_INTERVAL,
     DEFAULT_RECEIPT_TIMEOUT,
     DEFAULT_REQUEST_TIMEOUT,
     EVMClientConfig,
-    FlexibleVaultConfig,
 )
 from .connections import Web3Connections
 from .metadata import AssetMetadataCache
@@ -71,26 +69,12 @@ def __init__(
         hyperliquid_domain: int | None = None,
         mainnet_domain: int | None = None,
         cctp_finality_threshold: int = DEFAULT_CCTP_FINALITY_THRESHOLD,
-        flexible_vault: FlexibleVaultConfig | None = None,
         flexible_vault_proof_blob: Mapping[str, Any] | None = None,
         disable_call_verification: bool = False,
     ) -> None:
         hl_address = Web3.to_checksum_address(hl_strategy_address)
         bridge_address = Web3.to_checksum_address(bridge_strategy_address)
 
-        if flexible_vault and not disable_call_verification:
-            vault_proof_url = flexible_vault.proof_url
-            vault_verifier = flexible_vault.verifier_address
-            vault_network = flexible_vault.verifier_network
-            vault_check_root = flexible_vault.check_merkle_root
-            vault_blob = flexible_vault_proof_blob or flexible_vault.proof_blob
-        else:
-            vault_proof_url = DEFAULT_FLEXIBLE_VAULT_PROOF_URL
-            vault_verifier = None
-            vault_network = "hyper"
-            vault_check_root = False
-            vault_blob = flexible_vault_proof_blob
-
         config = EVMClientConfig(
             private_key=private_key,
             hl_rpc_url=hl_rpc_url,
@@ -107,11 +91,7 @@ def __init__(
             hyperliquid_domain=hyperliquid_domain,
             mainnet_domain=mainnet_domain,
             cctp_finality_threshold=cctp_finality_threshold,
-            flexible_vault_proof_url=vault_proof_url,
-            flexible_vault_verifier_address=vault_verifier,
-            flexible_vault_verifier_network=vault_network,
-            flexible_vault_check_merkle_root=vault_check_root,
-            flexible_vault_proof_blob=vault_blob,
+            flexible_vault_proof_blob=flexible_vault_proof_blob,
         )
 
         self._config = config
@@ -124,18 +104,10 @@ def __init__(
             receipt_timeout=config.receipt_timeout,
         )
         self._call_verification_disabled = disable_call_verification
-        # Create a temporary FlexibleVaultConfig for the resolver if needed
         self._flexible_proof_resolver: FlexibleVaultProofResolver | None
         if not self._call_verification_disabled and config.flexible_vault_proof_blob:
-            vault_config = FlexibleVaultConfig(
-                proof_url=config.flexible_vault_proof_url,
-                verifier_address=config.flexible_vault_verifier_address,
-                verifier_network=config.flexible_vault_verifier_network,
-                check_merkle_root=config.flexible_vault_check_merkle_root,
-                proof_blob=config.flexible_vault_proof_blob,
-            )
             self._flexible_proof_resolver = FlexibleVaultProofResolver(
-                vault_config,
+                config,
                 self._connections,
                 self._session,
                 request_timeout=config.request_timeout,

src/hl_api/evm/config.py

@@ -8,28 +8,15 @@
 
 from web3.types import ChecksumAddress
 
-DEFAULT_FLEXIBLE_VAULT_PROOF_URL = (
-    "https://raw.githubusercontent.com/mellow-finance/flexible-vaults/"
-    "test-deployments/scripts/jsons/ethereum%3AtqETH%3Asubvault0.json"
-)
-
-
-@dataclass(frozen=True)
-class FlexibleVaultConfig:
-    """Configuration for fetching Mellow flexible vault proof blobs."""
-
-    proof_url: str = DEFAULT_FLEXIBLE_VAULT_PROOF_URL
-    verifier_address: str | None = None
-    verifier_network: str = "hyper"
-    check_merkle_root: bool = False
-    proof_blob: Mapping[str, Any] | None = None
-
-
 DEFAULT_REQUEST_TIMEOUT = 10.0
 DEFAULT_RECEIPT_TIMEOUT = 120.0
 DEFAULT_IRIS_POLL_INTERVAL = 2.0
 DEFAULT_IRIS_MAX_POLLS = 100
 DEFAULT_CCTP_FINALITY_THRESHOLD = 1000
+DEFAULT_FLEXIBLE_VAULT_PROOF_URL = (
+    "https://raw.githubusercontent.com/mellow-finance/flexible-vaults/"
+    "test-deployments/scripts/jsons/ethereum%3AtqETH%3Asubvault0.json"
+)
 IRIS_API_SANDBOX = "https://iris-api-sandbox.circle.com"
 IRIS_API_PROD = "https://iris-api.circle.com"
 

src/hl_api/evm/proofs.py

@@ -12,7 +12,7 @@
 
 from ..exceptions import NetworkError, ValidationError
 from ..types import VerificationPayload
-from .config import FlexibleVaultConfig
+from .config import EVMClientConfig
 from .connections import Web3Connections
 
 logger = logging.getLogger(__name__)
@@ -48,8 +48,8 @@ def __init__(self, session: requests.Session, *, request_timeout: float) -> None
         self._cache: dict[str, ProofDataset] = {}
         self._validated_roots: set[str] = set()
 
-    def fetch(self, config: FlexibleVaultConfig) -> ProofDataset:
-        blob = config.proof_blob
+    def fetch(self, config: EVMClientConfig) -> ProofDataset:
+        blob = config.flexible_vault_proof_blob
         if blob is not None:
             if not isinstance(blob, Mapping):
                 raise ValidationError(
@@ -58,7 +58,7 @@ def fetch(self, config: FlexibleVaultConfig) -> ProofDataset:
                     value=blob,
                 )
 
-            source_label = config.proof_url or "<inline>"
+            source_label = config.flexible_vault_proof_url or "<inline>"
             if source_label == "<inline>":
                 logger.debug("Loading flexible vault proof set from inline blob")
             else:
@@ -67,11 +67,11 @@ def fetch(self, config: FlexibleVaultConfig) -> ProofDataset:
                     source_label,
                 )
             dataset = _build_dataset(blob, source_label=source_label)
-            if config.proof_url:
-                self._cache.setdefault(config.proof_url, dataset)
+            if config.flexible_vault_proof_url:
+                self._cache.setdefault(config.flexible_vault_proof_url, dataset)
             return dataset
 
-        url = config.proof_url
+        url = config.flexible_vault_proof_url
         if not url:
             raise ValidationError(
                 "Flexible vault proof URL is required when no blob is provided",
@@ -119,17 +119,17 @@ def fetch(self, config: FlexibleVaultConfig) -> ProofDataset:
         return dataset
 
     def ensure_merkle_root(
-        self, config: FlexibleVaultConfig, dataset: ProofDataset, connections: Web3Connections
+        self, config: EVMClientConfig, dataset: ProofDataset, connections: Web3Connections
     ) -> None:
-        verifier = config.verifier_address
-        if not verifier or not config.check_merkle_root:
+        verifier = config.flexible_vault_verifier_address
+        if not verifier or not config.flexible_vault_check_merkle_root:
             return
 
         cache_key = f"{dataset.url}|{verifier.lower()}"
         if cache_key in self._validated_roots:
             return
 
-        web3 = _select_web3(connections, config.verifier_network)
+        web3 = _select_web3(connections, config.flexible_vault_verifier_network)
         address = Web3.to_checksum_address(verifier)
         try:
             contract = web3.eth.contract(address=address, abi=_VERIFIER_ABI)
@@ -189,7 +189,7 @@ class FlexibleVaultProofResolver:
 
     def __init__(
         self,
-        config: FlexibleVaultConfig,
+        config: EVMClientConfig,
         connections: Web3Connections,
         session: requests.Session,
         *,

tests/test_flexible_vault.py

@@ -5,8 +5,9 @@
 
 import pytest
 from requests import Session
+from web3 import Web3
 
-from hl_api.evm.config import FlexibleVaultConfig
+from hl_api.evm.config import EVMClientConfig
 from hl_api.evm.connections import Web3Connections
 from hl_api.evm.proofs import FlexibleVaultProofResolver, ProofManager
 from hl_api.exceptions import ValidationError
@@ -83,7 +84,14 @@ def _example_payload() -> dict[str, Any]:
 
 
 def test_fetch_requires_https() -> None:
-    config = FlexibleVaultConfig(proof_url="http://example.com/proof.json")
+    config = EVMClientConfig(
+        private_key="0x" + "0" * 64,
+        hl_rpc_url="https://example.com",
+        mn_rpc_url="https://example.com",
+        hl_strategy_address=Web3.to_checksum_address("0x" + "0" * 40),
+        bridge_strategy_address=Web3.to_checksum_address("0x" + "0" * 40),
+        flexible_vault_proof_url="http://example.com/proof.json",
+    )
     session = DummySession(DummyResponse({}))
     manager = ProofManager(session, request_timeout=1.0)
 
@@ -104,10 +112,15 @@ def test_resolver_loads_payload(monkeypatch: pytest.MonkeyPatch) -> None:
         ),
     )
 
-    config = FlexibleVaultConfig(
-        proof_url="https://example.com/proof.json",
-        verifier_address="0x0000000000000000000000000000000000000001",
-        check_merkle_root=True,
+    config = EVMClientConfig(
+        private_key="0x" + "0" * 64,
+        hl_rpc_url="https://example.com",
+        mn_rpc_url="https://example.com",
+        hl_strategy_address=Web3.to_checksum_address("0x" + "0" * 40),
+        bridge_strategy_address=Web3.to_checksum_address("0x" + "0" * 40),
+        flexible_vault_proof_url="https://example.com/proof.json",
+        flexible_vault_verifier_address="0x0000000000000000000000000000000000000001",
+        flexible_vault_check_merkle_root=True,
     )
 
     resolver = FlexibleVaultProofResolver(
@@ -134,8 +147,13 @@ def test_resolver_missing_description_raises(monkeypatch: pytest.MonkeyPatch) ->
         ),
     )
 
-    config = FlexibleVaultConfig(
-        proof_url="https://example.com/proof.json",
+    config = EVMClientConfig(
+        private_key="0x" + "0" * 64,
+        hl_rpc_url="https://example.com",
+        mn_rpc_url="https://example.com",
+        hl_strategy_address=Web3.to_checksum_address("0x" + "0" * 40),
+        bridge_strategy_address=Web3.to_checksum_address("0x" + "0" * 40),
+        flexible_vault_proof_url="https://example.com/proof.json",
     )
 
     resolver = FlexibleVaultProofResolver(