genlayer-test 0.4.1__py3-none-any.whl → 0.5.1__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_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

@@ -31,13 +31,14 @@ class ColoredFormatter(logging.Formatter):
 
 def setup_logger():
     logger = logging.getLogger("gltest_cli")
-    logger.setLevel(logging.DEBUG)
+    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/contracts/intelligent_oracle_factory.py

@@ -38,6 +38,7 @@ class Registry(gl.Contract):
                 earliest_resolution_date,
             ],
             salt_nonce=registered_contracts + 1,
+            on="accepted",
         )
         print("contract_address", contract_address)
         print("contract_address type", type(contract_address))

tests/examples/contracts/multi_file_contract/__init__.py

@@ -12,6 +12,7 @@ class MultiFileContract(gl.Contract):
             args=["123"],
             salt_nonce=u256(1),
             value=u256(0),
+            on="accepted",
         )
 
     @gl.public.write

tests/examples/contracts/multi_tenant_storage.py

@@ -46,4 +46,6 @@ class MultiTentantStorage(gl.Contract):
             self.available_storage_contracts.pop()
 
         contract_to_use = self.mappings[gl.message.sender_address]
-        gl.get_contract_at(contract_to_use).emit().update_storage(new_storage)
+        gl.get_contract_at(contract_to_use).emit(on="accepted").update_storage(
+            new_storage
+        )

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,9 @@
-import time
 import json
 
 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 +109,25 @@ def test_intelligent_oracle_factory_pattern(setup_validators):
                 market_data["resolution_urls"],
                 market_data["earliest_resolution_date"],
             ],
+        ).transact(
+            wait_triggered_transactions=True,
         )
         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 +153,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

@@ -1,5 +1,4 @@
 from gltest import get_contract_factory
-from gltest.assertions import tx_execution_succeeded
 
 
 def test_multi_file_contract(setup_validators):
@@ -7,10 +6,10 @@ def test_multi_file_contract(setup_validators):
     # Deploy Contract, it will deploy other.py as well
     setup_validators()
     factory = get_contract_factory("MultiFileContract")
-    contract = factory.deploy(args=[])
+    contract = factory.deploy(
+        args=[],
+        wait_triggered_transactions=True,
+    )
 
-    wait_response = contract.wait(args=[])
-    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,27 @@ 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(
+            wait_triggered_transactions=True,
+        )
+    )
     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(
+            wait_triggered_transactions=True,
+        )
+    )
     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