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

gltest/contracts/utils.py

@@ -0,0 +1,12 @@
+def safe_filename(filename: str) -> str:
+    """
+    Replace problematic characters in filename.
+    """
+    return (
+        filename.replace("/", "_")
+        .replace("\\", "_")
+        .replace(":", "_")
+        .replace("-", "_")
+        .replace(" ", "_")
+        .replace(".py", "")
+    )

gltest/fixtures.py

@@ -4,12 +4,8 @@ These fixtures can be imported and used in test files.
 """
 
 import pytest
-from gltest.glchain import (
-    get_gl_client,
-    get_accounts,
-    get_default_account,
-    get_gl_provider,
-)
+from gltest.clients import get_gl_client, get_gl_provider
+from gltest.accounts import get_accounts, get_default_account
 from gltest_cli.config.general import get_general_config
 
 

gltest/helpers/take_snapshot.py

@@ -1,4 +1,4 @@
-from gltest.glchain import get_gl_provider
+from gltest.clients import get_gl_provider
 from dataclasses import dataclass
 from typing import Callable
 from gltest.exceptions import HelperError, InvalidSnapshotError

gltest_cli/config/constants.py

@@ -7,4 +7,5 @@ DEFAULT_NETWORK = "localnet"
 DEFAULT_RPC_URL = SIMULATOR_JSON_RPC_URL
 DEFAULT_ENVIRONMENT = ".env"
 DEFAULT_CONTRACTS_DIR = Path("contracts")
+DEFAULT_ARTIFACTS_DIR = Path("artifacts")
 DEFAULT_NETWORK_ID = 61999

gltest_cli/config/plugin.py

@@ -1,4 +1,5 @@
 from pathlib import Path
+import shutil
 from gltest_cli.logging import logger
 from gltest_cli.config.user import (
     user_config_exists,
@@ -9,6 +10,7 @@ from gltest_cli.config.general import (
     get_general_config,
 )
 from gltest_cli.config.types import PluginConfig
+from gltest_cli.config.pytest_context import _pytest_context
 
 
 def pytest_addoption(parser):
@@ -20,6 +22,13 @@ def pytest_addoption(parser):
         help="Path to directory containing contract files",
     )
 
+    group.addoption(
+        "--artifacts-dir",
+        action="store",
+        default=None,
+        help="Path to directory for storing contract artifacts",
+    )
+
     group.addoption(
         "--default-wait-interval",
         action="store",
@@ -55,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()
@@ -76,27 +92,45 @@ def pytest_configure(config):
 
     # Handle plugin config from command line
     contracts_dir = config.getoption("--contracts-dir")
+    artifacts_dir = config.getoption("--artifacts-dir")
     default_wait_interval = config.getoption("--default-wait-interval")
     default_wait_retries = config.getoption("--default-wait-retries")
     rpc_url = config.getoption("--rpc-url")
     network = config.getoption("--network")
     test_with_mocks = config.getoption("--test-with-mocks")
+    leader_only = config.getoption("--leader-only")
 
     plugin_config = PluginConfig()
     plugin_config.contracts_dir = (
         Path(contracts_dir) if contracts_dir is not None else None
     )
+    plugin_config.artifacts_dir = (
+        Path(artifacts_dir) if artifacts_dir is not None else None
+    )
     plugin_config.default_wait_interval = int(default_wait_interval)
     plugin_config.default_wait_retries = int(default_wait_retries)
     plugin_config.rpc_url = rpc_url
     plugin_config.network_name = network
     plugin_config.test_with_mocks = test_with_mocks
+    plugin_config.leader_only = leader_only
 
     general_config.plugin_config = plugin_config
 
 
 def pytest_sessionstart(session):
     general_config = get_general_config()
+
+    artifacts_dir = general_config.get_artifacts_dir()
+    if artifacts_dir and artifacts_dir.exists():
+        logger.info(f"Clearing artifacts directory: {artifacts_dir}")
+        try:
+            shutil.rmtree(artifacts_dir)
+            artifacts_dir.mkdir(parents=True, exist_ok=True)
+        except Exception as e:
+            logger.warning(f"Failed to clear artifacts directory: {e}")
+    elif artifacts_dir:
+        artifacts_dir.mkdir(parents=True, exist_ok=True)
+
     logger.info("Using the following configuration:")
     logger.info(f"  RPC URL: {general_config.get_rpc_url()}")
     logger.info(f"  Selected Network: {general_config.get_network_name()}")
@@ -104,6 +138,7 @@ def pytest_sessionstart(session):
         f"  Available networks: {list(general_config.user_config.networks.keys())}"
     )
     logger.info(f"  Contracts directory: {general_config.get_contracts_dir()}")
+    logger.info(f"  Artifacts directory: {general_config.get_artifacts_dir()}")
     logger.info(f"  Environment: {general_config.user_config.environment}")
     logger.info(
         f"  Default wait interval: {general_config.get_default_wait_interval()} ms"
@@ -111,5 +146,23 @@ 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
+
+
+def pytest_runtest_teardown(item):
+    try:
+        del _pytest_context.current_item
+    except AttributeError:
+        pass
+
 
 pytest_plugins = ["gltest.fixtures"]

gltest_cli/config/pytest_context.py

@@ -0,0 +1,9 @@
+from typing import Optional
+import threading
+
+_pytest_context = threading.local()
+
+
+def get_current_test_nodeid() -> Optional[str]:
+    item = getattr(_pytest_context, "current_item", None)
+    return item.nodeid if item is not None else None

gltest_cli/config/types.py

@@ -15,11 +15,13 @@ class NetworkConfig(str, Enum):
 @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 +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):
@@ -46,10 +49,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,6 +99,18 @@ 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_rpc_url(self) -> str:
         if self.plugin_config.rpc_url is not None:
             return self.plugin_config.rpc_url
@@ -141,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

@@ -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_NETWORK_KEYS = ["id", "url", "accounts", "from", "leader_only"]
+VALID_PATHS_KEYS = ["contracts", "artifacts"]
 
 
 @lru_cache(maxsize=1)
@@ -32,9 +33,12 @@ 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(contracts=DEFAULT_CONTRACTS_DIR),
+        paths=PathConfig(
+            contracts=DEFAULT_CONTRACTS_DIR, artifacts=DEFAULT_ARTIFACTS_DIR
+        ),
         environment=DEFAULT_ENVIRONMENT,
         default_network=DEFAULT_NETWORK,
     )
@@ -81,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:
@@ -182,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
 
@@ -208,10 +221,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
 

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

@@ -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: {