genlayer-test 1.0.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

{genlayer_test-1.0.0.dist-info → genlayer_test-2.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: genlayer-test
-Version: 1.0.0
+Version: 2.0.0
 Summary: GenLayer Testing Suite
 Author: GenLayer
 License-Expression: MIT
@@ -15,7 +15,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pytest
 Requires-Dist: setuptools>=77.0
-Requires-Dist: genlayer-py==0.7.1
+Requires-Dist: genlayer-py==0.7.2
 Requires-Dist: colorama>=0.4.6
 Requires-Dist: pyyaml
 Requires-Dist: python-dotenv
@@ -114,6 +114,7 @@ networks:
 
   localnet:  # Local development network configuration
     url: "http://127.0.0.1:4000/api"
+    leader_only: false  # Set to true to run all contracts in leader-only mode by default
 
   testnet_asimov:  # Test network configuration
     id: 4221
@@ -125,6 +126,7 @@ networks:
 
 paths:
   contracts: "contracts"  # Path to your contracts directory
+  artifacts: "artifacts" # Path to your artifacts directory
 
 environment: .env  # Path to your environment file containing private keys and other secrets
 ```
@@ -137,12 +139,14 @@ Key configuration sections:
      - `url`: The RPC endpoint for the network
      - `id`: Chain ID
      - `accounts`: List of account private keys (using environment variables)
+     - `leader_only`: Leader only mode
    - Special case for `localnet`:
      - If a network is named `localnet`, missing fields will be filled with default values
      - For all other network names, `id`, `url`, and `accounts` are required fields
 
 2. **Paths**: Define important directory paths
    - `contracts`: Location of your contract files
+   - `artifacts`: Location of your artifacts files (analysis results will be stored here)
 
 3. **Environment**: Path to your `.env` file containing sensitive information like private keys
 
@@ -231,6 +235,20 @@ def test_with_mocked_llm(setup_validators):
 
 Note: This feature is only available when running tests on localnet.
 
+11. Run tests with leader-only mode enabled
+```bash
+$ gltest --leader-only
+```
+The `--leader-only` flag configures all contract deployments and write operations to run only on the leader node. This is useful for:
+- Faster test execution by avoiding consensus
+- Testing specific leader-only scenarios
+- Development and debugging purposes
+- Reducing computational overhead in test environments
+
+When this flag is enabled, all contracts deployed and all write transactions will automatically use leader-only mode, regardless of individual method parameters.
+
+**Note:** Leader-only mode is only available for studio-based networks (localhost, 127.0.0.1, *.genlayer.com, *.genlayerlabs.com). When enabled on other networks, it will have no effect and a warning will be logged.
+
 ## 🚀 Key Features
 
 - **Pytest Integration** – Extends pytest to support intelligent contract testing, making it familiar and easy to adopt.
@@ -251,8 +269,9 @@ Before diving into the examples, let's understand the basic project structure:
 genlayer-example/
 ├── contracts/              # Contract definitions
 │   └── storage.py          # Example storage contract
-└── test/                   # Test files
-    └── test_contract.py    # Contract test cases
+├── test/                   # Test files
+│   └── test_contract.py    # Contract test cases
+└── gltest.config.yaml      # Configuration file
 ```
 
 ### Storage Contract Example
@@ -311,7 +330,6 @@ def test_deployment():
         args=["initial_value"],  # Constructor arguments
         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
     )
     
     # Contract is now deployed and ready to use
@@ -357,7 +375,6 @@ def test_write_methods():
     ).transact(
         value=0,  # Optional: amount of native currency to send
         consensus_max_rotations=3,  # Optional: max consensus rotations
-        leader_only=False,  # Optional: whether to run only on leader
         wait_interval=1,  # Optional: seconds between status checks
         wait_retries=10,  # Optional: max number of retries
     )
@@ -604,13 +621,11 @@ The `.analyze()` method helps you:
    # Try with increased consensus parameters
    contract = factory.deploy(
        consensus_max_rotations=5,  # Increase number of consensus rotations
-       leader_only=True,  # Try leader-only mode for faster execution
    )
    
    # For critical operations, use more conservative settings
    contract = factory.deploy(
        consensus_max_rotations=10,  # More rotations for better reliability
-       leader_only=False,  # Full consensus for better security
        wait_interval=3,  # Longer wait between checks
        wait_retries=30  # More retries for consensus
    )

