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

gltest_cli/config/user.py

@@ -4,20 +4,21 @@ import re
 from dotenv import load_dotenv
 from pathlib import Path
 from functools import lru_cache
-from gltest.glchain.account import create_accounts
+from gltest.accounts import create_accounts
 from gltest_cli.config.constants import (
     GLTEST_CONFIG_FILE,
     DEFAULT_NETWORK,
     DEFAULT_RPC_URL,
     DEFAULT_ENVIRONMENT,
     DEFAULT_CONTRACTS_DIR,
+    DEFAULT_ARTIFACTS_DIR,
     DEFAULT_NETWORK_ID,
 )
 from gltest_cli.config.types import UserConfig, NetworkConfigData, PathConfig
 
 VALID_ROOT_KEYS = ["networks", "paths", "environment"]
 VALID_NETWORK_KEYS = ["id", "url", "accounts", "from"]
-VALID_PATHS_KEYS = ["contracts"]
+VALID_PATHS_KEYS = ["contracts", "artifacts"]
 
 
 @lru_cache(maxsize=1)
@@ -34,7 +35,9 @@ def get_default_user_config() -> UserConfig:
                 from_account=accounts_private_keys[0],
             ),
         },
-        paths=PathConfig(contracts=DEFAULT_CONTRACTS_DIR),
+        paths=PathConfig(
+            contracts=DEFAULT_CONTRACTS_DIR, artifacts=DEFAULT_ARTIFACTS_DIR
+        ),
         environment=DEFAULT_ENVIRONMENT,
         default_network=DEFAULT_NETWORK,
     )
@@ -208,10 +211,10 @@ def _get_overridden_environment(raw_config: dict) -> str:
 def _get_overridden_paths(raw_config: dict) -> PathConfig:
     default_config = get_default_user_config()
     if "paths" in raw_config:
+        paths_config = raw_config.get("paths", {})
         return PathConfig(
-            contracts=Path(
-                raw_config.get("paths", {}).get("contracts", DEFAULT_CONTRACTS_DIR)
-            )
+            contracts=Path(paths_config.get("contracts", DEFAULT_CONTRACTS_DIR)),
+            artifacts=Path(paths_config.get("artifacts", DEFAULT_ARTIFACTS_DIR)),
         )
     return default_config.paths
 

gltest_cli/logging.py

@@ -30,7 +30,7 @@ class ColoredFormatter(logging.Formatter):
 
 
 def setup_logger():
-    logger = logging.getLogger("gltest")
+    logger = logging.getLogger("gltest_cli")
     logger.setLevel(logging.DEBUG)
 
     if logger.handlers:

tests/examples/tests/test_football_prediction_market.py

@@ -27,11 +27,11 @@ def test_football_prediction_market(setup_validators):
     contract = factory.deploy(args=["2024-06-26", "Georgia", "Portugal"])
 
     # Resolve match
-    transaction_response_call_1 = contract.resolve(args=[])
+    transaction_response_call_1 = contract.resolve(args=[]).transact()
     assert tx_execution_succeeded(transaction_response_call_1)
 
     # Get Updated State
-    contract_state_2 = contract.get_resolution_data(args=[])
+    contract_state_2 = contract.get_resolution_data(args=[]).call()
 
     assert contract_state_2["winner"] == 1
     assert contract_state_2["score"] == "2:0"

tests/examples/tests/test_intelligent_oracle_factory.py

