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

gltest_cli/config/types.py

@@ -2,24 +2,22 @@ from enum import Enum
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Dict, List, Optional
-from genlayer_py.chains import localnet, testnet_asimov
+from genlayer_py.chains import localnet, studionet, testnet_asimov
 from genlayer_py.types import GenLayerChain
 from urllib.parse import urlparse
-
-
-class NetworkConfig(str, Enum):
-    LOCALNET = "localnet"
-    TESTNET_ASIMOV = "testnet_asimov"
+from gltest_cli.config.constants import PRECONFIGURED_NETWORKS
 
 
 @dataclass
 class PluginConfig:
     contracts_dir: Optional[Path] = None
+    artifacts_dir: Optional[Path] = None
     rpc_url: Optional[str] = None
     default_wait_interval: Optional[int] = None
     default_wait_retries: Optional[int] = None
     network_name: Optional[str] = None
     test_with_mocks: bool = False
+    leader_only: bool = False
 
 
 @dataclass
@@ -28,6 +26,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):
@@ -46,10 +45,13 @@ class NetworkConfigData:
 @dataclass
 class PathConfig:
     contracts: Optional[Path] = None
+    artifacts: Optional[Path] = None
 
     def __post_init__(self):
         if self.contracts is not None and not isinstance(self.contracts, (str, Path)):
             raise ValueError("contracts must be a string or Path")
+        if self.artifacts is not None and not isinstance(self.artifacts, (str, Path)):
+            raise ValueError("artifacts must be a string or Path")
 
 
 @dataclass
@@ -93,10 +95,29 @@ class GeneralConfig:
     def set_contracts_dir(self, contracts_dir: Path):
         self.plugin_config.contracts_dir = contracts_dir
 
+    def get_artifacts_dir(self) -> Path:
+        if self.plugin_config.artifacts_dir is not None:
+            return self.plugin_config.artifacts_dir
+        return self.user_config.paths.artifacts
+
+    def set_artifacts_dir(self, artifacts_dir: Path):
+        self.plugin_config.artifacts_dir = artifacts_dir
+
+    def get_analysis_dir(self) -> Path:
+        artifacts_dir = self.get_artifacts_dir()
+        return artifacts_dir / "analysis"
+
+    def get_networks_keys(self) -> List[str]:
+        return list(self.user_config.networks.keys())
+
     def get_rpc_url(self) -> str:
         if self.plugin_config.rpc_url is not None:
             return self.plugin_config.rpc_url
         network_name = self.get_network_name()
+        if network_name not in self.user_config.networks:
+            raise ValueError(
+                f"Unknown network: {network_name}, possible values: {self.get_networks_keys()}"
+            )
         return self.user_config.networks[network_name].url
 
     def get_default_account_key(self, network_name: Optional[str] = None) -> str:
@@ -110,16 +131,37 @@ class GeneralConfig:
         return self.user_config.networks[self.user_config.default_network].accounts
 
     def get_chain(self) -> GenLayerChain:
+        network_name = self.get_network_name()
+        if network_name not in self.user_config.networks:
+            raise ValueError(
+                f"Unknown network: {network_name}, possible values: {self.get_networks_keys()}"
+            )
+
+        # Reserved network names
+        chain_map_by_name = {
+            "localnet": localnet,
+            "studionet": studionet,
+            "testnet_asimov": testnet_asimov,
+        }
+
+        if network_name in chain_map_by_name:
+            return chain_map_by_name[network_name]
+
+        if network_name in PRECONFIGURED_NETWORKS:
+            raise ValueError(
+                f"Network {network_name} should be handled by reserved mapping"
+            )
+
+        # Custom networks
         chain_map_by_id = {
             61999: localnet,
             4221: testnet_asimov,
         }
-        network_name = self.get_network_name()
         network_id = self.user_config.networks[network_name].id
         if network_id not in chain_map_by_id:
             known = ", ".join(map(str, chain_map_by_id.keys()))
             raise ValueError(
-                f"Unknown network: {network_name}, possible values: {known}"
+                f"Unknown network id: {network_id}, possible values: {known}"
             )
         return chain_map_by_id[network_id]
 
@@ -141,8 +183,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

@@ -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_NETWORK_ID,
+    DEFAULT_ARTIFACTS_DIR,
+    PRECONFIGURED_NETWORKS,
 )
+from genlayer_py.chains import localnet, studionet, testnet_asimov
 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_NETWORK_KEYS = ["id", "url", "accounts", "from", "leader_only"]
+VALID_PATHS_KEYS = ["contracts", "artifacts"]
 
 
 @lru_cache(maxsize=1)
@@ -25,16 +26,35 @@ def get_default_user_config() -> UserConfig:
     accounts = create_accounts(n_accounts=10)
     accounts_private_keys = [account.key.hex() for account in accounts]
 
+    networks = {
+        "localnet": NetworkConfigData(
+            id=localnet.id,
+            url=localnet.rpc_urls["default"]["http"][0],
+            accounts=accounts_private_keys,
+            from_account=accounts_private_keys[0],
+            leader_only=False,
+        ),
+        "studionet": NetworkConfigData(
+            id=studionet.id,
+            url=studionet.rpc_urls["default"]["http"][0],
+            accounts=accounts_private_keys,
+            from_account=accounts_private_keys[0],
+            leader_only=False,
+        ),
+        "testnet_asimov": NetworkConfigData(
+            id=testnet_asimov.id,
+            url=testnet_asimov.rpc_urls["default"]["http"][0],
+            accounts=None,
+            from_account=None,
+            leader_only=False,
+        ),
+    }
+
     return UserConfig(
-        networks={
-            DEFAULT_NETWORK: NetworkConfigData(
-                id=DEFAULT_NETWORK_ID,
-                url=DEFAULT_RPC_URL,
-                accounts=accounts_private_keys,
-                from_account=accounts_private_keys[0],
-            ),
-        },
-        paths=PathConfig(contracts=DEFAULT_CONTRACTS_DIR),
+        networks=networks,
+        paths=PathConfig(
+            contracts=DEFAULT_CONTRACTS_DIR, artifacts=DEFAULT_ARTIFACTS_DIR
+        ),
         environment=DEFAULT_ENVIRONMENT,
         default_network=DEFAULT_NETWORK,
     )