{genlayer_test-1.0.0.dist-info → genlayer_test-2.0.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-genlayer_test-1.0.0.dist-info/licenses/LICENSE,sha256=che_H4vE0QUx3HvWrAa1_jDEVInift0U6VO15-QqEls,1064
+genlayer_test-2.0.0.dist-info/licenses/LICENSE,sha256=che_H4vE0QUx3HvWrAa1_jDEVInift0U6VO15-QqEls,1064
 gltest/__init__.py,sha256=qoBV3IgDJr8uh9262XsWNMhi-ilkSgMqKVC9FVMk7cw,372
 gltest/accounts.py,sha256=HUmWguJMolggQaZNRPw-LGlRlQCjLLdUanKRowMv6pI,812
 gltest/assertions.py,sha256=0dEk0VxcHK4I7GZPHxJmz-2jaA60V499gOSR74rZbfM,1748
@@ -10,9 +10,9 @@ gltest/types.py,sha256=BODmwTr2gAUEiO9FjiuTiWwuKvXgo4xZWstQWNUfnlw,156
 gltest/artifacts/__init__.py,sha256=qTt3TE19gVNWnQLUlt5aDe4nNvJ2YJ1jzDkMmYIsCG0,194
 gltest/artifacts/contract.py,sha256=KChpmfjZod_0dVB8y-dvWz6IVm7QlIJsgG2ArtvVDaU,6457
 gltest/contracts/__init__.py,sha256=A9bvEtYOoqoHS8TLlFBfmNOnfwdsJPEf-AZuikagCHM,166
-gltest/contracts/contract.py,sha256=NGgciplaYINL_unJvLnOSWL4f8cNlHGMOEEbc6a1kw4,6402
-gltest/contracts/contract_factory.py,sha256=jjzxgsLW6AiQ4h8LcZwIzdq5Uqm-xkj_JZNhN0djijc,6691
-gltest/contracts/contract_functions.py,sha256=E-C9RnBkz3FeJRiswUaZbcDn4HRSWitsdwegSjX7E_Q,2089
+gltest/contracts/contract.py,sha256=cYr5B5Sy-YRtEk6PvlLGkRy1X0cwf1EmsCHb6xPL-Rw,6524
+gltest/contracts/contract_factory.py,sha256=4xoODlCu2jHh3Z2e6OmWWnAiXT99yFu_7DhVvCUbKZE,6812
+gltest/contracts/contract_functions.py,sha256=Dpgu9rUSMrczBgNSlEaZ47RUpKzV8vucnc6OyxExMnM,2017
 gltest/contracts/method_stats.py,sha256=zWWjvf7K5VC4yrHpDIR717VF7LYp1RaZ1Hr_RZvWxJA,5150
 gltest/contracts/stats_collector.py,sha256=fuCc8L8hd0tsVGzH4adtZWwPa7ORf0A0zR5Dt1w92Qk,9033
 gltest/contracts/utils.py,sha256=TTXgcXn9BuRIlKJrjwmU7R3l1IgXsXk2luM-r3lfbbg,296
@@ -24,13 +24,13 @@ gltest_cli/main.py,sha256=Ti2-0Ev1x5_cM0D1UKqdgaDt80CDHEQGtdRne2qLm4M,53
 gltest_cli/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 gltest_cli/config/constants.py,sha256=3iSK337AeupyYl_6Sf8MR_o91XfLmul8m1rVmi3Fvmo,342
 gltest_cli/config/general.py,sha256=ezpoGsT8grO9zQH6RugV14b1GzeFt-htYToHQBJhNvY,186
-gltest_cli/config/plugin.py,sha256=gMK1xrkJ4G0ddCjKAFB7lEXecdvoZiwndwwI4Srn66w,4857
+gltest_cli/config/plugin.py,sha256=zWNEJWjywI-T5B5Bc-8OyrGt7rUVlpNP8zrlsORhVgw,5412
 gltest_cli/config/pytest_context.py,sha256=Ze8JSkrwMTCE8jIhpzU_71CEXg92SiEPvSgNTp-gbS4,243
-gltest_cli/config/types.py,sha256=w7KyINjM3_n4MYoRPfMBgudptjXjnSKPficAsqqSUTY,6344
-gltest_cli/config/user.py,sha256=VSS7llCUJc2GSIexdL73FqkLthdiECwmQONO3-WYi7o,8242
+gltest_cli/config/types.py,sha256=KDAA_vNqI7o_sYMj21ks3WaIXGrbLVb76E17TSlWUwI,7241
+gltest_cli/config/user.py,sha256=WNX_Wi2eJpjW0UstQuQiDjzRpOIOwx9iiXOx4ntt93U,8759
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/conftest.py,sha256=RKdoE5_zcMimeojAoA_GSFI9du4pMzMi1vZ1njtfoAs,28
-tests/examples/contracts/football_prediction_market.py,sha256=0Lm2x2F1DhmUP1fcfzGQAfc50tWFcaHliwyAzXIRFVw,3247
+tests/examples/contracts/football_prediction_market.py,sha256=9xwU8f3q73Hae-ByHy_wauhMPLRnLZd4XKNrClnjOJM,3248
 tests/examples/contracts/intelligent_oracle.py,sha256=cZNGbjKMXY-pimVmPIKIlS963Gd3L1JAipq0VBR1J5Q,12360
 tests/examples/contracts/intelligent_oracle_factory.py,sha256=8lBEn3Atb0yUpXwlvnShlcRxCBTXCrrkoITDHWoWuHU,1499
 tests/examples/contracts/llm_erc20.py,sha256=pOvSUszCtC_f5yDX0tZnj494Ce10uESZ09JLLE8V67o,2534
@@ -65,11 +65,12 @@ tests/gltest/artifact/contracts/duplicate_ic_contract_2.py,sha256=bSWsUVjBy5cGtI
 tests/gltest/artifact/contracts/not_ic_contract.py,sha256=hQyGnYiiVceYdLI2WrvcFgPqzy1S4-YMb9FPhiHEGSA,510
 tests/gltest/assertions/test_assertions.py,sha256=qzVrOdOM4xYtIy1sFHVAD_-naDHOequ23tEN0MELh0k,10781
 tests/gltest_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/gltest_cli/config/test_general_config.py,sha256=T2haLj41-6tbEfybdXnEycIQQFNkdc_O07qmg_37dqM,5730
-tests/gltest_cli/config/test_plugin.py,sha256=GYY56VR39-uI2WXK-rlzTxB5Ui2h9f5oF_kO0iNljRo,5862
-tests/gltest_cli/config/test_user.py,sha256=40nEC-gM03Q86SnmJpkGfMRvKKtEkfx53qaGHj8XXGQ,13988
-genlayer_test-1.0.0.dist-info/METADATA,sha256=g1QNA8KP65HqSApiaNYcunHwz1Ch2IO_RIkFcbVk5Vo,24143
-genlayer_test-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-genlayer_test-1.0.0.dist-info/entry_points.txt,sha256=RWPcSArBpz_G4BYioh5L8Q8hyClRbSgzLimjcWMp-BQ,94
-genlayer_test-1.0.0.dist-info/top_level.txt,sha256=-qiGZxTRBytujzgVcKpxjvQ-WNeUDjXa59ceGMwMpko,24
-genlayer_test-1.0.0.dist-info/RECORD,,
+tests/gltest_cli/config/test_config_integration.py,sha256=vPTzr3_h9UMw7m72HogBJE2ZPhRduXoLSq18Z7FoCWQ,10105
+tests/gltest_cli/config/test_general_config.py,sha256=UHtSwVnso-ZwNtYM0Z4v2sCLKwyrVbHlk6b1leVfV84,14703
+tests/gltest_cli/config/test_plugin.py,sha256=87kJpSYcWbNuKDqfc_jiN7hoRnFkMEnOOTINwuXKBY0,7981
+tests/gltest_cli/config/test_user.py,sha256=JxR655oUFoM9quWQO68CVPKRpT0TMpzS3bF6j6NWyT4,14401
+genlayer_test-2.0.0.dist-info/METADATA,sha256=ykgDxxVQ0p5XRRShD6ke9amrhH4o7MacAQsUya0r5Ts,24978
+genlayer_test-2.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+genlayer_test-2.0.0.dist-info/entry_points.txt,sha256=RWPcSArBpz_G4BYioh5L8Q8hyClRbSgzLimjcWMp-BQ,94
+genlayer_test-2.0.0.dist-info/top_level.txt,sha256=-qiGZxTRBytujzgVcKpxjvQ-WNeUDjXa59ceGMwMpko,24
+genlayer_test-2.0.0.dist-info/RECORD,,

gltest/contracts/contract.py

@@ -46,7 +46,6 @@ def write_contract_wrapper(
     def transact_method(
         value: int = 0,
         consensus_max_rotations: Optional[int] = None,
-        leader_only: bool = False,
         wait_transaction_status: TransactionStatus = TransactionStatus.FINALIZED,
         wait_interval: Optional[int] = None,
         wait_retries: Optional[int] = None,
@@ -67,6 +66,11 @@ def write_contract_wrapper(
             if wait_retries is not None
             else general_config.get_default_wait_retries()
         )
+        leader_only = (
+            general_config.get_leader_only()
+            if general_config.check_studio_based_rpc()
+            else False
+        )
         client = get_gl_client()
         tx_hash = client.write_contract(
             address=self.address,

gltest/contracts/contract_factory.py

@@ -23,7 +23,6 @@ from gltest.exceptions import DeploymentError
 from gltest_cli.config.general import get_general_config
 
 
-
 @dataclass
 class ContractFactory:
     """
@@ -108,7 +107,6 @@ class ContractFactory:
         args: List[Any] = [],
         account: Optional[LocalAccount] = None,
         consensus_max_rotations: Optional[int] = None,
-        leader_only: bool = False,
         wait_interval: Optional[int] = None,
         wait_retries: Optional[int] = None,
         wait_transaction_status: TransactionStatus = TransactionStatus.FINALIZED,
@@ -121,6 +119,11 @@ class ContractFactory:
             wait_interval = general_config.get_default_wait_interval()
         if wait_retries is None:
             wait_retries = general_config.get_default_wait_retries()
+        leader_only = (
+            general_config.get_leader_only()
+            if general_config.check_studio_based_rpc()
+            else False
+        )
 
         client = get_gl_client()
         try:

gltest/contracts/contract_functions.py

@@ -20,7 +20,6 @@ class ContractFunction:
         self,
         value: int = 0,
         consensus_max_rotations: Optional[int] = None,
-        leader_only: bool = False,
         wait_transaction_status: TransactionStatus = TransactionStatus.FINALIZED,
         wait_interval: Optional[int] = None,
         wait_retries: Optional[int] = None,
@@ -32,7 +31,6 @@ class ContractFunction:
         return self.transact_method(
             value=value,
             consensus_max_rotations=consensus_max_rotations,
-            leader_only=leader_only,
             wait_transaction_status=wait_transaction_status,
             wait_interval=wait_interval,
             wait_retries=wait_retries,

gltest_cli/config/plugin.py

@@ -64,6 +64,13 @@ def pytest_addoption(parser):
         help="Test with mocks",
     )
 
+    group.addoption(
+        "--leader-only",
+        action="store_true",
+        default=False,
+        help="Run contracts in leader-only mode",
+    )
+
 
 def pytest_configure(config):
     general_config = get_general_config()
@@ -91,6 +98,7 @@ def pytest_configure(config):
     rpc_url = config.getoption("--rpc-url")
     network = config.getoption("--network")
     test_with_mocks = config.getoption("--test-with-mocks")
+    leader_only = config.getoption("--leader-only")
 
     plugin_config = PluginConfig()
     plugin_config.contracts_dir = (
@@ -104,6 +112,7 @@ def pytest_configure(config):
     plugin_config.rpc_url = rpc_url
     plugin_config.network_name = network
     plugin_config.test_with_mocks = test_with_mocks
+    plugin_config.leader_only = leader_only
 
     general_config.plugin_config = plugin_config
 
@@ -137,6 +146,13 @@ def pytest_sessionstart(session):
     logger.info(f"  Default wait retries: {general_config.get_default_wait_retries()}")
     logger.info(f"  Test with mocks: {general_config.get_test_with_mocks()}")
 
+    if general_config.get_leader_only() and not general_config.check_studio_based_rpc():
+        logger.warning(
+            "Leader only mode: True (enabled on non-studio network - will have no effect)"
+        )
+    else:
+        logger.info(f"  Leader only mode: {general_config.get_leader_only()}")
+
 
 def pytest_runtest_setup(item):
     _pytest_context.current_item = item

gltest_cli/config/types.py

@@ -21,6 +21,7 @@ class PluginConfig:
     default_wait_retries: Optional[int] = None
     network_name: Optional[str] = None
     test_with_mocks: bool = False
+    leader_only: bool = False
 
 
 @dataclass
@@ -29,6 +30,7 @@ class NetworkConfigData:
     url: Optional[str] = None
     accounts: Optional[List[str]] = None
     from_account: Optional[str] = None
+    leader_only: bool = False
 
     def __post_init__(self):
         if self.id is not None and not isinstance(self.id, int):
@@ -157,8 +159,31 @@ class GeneralConfig:
     def get_test_with_mocks(self) -> bool:
         return self.plugin_config.test_with_mocks
 
+    def get_leader_only(self) -> bool:
+        if self.plugin_config.leader_only:
+            return True
+        network_name = self.get_network_name()
+        if network_name in self.user_config.networks:
+            network_config = self.user_config.networks[network_name]
+            return network_config.leader_only
+        return False
+
     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
+
+    def check_studio_based_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
+
+        if domain in SUPPORTED_RPC_DOMAINS:
+            return True
+
+        # Check .genlayer.com or .genlayerlabs.com subdomains
+        if domain.endswith(".genlayer.com") or domain.endswith(".genlayerlabs.com"):
+            return True
+
+        return False

gltest_cli/config/user.py

@@ -17,7 +17,7 @@ from gltest_cli.config.constants import (
 from gltest_cli.config.types import UserConfig, NetworkConfigData, PathConfig
 
 VALID_ROOT_KEYS = ["networks", "paths", "environment"]
-VALID_NETWORK_KEYS = ["id", "url", "accounts", "from"]
+VALID_NETWORK_KEYS = ["id", "url", "accounts", "from", "leader_only"]
 VALID_PATHS_KEYS = ["contracts", "artifacts"]
 
 
@@ -33,6 +33,7 @@ def get_default_user_config() -> UserConfig:
                 url=DEFAULT_RPC_URL,
                 accounts=accounts_private_keys,
                 from_account=accounts_private_keys[0],
+                leader_only=False,
             ),
         },
         paths=PathConfig(
@@ -84,6 +85,10 @@ def validate_network_config(network_name: str, network_config: dict):
 
     if "from" in network_config and not isinstance(network_config["from"], str):
         raise ValueError(f"network {network_name} from must be a string")
+    if "leader_only" in network_config and not isinstance(
+        network_config["leader_only"], bool
+    ):
+        raise ValueError(f"network {network_name} leader_only must be a boolean")
 
     # For non-default networks, url and accounts are required
     if network_name != DEFAULT_NETWORK:
@@ -185,18 +190,23 @@ def _get_overridden_networks(raw_config: dict) -> tuple[dict, str]:
                 ]
             if "from" in network_config:
                 networks_config[network_name].from_account = network_config["from"]
+            if "leader_only" in network_config:
+                networks_config[network_name].leader_only = network_config[
+                    "leader_only"
+                ]
             continue
 
         url = network_config["url"]
         accounts = network_config["accounts"]
         from_account = network_config.get("from", accounts[0])
         network_id = network_config.get("id")
-
+        leader_only = network_config.get("leader_only", False)
         networks_config[network_name] = NetworkConfigData(
             id=network_id,
             url=url,
             accounts=accounts,
             from_account=from_account,
+            leader_only=leader_only,
         )
     return networks_config, user_default_network
 

tests/examples/contracts/football_prediction_market.py

@@ -97,4 +97,4 @@ This result should be perfectly parsable by a JSON parser without errors.
             "winner": self.winner,
             "score": self.score,
             "has_resolved": self.has_resolved,
-        }
+        }

tests/gltest_cli/config/test_config_integration.py

@@ -0,0 +1,432 @@
+def test_leader_only_network_config_true(pytester):
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_leader_only_network_config():
+            general_config = get_general_config()
+            assert general_config.get_leader_only() == True
+    """
+    )
+
+    config_content = """
+networks:
+  default: localnet
+  localnet:
+    url: "http://127.0.0.1:4000/api"
+    leader_only: true
+
+paths:
+  contracts: "contracts"
+
+environment: .env
+"""
+
+    pytester.makefile(".config.yaml", **{"gltest": config_content})
+
+    result = pytester.runpytest("-v")
+
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_leader_only_network_config PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_leader_only_network_config_false(pytester):
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_leader_only_network_config():
+            general_config = get_general_config()
+            assert general_config.get_leader_only() == False
+    """
+    )
+
+    config_content = """
+networks:
+  default: localnet
+  localnet:
+    url: "http://127.0.0.1:4000/api"
+    leader_only: false
+
+paths:
+  contracts: "contracts"
+
+environment: .env
+"""
+
+    pytester.makefile(".config.yaml", **{"gltest": config_content})
+
+    result = pytester.runpytest("-v")
+
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_leader_only_network_config PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_leader_only_cli_overrides_network_config(pytester):
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_leader_only_cli_overrides():
+            general_config = get_general_config()
+            assert general_config.get_leader_only() == True
+    """
+    )
+
+    config_content = """
+networks:
+  default: localnet
+  localnet:
+    url: "http://127.0.0.1:4000/api"
+    leader_only: false
+
+paths:
+  contracts: "contracts"
+
+environment: .env
+"""
+
+    pytester.makefile(".config.yaml", **{"gltest": config_content})
+
+    # CLI flag should override network config
+    result = pytester.runpytest("--leader-only", "-v")
+
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_leader_only_cli_overrides PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_leader_only_network_config_default(pytester):
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_leader_only_network_config_default():
+            general_config = get_general_config()
+            assert general_config.get_leader_only() == False
+    """
+    )
+
+    config_content = """
+networks:
+  default: localnet
+  localnet:
+    url: "http://127.0.0.1:4000/api"
+
+paths:
+  contracts: "contracts"
+
+environment: .env
+"""
+
+    pytester.makefile(".config.yaml", **{"gltest": config_content})
+
+    result = pytester.runpytest("-v")
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_leader_only_network_config_default PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_custom_accounts_config(pytester):
+    """Test custom accounts configuration."""
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_custom_accounts():
+            general_config = get_general_config()
+            accounts = general_config.get_accounts_keys()
+            assert len(accounts) == 3
+            assert accounts[0] == "account1_private_key"
+            assert accounts[1] == "account2_private_key"
+            assert accounts[2] == "account3_private_key"
+            from_account = general_config.get_default_account_key()
+            assert from_account == "account1_private_key"
+    """
+    )
+
+    config_content = """
+networks:
+  default: localnet
+  localnet:
+    url: "http://127.0.0.1:4000/api"
+    accounts:
+      - "account1_private_key"
+      - "account2_private_key"
+      - "account3_private_key"
+
+paths:
+  contracts: "contracts"
+
+environment: .env
+"""
+
+    pytester.makefile(".config.yaml", **{"gltest": config_content})
+
+    result = pytester.runpytest("-v")
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_custom_accounts PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_from_account_config(pytester):
+    """Test 'from' account configuration."""
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_from_account():
+            general_config = get_general_config()
+            from_account = general_config.get_default_account_key()
+            assert from_account == "account2_private_key"
+    """
+    )
+
+    config_content = """
+networks:
+  default: localnet
+  localnet:
+    url: "http://127.0.0.1:4000/api"
+    accounts:
+      - "account1_private_key"
+      - "account2_private_key"
+      - "account3_private_key"
+    from: "account2_private_key"
+
+paths:
+  contracts: "contracts"
+
+environment: .env
+"""
+
+    pytester.makefile(".config.yaml", **{"gltest": config_content})
+
+    result = pytester.runpytest("-v")
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_from_account PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_multiple_networks_config(pytester):
+    """Test multiple networks configuration."""
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_multiple_networks():
+            general_config = get_general_config()
+            # Default should be testnet
+            assert general_config.get_network_name() == "testnet"
+            rpc_url = general_config.get_rpc_url()
+            assert rpc_url == "https://testnet.example.com"
+    """
+    )
+
+    config_content = """
+networks:
+  default: testnet
+  localnet:
+    id: 61999
+    url: "http://127.0.0.1:4000/api"
+    accounts:
+      - "local_account1"
+      - "local_account2"
+  testnet:
+    id: 5555
+    url: "https://testnet.example.com"
+    accounts:
+      - "testnet_account1"
+      - "testnet_account2"
+    leader_only: true
+
+paths:
+  contracts: "contracts"
+
+environment: .env
+"""
+
+    pytester.makefile(".config.yaml", **{"gltest": config_content})
+
+    result = pytester.runpytest("-v")
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_multiple_networks PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_custom_paths_config(pytester):
+    """Test custom paths configuration."""
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+        from pathlib import Path
+
+        def test_custom_paths():
+            general_config = get_general_config()
+            assert general_config.get_contracts_dir() == Path("src/contracts")
+            assert general_config.get_artifacts_dir() == Path("build/artifacts")
+    """
+    )
+
+    config_content = """
+networks:
+  default: localnet
+  localnet:
+    url: "http://127.0.0.1:4000/api"
+
+paths:
+  contracts: "src/contracts"
+  artifacts: "build/artifacts"
+
+environment: .env
+"""
+
+    pytester.makefile(".config.yaml", **{"gltest": config_content})
+
+    result = pytester.runpytest("-v")
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_custom_paths PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_custom_environment_file(pytester):
+    """Test custom environment file configuration."""
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_custom_environment():
+            general_config = get_general_config()
+            assert general_config.user_config.environment == ".env.test"
+    """
+    )
+
+    config_content = """
+networks:
+  default: localnet
+  localnet:
+    url: "http://127.0.0.1:4000/api"
+
+paths:
+  contracts: "contracts"
+
+environment: .env.test
+"""
+
+    pytester.makefile(".config.yaml", **{"gltest": config_content})
+
+    result = pytester.runpytest("-v")
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_custom_environment PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_cli_network_override(pytester):
+    """Test CLI network override of config file."""
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_network_override():
+            general_config = get_general_config()
+            assert general_config.get_network_name() == "testnet"
+            rpc_url = general_config.get_rpc_url()
+            assert rpc_url == "https://testnet.example.com"
+    """
+    )
+
+    config_content = """
+networks:
+  default: localnet
+  localnet:
+    id: 61999
+    url: "http://127.0.0.1:4000/api"
+    accounts:
+      - "local_account1"
+  testnet:
+    id: 5555
+    url: "https://testnet.example.com"
+    accounts:
+      - "testnet_account1"
+
+paths:
+  contracts: "contracts"
+
+environment: .env
+"""
+
+    pytester.makefile(".config.yaml", **{"gltest": config_content})
+
+    result = pytester.runpytest("--network=testnet", "-v")
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_network_override PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_wait_interval_and_retries_config(pytester):
+    """Test default wait interval and retries from CLI."""
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_wait_config():
+            general_config = get_general_config()
+            assert general_config.get_default_wait_interval() == 3000
+            assert general_config.get_default_wait_retries() == 20
+    """
+    )
+
+    config_content = """
+networks:
+  default: localnet
+  localnet:
+    url: "http://127.0.0.1:4000/api"
+
+paths:
+  contracts: "contracts"
+
+environment: .env
+"""
+
+    pytester.makefile(".config.yaml", **{"gltest": config_content})
+
+    result = pytester.runpytest(
+        "--default-wait-interval=3000", "--default-wait-retries=20", "-v"
+    )
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_wait_config PASSED*",
+        ]
+    )
+    assert result.ret == 0

