genlayer-test 0.3.1__tar.gz → 0.4.0__tar.gz

{genlayer_test-0.3.1 → genlayer_test-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: genlayer-test
-Version: 0.3.1
+Version: 0.4.0
 Summary: GenLayer Testing Suite
 Author: GenLayer
 License-Expression: MIT
@@ -50,7 +50,7 @@ from gltest.assertions import tx_execution_succeeded
 
 factory = get_contract_factory("MyContract")
 # Deploy a contract with default account
-contract = factory.deploy() # This will be deployed with default_account
+contract = factory.deploy() # This will be deployed with the default account
 assert contract.account == get_default_account()
 
 # Deploy a contract with other account
@@ -207,6 +207,30 @@ $ gltest --default-wait-interval <default_wait_interval>
 $ gltest --default-wait-retries <default_wait_retries>
 ```
 
+10. Run tests with mocked LLM responses (localnet only)
+```bash
+$ gltest --test-with-mocks
+```
+The `--test-with-mocks` flag enables mocking of LLM responses when creating validators. This is particularly useful for:
+- Testing without actual LLM API calls
+- Ensuring deterministic test results
+- Faster test execution
+- Testing specific edge cases with controlled responses
+
+When using this flag with the `setup_validators` fixture, you can provide custom mock responses:
+```python
+def test_with_mocked_llm(setup_validators):
+    # Setup validators with a specific mock response
+    mock_response = {"result": "This is a mocked LLM response"}
+    setup_validators(mock_response=mock_response)
+    
+    # Your LLM-based contract will receive the mocked response
+    contract = factory.deploy()
+    result = contract.llm_method()  # Will use the mocked response
+```
+
+Note: This feature is only available when running tests on localnet.
+
 ## 🚀 Key Features
 
 - **Pytest Integration** – Extends pytest to support intelligent contract testing, making it familiar and easy to adopt.
@@ -275,7 +299,7 @@ Key features demonstrated in this contract:
 Here's how to deploy the Storage contract:
 
 ```python
-from gltest import get_contract_factory, default_account
+from gltest import get_contract_factory, get_default_account
 
 def test_deployment():
     # Get the contract factory for your contract
@@ -285,7 +309,7 @@ def test_deployment():
     # Deploy the contract with constructor arguments
     contract = factory.deploy(
         args=["initial_value"],  # Constructor arguments
-        account=default_account,  # Account to deploy from
+        account=get_default_account(),  # Account to deploy from
         consensus_max_rotations=3,  # Optional: max consensus rotations
         leader_only=False,  # Optional: whether to run only on leader
     )
@@ -384,6 +408,102 @@ Both `tx_execution_succeeded` and `tx_execution_failed` accept the following par
 
 For more example contracts, check out the [contracts directory](tests/examples/contracts) which contains various sample contracts demonstrating different features and use cases.
 
+### Test Fixtures
+
+The GenLayer Testing Suite provides reusable pytest fixtures in `gltest.fixtures` to simplify common testing operations. These fixtures can be imported and used in your test files to avoid repetitive setup code.
+
+#### Available Fixtures
+
+The following fixtures are available in `gltest.fixtures`:
+
+- **`gl_client`** (session scope) - GenLayer client instance for network operations
+- **`default_account`** (session scope) - Default account for testing and deployments
+- **`accounts`** (session scope) - List of test accounts for multi-account scenarios
+- **`setup_validators`** (function scope) - Function to create test validators for LLM operations
+
+##### 1. `gl_client` (session scope)
+Provides a GenLayer PY client instance that's created once per test session. This is useful for operations that interact directly with the GenLayer network.
+
+```python
+def test_client_operations(gl_client):
+    # Use the client for network operations
+    tx_hash = "0x1234..."
+    transaction = gl_client.get_transaction(tx_hash)
+```
+
+##### 2. `default_account` (session scope)
+Provides the default account used to execute transactions when no account is specified.
+
+```python
+def test_with_default_account(default_account):
+    # Use the default account for deployments
+    factory = get_contract_factory("MyContract")
+    contract = factory.deploy(account=default_account)
+```
+
+##### 3. `accounts` (session scope)
+Provides a list of account objects loaded from the private keys defined in `gltest.config.yaml` for the current network, or pre-created test accounts if no config is present
+
+```python
+def test_multiple_accounts(accounts):
+    # Get multiple accounts for testing
+    sender = accounts[0]
+    receiver = accounts[1]
+    
+    # Test transfers or multi-party interactions
+    contract.transfer(args=[receiver.address, 100], account=sender)
+```
+
+##### 4. `setup_validators` (function scope)
+Creates test validators for localnet environment. This fixture is particularly useful for testing LLM-based contract methods and consensus behavior. It yields a function that allows you to configure validators with custom settings.
+
+```python
+def test_with_validators(setup_validators):
+    # Setup validators with default configuration
+    setup_validators()
+    
+    # Or setup with custom mock responses for testing
+    mock_response = {"result": "mocked LLM response"}
+    setup_validators(mock_response=mock_response, n_validators=3)
+    
+    # Now test your LLM-based contract methods
+    contract = factory.deploy()
+    result = contract.llm_based_method()
+```
+
+Parameters for `setup_validators`:
+- `mock_response` (dict, optional): Mock validator response when using `--test-with-mocks` flag
+- `n_validators` (int, optional): Number of validators to create (default: 5)
+
+#### Using Fixtures in Your Tests
+
+To use these fixtures, simply import them and include them as parameters in your test functions:
+
+```python
+from gltest import get_contract_factory
+from gltest.assertions import tx_execution_succeeded
+
+def test_complete_workflow(gl_client, default_account, accounts, setup_validators):
+    # Setup validators for LLM operations
+    setup_validators()
+    
+    # Deploy contract with default account
+    factory = get_contract_factory("MyContract")
+    contract = factory.deploy(account=default_account)
+    
+    # Interact using other accounts
+    other_account = accounts[1]
+    tx_receipt = contract.some_method(args=["value"], account=other_account)
+    
+    assert tx_execution_succeeded(tx_receipt)
+```
+
+Fixtures help maintain clean, DRY test code by:
+- Eliminating repetitive setup code
+- Ensuring consistent test environments
+- Managing resource cleanup automatically
+- Providing appropriate scoping for performance
+
 ## 📝 Best Practices
 
 1. **Test Organization**

{genlayer_test-0.3.1 → genlayer_test-0.4.0}/README.md

@@ -27,7 +27,7 @@ from gltest.assertions import tx_execution_succeeded
 
 factory = get_contract_factory("MyContract")
 # Deploy a contract with default account
-contract = factory.deploy() # This will be deployed with default_account
+contract = factory.deploy() # This will be deployed with the default account
 assert contract.account == get_default_account()
 
 # Deploy a contract with other account
@@ -184,6 +184,30 @@ $ gltest --default-wait-interval <default_wait_interval>
 $ gltest --default-wait-retries <default_wait_retries>
 ```
 
+10. Run tests with mocked LLM responses (localnet only)
+```bash
+$ gltest --test-with-mocks
+```
+The `--test-with-mocks` flag enables mocking of LLM responses when creating validators. This is particularly useful for:
+- Testing without actual LLM API calls
+- Ensuring deterministic test results
+- Faster test execution
+- Testing specific edge cases with controlled responses
+
+When using this flag with the `setup_validators` fixture, you can provide custom mock responses:
+```python
+def test_with_mocked_llm(setup_validators):
+    # Setup validators with a specific mock response
+    mock_response = {"result": "This is a mocked LLM response"}
+    setup_validators(mock_response=mock_response)
+    
+    # Your LLM-based contract will receive the mocked response
+    contract = factory.deploy()
+    result = contract.llm_method()  # Will use the mocked response
+```
+
+Note: This feature is only available when running tests on localnet.
+
 ## 🚀 Key Features
 
 - **Pytest Integration** – Extends pytest to support intelligent contract testing, making it familiar and easy to adopt.
@@ -252,7 +276,7 @@ Key features demonstrated in this contract:
 Here's how to deploy the Storage contract:
 
 ```python
-from gltest import get_contract_factory, default_account
+from gltest import get_contract_factory, get_default_account
 
 def test_deployment():
     # Get the contract factory for your contract
@@ -262,7 +286,7 @@ def test_deployment():
     # Deploy the contract with constructor arguments
     contract = factory.deploy(
         args=["initial_value"],  # Constructor arguments
-        account=default_account,  # Account to deploy from
+        account=get_default_account(),  # Account to deploy from
         consensus_max_rotations=3,  # Optional: max consensus rotations
         leader_only=False,  # Optional: whether to run only on leader
     )
@@ -361,6 +385,102 @@ Both `tx_execution_succeeded` and `tx_execution_failed` accept the following par
 
 For more example contracts, check out the [contracts directory](tests/examples/contracts) which contains various sample contracts demonstrating different features and use cases.
 
+### Test Fixtures
+
+The GenLayer Testing Suite provides reusable pytest fixtures in `gltest.fixtures` to simplify common testing operations. These fixtures can be imported and used in your test files to avoid repetitive setup code.
+
+#### Available Fixtures
+
+The following fixtures are available in `gltest.fixtures`:
+
+- **`gl_client`** (session scope) - GenLayer client instance for network operations
+- **`default_account`** (session scope) - Default account for testing and deployments
+- **`accounts`** (session scope) - List of test accounts for multi-account scenarios
+- **`setup_validators`** (function scope) - Function to create test validators for LLM operations
+
+##### 1. `gl_client` (session scope)
+Provides a GenLayer PY client instance that's created once per test session. This is useful for operations that interact directly with the GenLayer network.
+
+```python
+def test_client_operations(gl_client):
+    # Use the client for network operations
+    tx_hash = "0x1234..."
+    transaction = gl_client.get_transaction(tx_hash)
+```
+
+##### 2. `default_account` (session scope)
+Provides the default account used to execute transactions when no account is specified.
+
+```python
+def test_with_default_account(default_account):
+    # Use the default account for deployments
+    factory = get_contract_factory("MyContract")
+    contract = factory.deploy(account=default_account)
+```
+
+##### 3. `accounts` (session scope)
+Provides a list of account objects loaded from the private keys defined in `gltest.config.yaml` for the current network, or pre-created test accounts if no config is present
+
+```python
+def test_multiple_accounts(accounts):
+    # Get multiple accounts for testing
+    sender = accounts[0]
+    receiver = accounts[1]
+    
+    # Test transfers or multi-party interactions
+    contract.transfer(args=[receiver.address, 100], account=sender)
+```
+
+##### 4. `setup_validators` (function scope)
+Creates test validators for localnet environment. This fixture is particularly useful for testing LLM-based contract methods and consensus behavior. It yields a function that allows you to configure validators with custom settings.
+
+```python
+def test_with_validators(setup_validators):
+    # Setup validators with default configuration
+    setup_validators()
+    
+    # Or setup with custom mock responses for testing
+    mock_response = {"result": "mocked LLM response"}
+    setup_validators(mock_response=mock_response, n_validators=3)
+    
+    # Now test your LLM-based contract methods
+    contract = factory.deploy()
+    result = contract.llm_based_method()
+```
+
+Parameters for `setup_validators`:
+- `mock_response` (dict, optional): Mock validator response when using `--test-with-mocks` flag
+- `n_validators` (int, optional): Number of validators to create (default: 5)
+
+#### Using Fixtures in Your Tests
+
+To use these fixtures, simply import them and include them as parameters in your test functions:
+
+```python
+from gltest import get_contract_factory
+from gltest.assertions import tx_execution_succeeded
+
+def test_complete_workflow(gl_client, default_account, accounts, setup_validators):
+    # Setup validators for LLM operations
+    setup_validators()
+    
+    # Deploy contract with default account
+    factory = get_contract_factory("MyContract")
+    contract = factory.deploy(account=default_account)
+    
+    # Interact using other accounts
+    other_account = accounts[1]
+    tx_receipt = contract.some_method(args=["value"], account=other_account)
+    
+    assert tx_execution_succeeded(tx_receipt)
+```
+
+Fixtures help maintain clean, DRY test code by:
+- Eliminating repetitive setup code
+- Ensuring consistent test environments
+- Managing resource cleanup automatically
+- Providing appropriate scoping for performance
+
 ## 📝 Best Practices
 
 1. **Test Organization**

{genlayer_test-0.3.1 → genlayer_test-0.4.0}/genlayer_test.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: genlayer-test
-Version: 0.3.1
+Version: 0.4.0
 Summary: GenLayer Testing Suite
 Author: GenLayer
 License-Expression: MIT
@@ -50,7 +50,7 @@ from gltest.assertions import tx_execution_succeeded
 
 factory = get_contract_factory("MyContract")
 # Deploy a contract with default account
-contract = factory.deploy() # This will be deployed with default_account
+contract = factory.deploy() # This will be deployed with the default account
 assert contract.account == get_default_account()
 
 # Deploy a contract with other account
@@ -207,6 +207,30 @@ $ gltest --default-wait-interval <default_wait_interval>
 $ gltest --default-wait-retries <default_wait_retries>
 ```
 
+10. Run tests with mocked LLM responses (localnet only)
+```bash
+$ gltest --test-with-mocks
+```
+The `--test-with-mocks` flag enables mocking of LLM responses when creating validators. This is particularly useful for:
+- Testing without actual LLM API calls
+- Ensuring deterministic test results
+- Faster test execution
+- Testing specific edge cases with controlled responses
+
+When using this flag with the `setup_validators` fixture, you can provide custom mock responses:
+```python
+def test_with_mocked_llm(setup_validators):
+    # Setup validators with a specific mock response
+    mock_response = {"result": "This is a mocked LLM response"}
+    setup_validators(mock_response=mock_response)
+    
+    # Your LLM-based contract will receive the mocked response
+    contract = factory.deploy()
+    result = contract.llm_method()  # Will use the mocked response
+```
+
+Note: This feature is only available when running tests on localnet.
+
 ## 🚀 Key Features
 
 - **Pytest Integration** – Extends pytest to support intelligent contract testing, making it familiar and easy to adopt.
@@ -275,7 +299,7 @@ Key features demonstrated in this contract:
 Here's how to deploy the Storage contract:
 
 ```python
-from gltest import get_contract_factory, default_account
+from gltest import get_contract_factory, get_default_account
 
 def test_deployment():
     # Get the contract factory for your contract
@@ -285,7 +309,7 @@ def test_deployment():
     # Deploy the contract with constructor arguments
     contract = factory.deploy(
         args=["initial_value"],  # Constructor arguments
-        account=default_account,  # Account to deploy from
+        account=get_default_account(),  # Account to deploy from
         consensus_max_rotations=3,  # Optional: max consensus rotations
         leader_only=False,  # Optional: whether to run only on leader
     )
@@ -384,6 +408,102 @@ Both `tx_execution_succeeded` and `tx_execution_failed` accept the following par
 
 For more example contracts, check out the [contracts directory](tests/examples/contracts) which contains various sample contracts demonstrating different features and use cases.
 
+### Test Fixtures
+
+The GenLayer Testing Suite provides reusable pytest fixtures in `gltest.fixtures` to simplify common testing operations. These fixtures can be imported and used in your test files to avoid repetitive setup code.
+
+#### Available Fixtures
+
+The following fixtures are available in `gltest.fixtures`:
+
+- **`gl_client`** (session scope) - GenLayer client instance for network operations
+- **`default_account`** (session scope) - Default account for testing and deployments
+- **`accounts`** (session scope) - List of test accounts for multi-account scenarios
+- **`setup_validators`** (function scope) - Function to create test validators for LLM operations
+
+##### 1. `gl_client` (session scope)
+Provides a GenLayer PY client instance that's created once per test session. This is useful for operations that interact directly with the GenLayer network.
+
+```python
+def test_client_operations(gl_client):
+    # Use the client for network operations
+    tx_hash = "0x1234..."
+    transaction = gl_client.get_transaction(tx_hash)
+```
+
+##### 2. `default_account` (session scope)
+Provides the default account used to execute transactions when no account is specified.
+
+```python
+def test_with_default_account(default_account):
+    # Use the default account for deployments
+    factory = get_contract_factory("MyContract")
+    contract = factory.deploy(account=default_account)
+```
+
+##### 3. `accounts` (session scope)
+Provides a list of account objects loaded from the private keys defined in `gltest.config.yaml` for the current network, or pre-created test accounts if no config is present
+
+```python
+def test_multiple_accounts(accounts):
+    # Get multiple accounts for testing
+    sender = accounts[0]
+    receiver = accounts[1]
+    
+    # Test transfers or multi-party interactions
+    contract.transfer(args=[receiver.address, 100], account=sender)
+```
+
+##### 4. `setup_validators` (function scope)
+Creates test validators for localnet environment. This fixture is particularly useful for testing LLM-based contract methods and consensus behavior. It yields a function that allows you to configure validators with custom settings.
+
+```python
+def test_with_validators(setup_validators):
+    # Setup validators with default configuration
+    setup_validators()
+    
+    # Or setup with custom mock responses for testing
+    mock_response = {"result": "mocked LLM response"}
+    setup_validators(mock_response=mock_response, n_validators=3)
+    
+    # Now test your LLM-based contract methods
+    contract = factory.deploy()
+    result = contract.llm_based_method()
+```
+
+Parameters for `setup_validators`:
+- `mock_response` (dict, optional): Mock validator response when using `--test-with-mocks` flag
+- `n_validators` (int, optional): Number of validators to create (default: 5)
+
+#### Using Fixtures in Your Tests
+
+To use these fixtures, simply import them and include them as parameters in your test functions:
+
+```python
+from gltest import get_contract_factory
+from gltest.assertions import tx_execution_succeeded
+
+def test_complete_workflow(gl_client, default_account, accounts, setup_validators):
+    # Setup validators for LLM operations
+    setup_validators()
+    
+    # Deploy contract with default account
+    factory = get_contract_factory("MyContract")
+    contract = factory.deploy(account=default_account)
+    
+    # Interact using other accounts
+    other_account = accounts[1]
+    tx_receipt = contract.some_method(args=["value"], account=other_account)
+    
+    assert tx_execution_succeeded(tx_receipt)
+```
+
+Fixtures help maintain clean, DRY test code by:
+- Eliminating repetitive setup code
+- Ensuring consistent test environments
+- Managing resource cleanup automatically
+- Providing appropriate scoping for performance
+
 ## 📝 Best Practices
 
 1. **Test Organization**

{genlayer_test-0.3.1 → genlayer_test-0.4.0}/genlayer_test.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ genlayer_test.egg-info/top_level.txt
 gltest/__init__.py
 gltest/assertions.py
 gltest/exceptions.py
+gltest/fixtures.py
 gltest/types.py
 gltest/artifacts/__init__.py
 gltest/artifacts/contract.py

genlayer_test-0.4.0/gltest/fixtures.py

@@ -0,0 +1,91 @@
+"""
+This module provides reusable pytest fixtures for common gltest operations.
+These fixtures can be imported and used in test files.
+"""
+
+import pytest
+from gltest.glchain import (
+    get_gl_client,
+    get_accounts,
+    get_default_account,
+    get_gl_provider,
+)
+from gltest_cli.config.general import get_general_config
+
+
+@pytest.fixture(scope="session")
+def gl_client():
+    """
+    Provides a GenLayer client instance.
+
+    Scope: session - created once per test session
+    """
+    return get_gl_client()
+
+
+@pytest.fixture(scope="session")
+def default_account():
+    """
+    Provides the default account for testing.
+
+    Scope: session - created once per test session
+    """
+    return get_default_account()
+
+
+@pytest.fixture(scope="session")
+def accounts():
+    """
+    Provides a list of test accounts.
+
+    Scope: session - created once per test session
+    """
+    return get_accounts()
+
+
+@pytest.fixture(scope="function")
+def setup_validators():
+    """
+    Creates test validators for localnet environment.
+
+    Args:
+        mock_response (dict, optional): Mock validator response when using --test-with-mocks flag
+        n_validators (int, optional): Number of validators to create (default: 5)
+
+    Scope: function - created fresh for each test
+    """
+    general_config = get_general_config()
+    provider = get_gl_provider()
+
+    def _setup(mock_response=None, n_validators=5):
+        if not general_config.check_local_rpc():
+            return
+        if general_config.get_test_with_mocks():
+            for _ in range(n_validators):
+                provider.make_request(
+                    method="sim_createValidator",
+                    params=[
+                        8,
+                        "openai",
+                        "gpt-4o",
+                        {"temperature": 0.75, "max_tokens": 500},
+                        "openai-compatible",
+                        {
+                            "api_key_env_var": "OPENAIKEY",
+                            "api_url": "https://api.openai.com",
+                            "mock_response": mock_response if mock_response else {},
+                        },
+                    ],
+                )
+        else:
+            provider.make_request(
+                method="sim_createRandomValidators",
+                params=[n_validators, 8, 12],
+            )
+
+    yield _setup
+
+    if not general_config.check_local_rpc():
+        return
+
+    provider.make_request(method="sim_deleteAllValidators", params=[])

{genlayer_test-0.3.1 → genlayer_test-0.4.0}/gltest/helpers/fixture_snapshot.py

@@ -1,6 +1,5 @@
 from typing import TypeVar, Callable, List, Any
 from dataclasses import dataclass
-from urllib.parse import urlparse
 from .take_snapshot import SnapshotRestorer, take_snapshot
 from gltest.exceptions import (
     FixtureSnapshotError,
@@ -9,8 +8,6 @@ from gltest.exceptions import (
 )
 from gltest_cli.config.general import get_general_config
 
-SUPPORTED_RPC_DOMAINS = ["localhost", "127.0.0.1"]
-
 T = TypeVar("T")
 
 
@@ -35,9 +32,7 @@ def load_fixture(fixture: Callable[[], T]) -> T:
         raise FixtureAnonymousFunctionError("Fixtures must be named functions")
 
     general_config = get_general_config()
-    rpc_url = general_config.get_rpc_url()
-    domain = urlparse(rpc_url).netloc.split(":")[0]  # Extract domain without port
-    if domain not in SUPPORTED_RPC_DOMAINS:
+    if not general_config.check_local_rpc():
         return fixture()
 
     # Find existing snapshot for this fixture

{genlayer_test-0.3.1 → genlayer_test-0.4.0}/gltest_cli/config/plugin.py

@@ -48,6 +48,13 @@ def pytest_addoption(parser):
         help="Target network (defaults to 'localnet' if no config file)",
     )
 
+    group.addoption(
+        "--test-with-mocks",
+        action="store_true",
+        default=False,
+        help="Test with mocks",
+    )
+
 
 def pytest_configure(config):
     general_config = get_general_config()
@@ -73,6 +80,7 @@ def pytest_configure(config):
     default_wait_retries = config.getoption("--default-wait-retries")
     rpc_url = config.getoption("--rpc-url")
     network = config.getoption("--network")
+    test_with_mocks = config.getoption("--test-with-mocks")
 
     plugin_config = PluginConfig()
     plugin_config.contracts_dir = (
@@ -82,6 +90,7 @@ def pytest_configure(config):
     plugin_config.default_wait_retries = int(default_wait_retries)
     plugin_config.rpc_url = rpc_url
     plugin_config.network_name = network
+    plugin_config.test_with_mocks = test_with_mocks
 
     general_config.plugin_config = plugin_config
 
@@ -100,3 +109,7 @@ def pytest_sessionstart(session):
         f"  Default wait interval: {general_config.get_default_wait_interval()} ms"
     )
     logger.info(f"  Default wait retries: {general_config.get_default_wait_retries()}")
+    logger.info(f"  Test with mocks: {general_config.get_test_with_mocks()}")
+
+
+pytest_plugins = ["gltest.fixtures"]

{genlayer_test-0.3.1 → genlayer_test-0.4.0}/gltest_cli/config/types.py

@@ -4,6 +4,7 @@ from pathlib import Path
 from typing import Dict, List, Optional
 from genlayer_py.chains import localnet, testnet_asimov
 from genlayer_py.types import GenLayerChain
+from urllib.parse import urlparse
 
 
 class NetworkConfig(str, Enum):
@@ -18,6 +19,7 @@ class PluginConfig:
     default_wait_interval: Optional[int] = None
     default_wait_retries: Optional[int] = None
     network_name: Optional[str] = None
+    test_with_mocks: bool = False
 
 
 @dataclass
@@ -135,3 +137,12 @@ class GeneralConfig:
         if self.plugin_config.network_name is not None:
             return self.plugin_config.network_name
         return self.user_config.default_network
+
+    def get_test_with_mocks(self) -> bool:
+        return self.plugin_config.test_with_mocks
+
+    def check_local_rpc(self) -> bool:
+        SUPPORTED_RPC_DOMAINS = ["localhost", "127.0.0.1"]
+        rpc_url = self.get_rpc_url()
+        domain = urlparse(rpc_url).netloc.split(":")[0]  # Extract domain without port
+        return domain in SUPPORTED_RPC_DOMAINS