@@ -42,11 +62,26 @@ def get_default_user_config() -> UserConfig:
 
 def resolve_env_vars(obj):
     if isinstance(obj, str):
-        return re.sub(
-            r"\${(\w+)}",
-            lambda m: os.getenv(m.group(1), f"<UNSET:{m.group(1)}>"),
-            obj,
-        )
+
+        def replace_env_var(m):
+            try:
+                var_name = m.group(1)
+                if var_name is None:
+                    raise ValueError(
+                        f"Invalid environment variable pattern: {m.group(0)}"
+                    )
+                var_value = os.getenv(var_name)
+                if var_value is None:
+                    raise ValueError(
+                        f"Environment variable {var_name} is not set, please check your environment file"
+                    )
+                return var_value
+            except IndexError as e:
+                raise ValueError(
+                    f"Invalid environment variable pattern: {m.group(0)}"
+                ) from e
+
+        return re.sub(r"\${(\w+)}", replace_env_var, obj)
     elif isinstance(obj, dict):
         return {k: resolve_env_vars(v) for k, v in obj.items()}
     elif isinstance(obj, list):
@@ -81,9 +116,13 @@ 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:
+    # For non-preconfigured networks, url and accounts are required
+    if network_name not in PRECONFIGURED_NETWORKS:
         if "id" not in network_config:
             raise ValueError(f"network {network_name} must have an id")
         if "url" not in network_config:
@@ -131,7 +170,6 @@ def validate_raw_user_config(config: dict):
 def load_user_config(path: str) -> UserConfig:
     with open(path, "r") as f:
         raw_config = yaml.safe_load(f) or {}
-
     validate_raw_user_config(raw_config)
     load_dotenv(
         dotenv_path=raw_config.get("environment", DEFAULT_ENVIRONMENT), override=True
@@ -168,8 +206,8 @@ def _get_overridden_networks(raw_config: dict) -> tuple[dict, str]:
 
     networks_config = {}
     for network_name, network_config in networks.items():
-        if network_name == DEFAULT_NETWORK:
-            networks_config[network_name] = default_config.networks[DEFAULT_NETWORK]
+        if network_name in PRECONFIGURED_NETWORKS:
+            networks_config[network_name] = default_config.networks[network_name]
             if network_config is None:
                 continue
 
@@ -182,18 +220,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
 
@@ -208,10 +251,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,14 +30,15 @@ class ColoredFormatter(logging.Formatter):
 
 
 def setup_logger():
-    logger = logging.getLogger("gltest")
-    logger.setLevel(logging.DEBUG)
+    logger = logging.getLogger("gltest_cli")
+    log_level = logging.INFO
+    logger.setLevel(log_level)
 
     if logger.handlers:
         return logger
 
     console_handler = logging.StreamHandler()
-    console_handler.setLevel(logging.DEBUG)
+    console_handler.setLevel(log_level)
 
     formatter = ColoredFormatter("%(levelname)s: %(message)s")
     console_handler.setFormatter(formatter)

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/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

@@ -1,24 +1,10 @@
-import time
 import json
+from gltest.types import TransactionStatus
 
 from gltest import get_contract_factory
 from gltest.assertions import tx_execution_succeeded
 
 
-def wait_for_contract_deployment(intelligent_oracle_contract, max_retries=10, delay=5):
-    """
-    Wait for intelligent oracle contract to be fully deployed by attempting to call a method.
-    This is used to check if the triggered deployment did deploy the contract.
-    """
-    for _ in range(max_retries):
-        try:
-            intelligent_oracle_contract.get_dict(args=[])
-            return True  # If successful, contract is deployed
-        except Exception:
-            time.sleep(delay)
-    return False
-
-
 def create_mock_response(markets_data):
     reasoning_single_source_marathon = "The HTML content contains the results of the Madrid Marathon 2024, which occurred on April 28, 2024. Mitku Tafa won and matches the name 'Tafa Mitku' in the list of potential outcomes."
     reasoning_all_sources_marathon = "The URL indicates that the Madrid Marathon 2024 has occurred on April 28, 2024, and Mitku Tafa was the winner. The name matches one of the potential outcomes. There are no conflicting sources."
@@ -124,28 +110,26 @@ def test_intelligent_oracle_factory_pattern(setup_validators):
                 market_data["resolution_urls"],
                 market_data["earliest_resolution_date"],
             ],
+        ).transact(
+            wait_triggered_transactions=True,
+            wait_triggered_transactions_status=TransactionStatus.ACCEPTED,
         )
         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
         market_contract = intelligent_oracle_factory.build_contract(new_market_address)
         created_market_contracts.append(market_contract)
 
-        # Wait for the new market contract to be deployed
-        assert wait_for_contract_deployment(
-            market_contract
-        ), f"Market contract deployment timeout for {market_data['prediction_market_id']}"
-
     # Verify all markets were registered
     assert len(registered_addresses) == len(markets_data)
 
     # 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 +155,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"