tests/gltest_cli/config/test_general_config.py

@@ -147,3 +147,260 @@ def test_general_config_contracts_default():
 
     # Should return default contracts directory
     assert general_config.get_contracts_dir() == DEFAULT_CONTRACTS_DIR
+
+
+def test_general_config_leader_only_default():
+    """Test GeneralConfig leader_only with default values."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData()},
+    )
+
+    plugin_config = PluginConfig()
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Should return False by default
+    assert general_config.get_leader_only() is False
+
+
+def test_general_config_leader_only_network_config():
+    """Test GeneralConfig leader_only from network configuration."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData(leader_only=True)},
+        default_network="localnet",
+    )
+
+    plugin_config = PluginConfig()
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Should return True from network config
+    assert general_config.get_leader_only() is True
+
+
+def test_general_config_leader_only_plugin_precedence():
+    """Test that plugin config takes precedence over network config for leader_only."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData(leader_only=False)},
+        default_network="localnet",
+    )
+
+    plugin_config = PluginConfig(leader_only=True)
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Plugin config should take precedence
+    assert general_config.get_leader_only() is True
+
+
+def test_general_config_leader_only_multiple_networks():
+    """Test leader_only with multiple networks."""
+    user_config = UserConfig(
+        networks={
+            "localnet": NetworkConfigData(leader_only=False),
+            "testnet": NetworkConfigData(leader_only=True),
+        },
+        default_network="testnet",
+    )
+
+    plugin_config = PluginConfig()
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Should use the default network's leader_only value
+    assert general_config.get_leader_only() is True
+
+    # Change network via plugin config
+    plugin_config.network_name = "localnet"
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+    assert general_config.get_leader_only() is False
+
+
+def test_general_config_leader_only_network_not_found():
+    """Test leader_only when selected network is not found."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData(leader_only=True)},
+        default_network="localnet",
+    )
+
+    plugin_config = PluginConfig(network_name="nonexistent")
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Should return False when network is not found
+    assert general_config.get_leader_only() is False
+
+
+def test_check_local_rpc_with_localhost():
+    """Test check_local_rpc with localhost URL."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData(url="http://localhost:8545")},
+        default_network="localnet",
+    )
+
+    plugin_config = PluginConfig()
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    assert general_config.check_local_rpc() is True
+
+
+def test_check_local_rpc_with_127_0_0_1():
+    """Test check_local_rpc with 127.0.0.1 URL."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData(url="http://127.0.0.1:8545")},
+        default_network="localnet",
+    )
+
+    plugin_config = PluginConfig()
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    assert general_config.check_local_rpc() is True
+
+
+def test_check_local_rpc_with_external_url():
+    """Test check_local_rpc with external URL."""
+    user_config = UserConfig(
+        networks={"testnet": NetworkConfigData(url="https://api.genlayer.com:8545")},
+        default_network="testnet",
+    )
+
+    plugin_config = PluginConfig()
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    assert general_config.check_local_rpc() is False
+
+
+def test_check_local_rpc_with_plugin_override():
+    """Test check_local_rpc with plugin config RPC URL override."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData(url="https://external.com")},
+        default_network="localnet",
+    )
+
+    plugin_config = PluginConfig(rpc_url="http://localhost:9000")
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Plugin config should take precedence
+    assert general_config.check_local_rpc() is True
+
+
+def test_check_studio_based_rpc_with_localhost():
+    """Test check_studio_based_rpc with localhost URL."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData(url="http://localhost:8545")},
+        default_network="localnet",
+    )
+
+    plugin_config = PluginConfig()
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    assert general_config.check_studio_based_rpc() is True
+
+
+def test_check_studio_based_rpc_with_127_0_0_1():
+    """Test check_studio_based_rpc with 127.0.0.1 URL."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData(url="http://127.0.0.1:8545")},
+        default_network="localnet",
+    )
+
+    plugin_config = PluginConfig()
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    assert general_config.check_studio_based_rpc() is True
+
+
+def test_check_studio_based_rpc_with_genlayer_subdomain():
+    """Test check_studio_based_rpc with .genlayer.com subdomains."""
+    test_cases = [
+        "https://api.genlayer.com:8545",
+        "https://test.genlayer.com",
+        "http://staging.api.genlayer.com:9000",
+        "https://dev.test.genlayer.com",
+    ]
+
+    for url in test_cases:
+        user_config = UserConfig(
+            networks={"testnet": NetworkConfigData(url=url)},
+            default_network="testnet",
+        )
+
+        plugin_config = PluginConfig()
+        general_config = GeneralConfig(
+            user_config=user_config, plugin_config=plugin_config
+        )
+
+        assert general_config.check_studio_based_rpc() is True, f"Failed for URL: {url}"
+
+
+def test_check_studio_based_rpc_with_genlayerlabs_subdomain():
+    """Test check_studio_based_rpc with .genlayerlabs.com subdomains."""
+    test_cases = [
+        "https://api.genlayerlabs.com:8545",
+        "https://test.genlayerlabs.com",
+        "http://staging.api.genlayerlabs.com:9000",
+        "https://dev.test.genlayerlabs.com",
+    ]
+
+    for url in test_cases:
+        user_config = UserConfig(
+            networks={"testnet": NetworkConfigData(url=url)},
+            default_network="testnet",
+        )
+
+        plugin_config = PluginConfig()
+        general_config = GeneralConfig(
+            user_config=user_config, plugin_config=plugin_config
+        )
+
+        assert general_config.check_studio_based_rpc() is True, f"Failed for URL: {url}"
+
+
+def test_check_studio_based_rpc_with_non_genlayer_domain():
+    """Test check_studio_based_rpc with non-GenLayer domains."""
+    test_cases = [
+        "https://api.example.com:8545",
+        "https://test.otherdomain.com",
+        "http://staging.api.random.org:9000",
+        "https://genlayer.example.com",  # Not a subdomain of .genlayer.com
+        "https://genlayerlabs.example.com",  # Not a subdomain of .genlayerlabs.com
+    ]
+
+    for url in test_cases:
+        user_config = UserConfig(
+            networks={"testnet": NetworkConfigData(url=url)},
+            default_network="testnet",
+        )
+
+        plugin_config = PluginConfig()
+        general_config = GeneralConfig(
+            user_config=user_config, plugin_config=plugin_config
+        )
+
+        assert (
+            general_config.check_studio_based_rpc() is False
+        ), f"Failed for URL: {url}"
+
+
+def test_check_studio_based_rpc_with_plugin_override():
+    """Test check_studio_based_rpc with plugin config RPC URL override."""
+    # User config has external URL, but plugin overrides with GenLayer domain
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData(url="https://external.com")},
+        default_network="localnet",
+    )
+
+    plugin_config = PluginConfig(rpc_url="https://api.genlayer.com:9000")
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Plugin config should take precedence
+    assert general_config.check_studio_based_rpc() is True
+
+    # Test opposite case: user has GenLayer domain, plugin overrides with external
+    user_config2 = UserConfig(
+        networks={"localnet": NetworkConfigData(url="https://api.genlayer.com")},
+        default_network="localnet",
+    )
+
+    plugin_config2 = PluginConfig(rpc_url="https://external.com:9000")
+    general_config2 = GeneralConfig(
+        user_config=user_config2, plugin_config=plugin_config2
+    )
+
+    # Plugin config should take precedence
+    assert general_config2.check_studio_based_rpc() is False

tests/gltest_cli/config/test_plugin.py

@@ -17,6 +17,8 @@ def test_help_message(pytester):
             "  --rpc-url=RPC_URL     RPC endpoint URL for the GenLayer network",
             "  --network=NETWORK     Target network (defaults to 'localnet' if no config",
             "                        file)",
+            "  --test-with-mocks     Test with mocks",
+            "  --leader-only         Run contracts in leader-only mode",
         ]
     )
 
@@ -178,6 +180,50 @@ def test_contracts_and_artifacts_dirs(pytester):
     assert result.ret == 0
 
 
+def test_test_with_mocks_true(pytester):
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_test_with_mocks():
+            general_config = get_general_config()
+            assert general_config.get_test_with_mocks() == True
+    """
+    )
+
+    result = pytester.runpytest("--test-with-mocks", "-v")
+
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_test_with_mocks PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_test_with_mocks_false(pytester):
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_test_with_mocks():
+            general_config = get_general_config()
+            assert general_config.get_test_with_mocks() == False
+            "*::test_test_with_mocks PASSED*",
+
+    """
+    )
+
+    result = pytester.runpytest("-v")
+
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_test_with_mocks PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
 def test_artifacts_dir_default_fallback(pytester):
     """Test that artifacts directory falls back to config file default when CLI not provided."""
     pytester.makepyfile(
@@ -192,6 +238,7 @@ def test_artifacts_dir_default_fallback(pytester):
             assert isinstance(artifacts_dir, Path)
             # Default should be 'artifacts' 
             assert str(artifacts_dir) == "artifacts"
+
     """
     )
 