@@ -12,7 +12,7 @@ def wait_for_contract_deployment(intelligent_oracle_contract, max_retries=10, de
     """
     for _ in range(max_retries):
         try:
-            intelligent_oracle_contract.get_dict(args=[])
+            intelligent_oracle_contract.get_dict(args=[]).call()
             return True  # If successful, contract is deployed
         except Exception:
             time.sleep(delay)
@@ -124,11 +124,11 @@ def test_intelligent_oracle_factory_pattern(setup_validators):
                 market_data["resolution_urls"],
                 market_data["earliest_resolution_date"],
             ],
-        )
+        ).transact()
         assert tx_execution_succeeded(create_result)
 
         # Get the latest contract address from factory
-        registered_addresses = registry_contract.get_contract_addresses(args=[])
+        registered_addresses = registry_contract.get_contract_addresses(args=[]).call()
         new_market_address = registered_addresses[-1]
 
         # Build a contract object
@@ -145,7 +145,7 @@ def test_intelligent_oracle_factory_pattern(setup_validators):
 
     # Verify each market's state
     for i, market_contract in enumerate(created_market_contracts):
-        market_state = market_contract.get_dict(args=[])
+        market_state = market_contract.get_dict(args=[]).call()
         expected_data = markets_data[i]
 
         # Verify key market properties
@@ -171,10 +171,10 @@ def test_intelligent_oracle_factory_pattern(setup_validators):
     for i, market_contract in enumerate(created_market_contracts):
         resolve_result = market_contract.resolve(
             args=[markets_data[i]["evidence_urls"]],
-        )
+        ).transact()
         assert tx_execution_succeeded(resolve_result)
 
         # Verify market was resolved and has the correct outcome
-        market_state = market_contract.get_dict(args=[])
+        market_state = market_contract.get_dict(args=[]).call()
         assert market_state["status"] == "Resolved"
         assert market_state["outcome"] == markets_data[i]["outcome"]

tests/examples/tests/test_llm_erc20.py

@@ -34,17 +34,17 @@ def test_llm_erc20(setup_validators):
     contract = factory.deploy(args=[TOKEN_TOTAL_SUPPLY])
 
     # Get Initial State
-    contract_state_1 = contract.get_balances(args=[])
+    contract_state_1 = contract.get_balances(args=[]).call()
     assert contract_state_1[from_account_a.address] == TOKEN_TOTAL_SUPPLY
 
     # Transfer from User A to User B
     transaction_response_call_1 = contract.transfer(
         args=[TRANSFER_AMOUNT, from_account_b.address]
-    )
+    ).transact()
     assert tx_execution_succeeded(transaction_response_call_1)
 
     # Get Updated State
-    contract_state_2_1 = contract.get_balances(args=[])
+    contract_state_2_1 = contract.get_balances(args=[]).call()
     assert (
         contract_state_2_1[from_account_a.address]
         == TOKEN_TOTAL_SUPPLY - TRANSFER_AMOUNT
@@ -52,9 +52,9 @@ def test_llm_erc20(setup_validators):
     assert contract_state_2_1[from_account_b.address] == TRANSFER_AMOUNT
 
     # Get Updated State
-    contract_state_2_2 = contract.get_balance_of(args=[from_account_a.address])
+    contract_state_2_2 = contract.get_balance_of(args=[from_account_a.address]).call()
     assert contract_state_2_2 == TOKEN_TOTAL_SUPPLY - TRANSFER_AMOUNT
 
     # Get Updated State
-    contract_state_2_3 = contract.get_balance_of(args=[from_account_b.address])
+    contract_state_2_3 = contract.get_balance_of(args=[from_account_b.address]).call()
     assert contract_state_2_3 == TRANSFER_AMOUNT

tests/examples/tests/test_llm_erc20_analyze.py

@@ -0,0 +1,50 @@
+from gltest import get_contract_factory, get_default_account, create_account
+
+
+TOKEN_TOTAL_SUPPLY = 1000
+TRANSFER_AMOUNT = 100
+
+
+def test_llm_erc20_analyze(setup_validators):
+    setup_validators()
+    # Account Setup
+    from_account_a = get_default_account()
+    from_account_b = create_account()
+
+    # Deploy Contract
+    factory = get_contract_factory("LlmErc20")
+    contract = factory.deploy(args=[TOKEN_TOTAL_SUPPLY])
+
+    # Get Initial State
+    contract_state_1 = contract.get_balances(args=[]).call()
+    assert contract_state_1[from_account_a.address] == TOKEN_TOTAL_SUPPLY
+
+    # Transfer from User A to User B
+    stats = contract.transfer(args=[TRANSFER_AMOUNT, from_account_b.address]).analyze(
+        provider="openai", model="gpt-4o", runs=3
+    )
+
+    # Verify it's a MethodStatsSummary object
+    assert hasattr(stats, "method")
+    assert hasattr(stats, "args")
+    assert hasattr(stats, "total_runs")
+    assert hasattr(stats, "execution_time")
+    assert hasattr(stats, "provider")
+    assert hasattr(stats, "model")
+
+    # Check basic properties
+    assert stats.method == "transfer"
+    assert stats.args == [TRANSFER_AMOUNT, from_account_b.address]
+    assert stats.total_runs == 3
+    assert stats.provider == "openai"
+    assert stats.model == "gpt-4o"
+    assert isinstance(stats.execution_time, float)
+
+    # Check string representation
+    stats_str = str(stats)
+    assert "Method analysis summary" in stats_str
+    assert "Method: transfer" in stats_str
+    assert f"Args: [{TRANSFER_AMOUNT}, '{from_account_b.address}']" in stats_str
+    assert f"Total runs: {stats.total_runs}" in stats_str
+    assert f"Provider: {stats.provider}" in stats_str
+    assert f"Model: {stats.model}" in stats_str

tests/examples/tests/test_log_indexer.py

@@ -9,56 +9,68 @@ def test_log_indexer(setup_validators):
     contract = factory.deploy(args=[])
 
     # Get closest vector when empty
-    closest_vector_log_0 = contract.get_closest_vector(args=["I like mango"])
+    closest_vector_log_0 = contract.get_closest_vector(args=["I like mango"]).call()
     assert closest_vector_log_0 is None
 
     # Add log 0
-    transaction_response_add_log_0 = contract.add_log(args=["I like to eat mango", 0])
+    transaction_response_add_log_0 = contract.add_log(
+        args=["I like to eat mango", 0]
+    ).transact()
     assert tx_execution_succeeded(transaction_response_add_log_0)
 
     # Get closest vector to log 0
-    closest_vector_log_0 = contract.get_closest_vector(args=["I like mango"])
+    closest_vector_log_0 = contract.get_closest_vector(args=["I like mango"]).call()
     closest_vector_log_0 = closest_vector_log_0
     assert float(closest_vector_log_0["similarity"]) > 0.94
     assert float(closest_vector_log_0["similarity"]) < 0.95
 
     # Add log 1
-    transaction_response_add_log_1 = contract.add_log(args=["I like carrots", 1])
+    transaction_response_add_log_1 = contract.add_log(
+        args=["I like carrots", 1]
+    ).transact()
     assert tx_execution_succeeded(transaction_response_add_log_1)
 
     # Get closest vector to log 1
-    closest_vector_log_1 = contract.get_closest_vector(args=["I like carrots"])
+    closest_vector_log_1 = contract.get_closest_vector(args=["I like carrots"]).call()
     closest_vector_log_1 = closest_vector_log_1
     assert float(closest_vector_log_1["similarity"]) == 1
 
     # Update log 0
     transaction_response_update_log_0 = contract.update_log(
         args=[0, "I like to eat a lot of mangoes"]
-    )
+    ).transact()
     assert tx_execution_succeeded(transaction_response_update_log_0)
 
     # Get closest vector to log 0
-    closest_vector_log_0_2 = contract.get_closest_vector(args=["I like mango a lot"])
+    closest_vector_log_0_2 = contract.get_closest_vector(
+        args=["I like mango a lot"]
+    ).call()
     closest_vector_log_0_2 = closest_vector_log_0_2
     assert float(closest_vector_log_0_2["similarity"]) > 0.94
     assert float(closest_vector_log_0_2["similarity"]) < 0.95
 
     # Remove log 0
-    transaction_response_remove_log_0 = contract.remove_log(args=[0])
+    transaction_response_remove_log_0 = contract.remove_log(args=[0]).transact()
     assert tx_execution_succeeded(transaction_response_remove_log_0)
 
     # Get closest vector to log 0
-    closest_vector_log_0_3 = contract.get_closest_vector(args=["I like to eat mango"])
+    closest_vector_log_0_3 = contract.get_closest_vector(
+        args=["I like to eat mango"]
+    ).call()
     closest_vector_log_0_3 = closest_vector_log_0_3
     assert float(closest_vector_log_0_3["similarity"]) > 0.67
     assert float(closest_vector_log_0_3["similarity"]) < 0.68
 
     # Add third log
-    transaction_response_add_log_2 = contract.add_log(args=["This is the third log", 3])
+    transaction_response_add_log_2 = contract.add_log(
+        args=["This is the third log", 3]
+    ).transact()
     assert tx_execution_succeeded(transaction_response_add_log_2)
 
     # Check if new item got id 2
-    closest_vector_log_2 = contract.get_closest_vector(args=["This is the third log"])
+    closest_vector_log_2 = contract.get_closest_vector(
+        args=["This is the third log"]
+    ).call()
     assert float(closest_vector_log_2["similarity"]) > 0.99
     assert closest_vector_log_2["id"] == 3
     assert closest_vector_log_2["text"] == "This is the third log"

tests/examples/tests/test_multi_file_contract.py

@@ -9,8 +9,8 @@ def test_multi_file_contract(setup_validators):
     factory = get_contract_factory("MultiFileContract")
     contract = factory.deploy(args=[])
 
-    wait_response = contract.wait(args=[])
+    wait_response = contract.wait(args=[]).transact()
     assert tx_execution_succeeded(wait_response)
 
-    res = contract.test(args=[])
+    res = contract.test(args=[]).call()
     assert res == "123"

tests/examples/tests/test_multi_file_contract_legacy.py

@@ -9,8 +9,8 @@ def test_multi_file_contract_legacy(setup_validators):
     factory = get_contract_factory("MultiFileContractLegacy")
     contract = factory.deploy(args=[])
 
-    wait_response = contract.wait(args=[])
+    wait_response = contract.wait(args=[]).transact()
     assert tx_execution_succeeded(wait_response)
 
-    res = contract.test(args=[])
+    res = contract.test(args=[]).call()
     assert res == "123"

tests/examples/tests/test_multi_read_erc20.py

@@ -61,11 +61,11 @@ def test_multi_read_erc20(setup_validators):
             from_account_doge.address,
             [doge_contract.address, shiba_contract.address],
         ]
-    )
+    ).transact()
     assert tx_execution_succeeded(transaction_response_call)
 
     # check balances
-    call_method_response_get_balances = multi_read_contract.get_balances(args=[])
+    call_method_response_get_balances = multi_read_contract.get_balances(args=[]).call()
     assert call_method_response_get_balances == {
         from_account_doge.address: {
             doge_contract.address: TOKEN_TOTAL_SUPPLY,
@@ -74,20 +74,22 @@ def test_multi_read_erc20(setup_validators):
     }
 
     # update balances for shiba account
-    transaction_response_call = multi_read_contract.connect(
-        from_account_shiba
-    ).update_token_balances(
-        args=[
-            from_account_shiba.address,
-            [doge_contract.address, shiba_contract.address],
-        ]
+    transaction_response_call = (
+        multi_read_contract.connect(from_account_shiba)
+        .update_token_balances(
+            args=[
+                from_account_shiba.address,
+                [doge_contract.address, shiba_contract.address],
+            ]
+        )
+        .transact()
     )
     assert tx_execution_succeeded(transaction_response_call)
 
     # check balances
-    call_method_response_get_balances = multi_read_contract.connect(
-        from_account_shiba
-    ).get_balances(args=[])
+    call_method_response_get_balances = (
+        multi_read_contract.connect(from_account_shiba).get_balances(args=[]).call()
+    )
 
     assert call_method_response_get_balances == {
         from_account_doge.address: {

tests/examples/tests/test_multi_tenant_storage.py

@@ -48,19 +48,23 @@ def test_multi_tenant_storage(setup_validators):
         ]
     )
     # update storage for first contract
-    transaction_response_call = multi_tenant_storage_contract.connect(
-        account=user_account_a
-    ).update_storage(args=["user_a_storage"])
+    transaction_response_call = (
+        multi_tenant_storage_contract.connect(account=user_account_a)
+        .update_storage(args=["user_a_storage"])
+        .transact()
+    )
     assert tx_execution_succeeded(transaction_response_call)
 
     # update storage for second contract
-    transaction_response_call = multi_tenant_storage_contract.connect(
-        account=user_account_b
-    ).update_storage(args=["user_b_storage"])
+    transaction_response_call = (
+        multi_tenant_storage_contract.connect(account=user_account_b)
+        .update_storage(args=["user_b_storage"])
+        .transact()
+    )
     assert tx_execution_succeeded(transaction_response_call)
 
     # get all storages
-    storages = multi_tenant_storage_contract.get_all_storages(args=[])
+    storages = multi_tenant_storage_contract.get_all_storages(args=[]).call()
 
     assert storages == {
         second_storage_contract.address: "user_a_storage",

tests/examples/tests/test_read_erc20.py

@@ -34,5 +34,5 @@ def test_read_erc20(setup_validators):
         # check balance
         contract_state = read_erc20_contract.get_balance_of(
             args=[get_default_account().address]
-        )
+        ).call()
         assert contract_state == TOKEN_TOTAL_SUPPLY

tests/examples/tests/test_storage.py

@@ -12,15 +12,15 @@ def test_storage(setup_validators):
     contract = factory.deploy(args=[INITIAL_STATE], wait_retries=40)
 
     # Get initial state
-    contract_state_1 = contract.get_storage(args=[])
+    contract_state_1 = contract.get_storage(args=[]).call()
     assert contract_state_1 == INITIAL_STATE
 
     # Update State
     transaction_response_call_1 = contract.update_storage(
-        args=[UPDATED_STATE], wait_retries=40
-    )
+        args=[UPDATED_STATE]
+    ).transact(wait_retries=40)
     assert tx_execution_succeeded(transaction_response_call_1)
 
     # Get Updated State
-    contract_state_2 = contract.get_storage(args=[])
+    contract_state_2 = contract.get_storage(args=[]).call()
     assert contract_state_2 == UPDATED_STATE

tests/examples/tests/test_storage_legacy.py

@@ -12,13 +12,15 @@ def test_storage_legacy(setup_validators):
     contract = factory.deploy(args=[INITIAL_STATE])
 
     # Get initial state
-    contract_state_1 = contract.get_storage(args=[])
+    contract_state_1 = contract.get_storage(args=[]).call()
     assert contract_state_1 == INITIAL_STATE
 
     # Update State
-    transaction_response_call_1 = contract.update_storage(args=[UPDATED_STATE])
+    transaction_response_call_1 = contract.update_storage(
+        args=[UPDATED_STATE]
+    ).transact()
     assert tx_execution_succeeded(transaction_response_call_1)
 
     # Get Updated State
-    contract_state_2 = contract.get_storage(args=[])
+    contract_state_2 = contract.get_storage(args=[]).call()
     assert contract_state_2 == UPDATED_STATE

tests/examples/tests/test_user_storage.py

@@ -37,41 +37,51 @@ def test_user_storage(setup_validators):
     contract = factory.deploy()
 
     # GET Initial State
-    contract_state_1 = contract.get_complete_storage(args=[])
+    contract_state_1 = contract.get_complete_storage(args=[]).call()
     assert contract_state_1 == {}
 
     # ADD User A State
-    transaction_response_call_1 = contract.update_storage(args=[INITIAL_STATE_USER_A])
+    transaction_response_call_1 = contract.update_storage(
+        args=[INITIAL_STATE_USER_A]
+    ).transact()
     assert tx_execution_succeeded(transaction_response_call_1)
 
     # Get Updated State
-    contract_state_2_1 = contract.get_complete_storage(args=[])
+    contract_state_2_1 = contract.get_complete_storage(args=[]).call()
     assert contract_state_2_1[from_account_a.address] == INITIAL_STATE_USER_A
 
     # Get Updated State
-    contract_state_2_2 = contract.get_account_storage(args=[from_account_a.address])
+    contract_state_2_2 = contract.get_account_storage(
+        args=[from_account_a.address]
+    ).call()
     assert contract_state_2_2 == INITIAL_STATE_USER_A
 
     # ADD User B State
-    transaction_response_call_2 = contract.connect(from_account_b).update_storage(
-        args=[INITIAL_STATE_USER_B]
+    transaction_response_call_2 = (
+        contract.connect(from_account_b)
+        .update_storage(args=[INITIAL_STATE_USER_B])
+        .transact()
     )
     assert tx_execution_succeeded(transaction_response_call_2)
 
     # Get Updated State
-    contract_state_3 = contract.get_complete_storage(args=[])
+    contract_state_3 = contract.get_complete_storage(args=[]).call()
     assert contract_state_3[from_account_a.address] == INITIAL_STATE_USER_A
     assert contract_state_3[from_account_b.address] == INITIAL_STATE_USER_B
 
     # UPDATE User A State
-    transaction_response_call_3 = contract.update_storage(args=[UPDATED_STATE_USER_A])
+    transaction_response_call_3 = contract.update_storage(
+        args=[UPDATED_STATE_USER_A]
+    ).transact()
     assert tx_execution_succeeded(transaction_response_call_3)
 
     # Get Updated State
-    contract_state_4_1 = contract.get_complete_storage(args=[])
+    contract_state_4_1 = contract.get_complete_storage(args=[]).call()
     assert contract_state_4_1[from_account_a.address] == UPDATED_STATE_USER_A
     assert contract_state_4_1[from_account_b.address] == INITIAL_STATE_USER_B
 
     # Get Updated State
-    contract_state_4_2 = contract.get_account_storage(args=[from_account_b.address])
+    contract_state_4_2 = contract.get_account_storage(
+        args=[from_account_b.address]
+    ).call()
     assert contract_state_4_2 == INITIAL_STATE_USER_B

tests/examples/tests/test_wizard_of_coin.py

@@ -23,5 +23,5 @@ def test_wizard_of_coin(setup_validators):
 
     transaction_response_call_1 = contract.ask_for_coin(
         args=["Can you please give me my coin?"]
-    )
+    ).transact()
     assert tx_execution_succeeded(transaction_response_call_1)

tests/gltest_cli/config/test_general_config.py

@@ -0,0 +1,149 @@
+import pytest
+from pathlib import Path
+from gltest_cli.config.types import (
+    GeneralConfig,
+    UserConfig,
+    PluginConfig,
+    PathConfig,
+    NetworkConfigData,
+)
+from gltest_cli.config.constants import DEFAULT_ARTIFACTS_DIR, DEFAULT_CONTRACTS_DIR
+
+
+def test_general_config_artifacts_methods():
+    """Test GeneralConfig artifacts directory methods."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData()},
+        paths=PathConfig(contracts=Path("contracts"), artifacts=Path("user_artifacts")),
+    )
+
+    plugin_config = PluginConfig()
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Test get_artifacts_dir returns user config value when plugin config is not set
+    assert general_config.get_artifacts_dir() == Path("user_artifacts")
+
+    # Test set_artifacts_dir updates plugin config
+    general_config.set_artifacts_dir(Path("plugin_artifacts"))
+    assert general_config.get_artifacts_dir() == Path("plugin_artifacts")
+
+    # Plugin config should take precedence
+    assert general_config.plugin_config.artifacts_dir == Path("plugin_artifacts")
+
+
+def test_general_config_artifacts_default():
+    """Test GeneralConfig artifacts directory with default values."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData()},
+        paths=PathConfig(artifacts=DEFAULT_ARTIFACTS_DIR),
+    )
+
+    plugin_config = PluginConfig()
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Should return default artifacts directory
+    assert general_config.get_artifacts_dir() == DEFAULT_ARTIFACTS_DIR
+
+
+def test_general_config_artifacts_plugin_precedence():
+    """Test that plugin config takes precedence over user config for artifacts."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData()},
+        paths=PathConfig(artifacts=Path("user_artifacts")),
+    )
+
+    plugin_config = PluginConfig(artifacts_dir=Path("plugin_artifacts"))
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Plugin config should take precedence
+    assert general_config.get_artifacts_dir() == Path("plugin_artifacts")
+
+
+def test_general_config_artifacts_none_values():
+    """Test GeneralConfig behavior when artifacts paths are None."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData()}, paths=PathConfig(artifacts=None)
+    )
+
+    plugin_config = PluginConfig(artifacts_dir=None)
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Should return None when both are None
+    assert general_config.get_artifacts_dir() is None
+
+
+def test_general_config_both_contracts_and_artifacts():
+    """Test that both contracts and artifacts directories work together."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData()},
+        paths=PathConfig(
+            contracts=Path("src/contracts"), artifacts=Path("build/artifacts")
+        ),
+    )
+
+    plugin_config = PluginConfig(
+        contracts_dir=Path("custom/contracts"), artifacts_dir=Path("custom/artifacts")
+    )
+
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Both should return plugin values (precedence)
+    assert general_config.get_contracts_dir() == Path("custom/contracts")
+    assert general_config.get_artifacts_dir() == Path("custom/artifacts")
+
+
+def test_general_config_mixed_precedence():
+    """Test mixed precedence where only one path is overridden in plugin."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData()},
+        paths=PathConfig(
+            contracts=Path("user/contracts"), artifacts=Path("user/artifacts")
+        ),
+    )
+
+    # Only override artifacts in plugin config
+    plugin_config = PluginConfig(artifacts_dir=Path("plugin/artifacts"))
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Contracts should come from user config, artifacts from plugin config
+    assert general_config.get_contracts_dir() == Path("user/contracts")
+    assert general_config.get_artifacts_dir() == Path("plugin/artifacts")
+
+
+def test_path_config_validation():
+    """Test PathConfig validation for artifacts."""
+    # Valid path configurations
+    valid_config = PathConfig(contracts=Path("contracts"), artifacts=Path("artifacts"))
+    assert valid_config.contracts == Path("contracts")
+    assert valid_config.artifacts == Path("artifacts")
+
+    # Test with string paths
+    string_config = PathConfig(contracts="contracts", artifacts="artifacts")
+    # PathConfig should handle string conversion in __post_init__
+    assert string_config.contracts == "contracts"
+    assert string_config.artifacts == "artifacts"
+
+
+def test_path_config_invalid_types():
+    """Test PathConfig validation with invalid types."""
+    # Test invalid artifacts type
+    with pytest.raises(ValueError, match="artifacts must be a string or Path"):
+        PathConfig(artifacts=123)
+
+    # Test invalid contracts type (existing validation)
+    with pytest.raises(ValueError, match="contracts must be a string or Path"):
+        PathConfig(contracts=123)
+
+
+def test_general_config_contracts_default():
+    """Test GeneralConfig contracts directory with default values."""
+    user_config = UserConfig(
+        networks={"localnet": NetworkConfigData()},
+        paths=PathConfig(contracts=DEFAULT_CONTRACTS_DIR),
+    )
+
+    plugin_config = PluginConfig()
+    general_config = GeneralConfig(user_config=user_config, plugin_config=plugin_config)
+
+    # Should return default contracts directory
+    assert general_config.get_contracts_dir() == DEFAULT_CONTRACTS_DIR