@@ -203,3 +250,45 @@ def test_artifacts_dir_default_fallback(pytester):
         ]
     )
     assert result.ret == 0
+
+
+def test_leader_only_true(pytester):
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_leader_only():
+            general_config = get_general_config()
+            assert general_config.get_leader_only() == True
+    """
+    )
+
+    result = pytester.runpytest("--leader-only", "-v")
+
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_leader_only PASSED*",
+        ]
+    )
+    assert result.ret == 0
+
+
+def test_leader_only_false(pytester):
+    pytester.makepyfile(
+        """
+        from gltest_cli.config.general import get_general_config
+
+        def test_leader_only():
+            general_config = get_general_config()
+            assert general_config.get_leader_only() == False
+    """
+    )
+
+    result = pytester.runpytest("-v")
+
+    result.stdout.fnmatch_lines(
+        [
+            "*::test_leader_only PASSED*",
+        ]
+    )
+    assert result.ret == 0

tests/gltest_cli/config/test_user.py

@@ -137,6 +137,11 @@ def test_validate_raw_user_config_invalid():
             {"networks": {"default": "localnet", "localnet": {"from": 123}}}
         )
 
+    with pytest.raises(ValueError, match="leader_only must be a boolean"):
+        validate_raw_user_config(
+            {"networks": {"default": "localnet", "localnet": {"leader_only": "true"}}}
+        )
+
     with pytest.raises(ValueError, match="paths must be a dictionary"):
         validate_raw_user_config({"paths": "not_a_dict"})
 
@@ -182,6 +187,11 @@ def test_validate_raw_user_config_invalid():
             {"networks": {"default": "localnet", "testnet": {"from": 123}}}
         )
 
+    with pytest.raises(ValueError, match="leader_only must be a boolean"):
+        validate_raw_user_config(
+            {"networks": {"default": "localnet", "testnet": {"leader_only": "true"}}}
+        )
+
     # Test required fields for non-default networks
     with pytest.raises(ValueError, match="network testnet must have an id"):
         validate_raw_user_config(