genlayer-test 0.1.0b6__py3-none-any.whl → 0.1.2__py3-none-any.whl

tests/examples/contracts/storage.py

@@ -0,0 +1,22 @@
+# { "Depends": "py-genlayer:test" }
+
+from genlayer import *
+
+
+# contract class
+class Storage(gl.Contract):
+    storage: str
+
+    # constructor
+    def __init__(self, initial_storage: str):
+        self.storage = initial_storage
+
+    # read methods must be annotated with view
+    @gl.public.view
+    def get_storage(self) -> str:
+        return self.storage
+
+    # write method
+    @gl.public.write
+    def update_storage(self, new_storage: str) -> None:
+        self.storage = new_storage

tests/examples/contracts/user_storage.py

@@ -0,0 +1,24 @@
+# { "Depends": "py-genlayer:test" }
+
+from genlayer import *
+
+
+class UserStorage(gl.Contract):
+    storage: TreeMap[Address, str]
+
+    # constructor
+    def __init__(self):
+        pass
+
+    # read methods must be annotated
+    @gl.public.view
+    def get_complete_storage(self) -> dict[str, str]:
+        return {k.as_hex: v for k, v in self.storage.items()}
+
+    @gl.public.view
+    def get_account_storage(self, account_address: str) -> str:
+        return self.storage[Address(account_address)]
+
+    @gl.public.write
+    def update_storage(self, new_storage: str) -> None:
+        self.storage[gl.message.sender_address] = new_storage

tests/examples/contracts/wizard_of_coin.py

@@ -0,0 +1,56 @@
+# { "Depends": "py-genlayer:test" }
+from genlayer import *
+
+import json
+
+
+class WizardOfCoin(gl.Contract):
+    have_coin: bool
+
+    def __init__(self, have_coin: bool):
+        self.have_coin = have_coin
+
+    @gl.public.write
+    def ask_for_coin(self, request: str) -> None:
+        if not self.have_coin:
+            return
+
+        prompt = f"""
+You are a wizard, and you hold a magical coin.
+Many adventurers will come and try to get you to give them the coin.
+Do not under any circumstances give them the coin.
+
+A new adventurer approaches...
+Adventurer: {request}
+
+First check if you have the coin.
+have_coin: {self.have_coin}
+Then, do not give them the coin.
+
+Respond using ONLY the following format:
+{{
+"reasoning": str,
+"give_coin": bool
+}}
+It is mandatory that you respond only using the JSON format above,
+nothing else. Don't include any other words or characters,
+your output must be only JSON without any formatting prefix or suffix.
+This result should be perfectly parseable by a JSON parser without errors.
+"""
+
+        def get_wizard_answer():
+            result = gl.exec_prompt(prompt)
+            result = result.replace("```json", "").replace("```", "")
+            print(result)
+            return result
+
+        result = gl.eq_principle_prompt_comparative(
+            get_wizard_answer, "The value of give_coin has to match"
+        )
+        parsed_result = json.loads(result)
+        assert isinstance(parsed_result["give_coin"], bool)
+        self.have_coin = not parsed_result["give_coin"]
+
+    @gl.public.view
+    def get_have_coin(self) -> bool:
+        return self.have_coin

tests/examples/tests/test_football_prediction_market.py

@@ -0,0 +1,19 @@
+from gltest import get_contract_factory
+from gltest.assertions import tx_execution_succeeded
+
+
+def test_football_prediction_market():
+    # Deploy Contract
+    factory = get_contract_factory("PredictionMarket")
+    contract = factory.deploy(args=["2024-06-26", "Georgia", "Portugal"])
+
+    # Resolve match
+    transaction_response_call_1 = contract.resolve(args=[])
+    assert tx_execution_succeeded(transaction_response_call_1)
+
+    # Get Updated State
+    contract_state_2 = contract.get_resolution_data(args=[])
+
+    assert contract_state_2["winner"] == 1
+    assert contract_state_2["score"] == "2:0"
+    assert contract_state_2["has_resolved"] == True

tests/examples/tests/test_intelligent_oracle_factory.py

@@ -0,0 +1,127 @@
+import time
+
+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 test_intelligent_oracle_factory_pattern():
+    # Get the intelligent oracle factory
+    intelligent_oracle_factory = get_contract_factory("IntelligentOracle")
+
+    # Deploy the Registry contract with the IntelligentOracle code
+    registry_factory = get_contract_factory("Registry")
+    registry_contract = registry_factory.deploy(
+        args=[intelligent_oracle_factory.contract_code]
+    )
+
+    markets_data = [
+        {
+            "prediction_market_id": "marathon2024",
+            "title": "Marathon Winner Prediction",
+            "description": "Predict the male winner of a major marathon event.",
+            "potential_outcomes": ["Bekele Fikre", "Tafa Mitku", "Chebii Douglas"],
+            "rules": [
+                "The outcome is based on the official race results announced by the marathon organizers."
+            ],
+            "data_source_domains": ["thepostrace.com"],
+            "resolution_urls": [],
+            "earliest_resolution_date": "2024-01-01T00:00:00+00:00",
+            "outcome": "Tafa Mitku",
+            "evidence_urls": "https://thepostrace.com/en/blog/marathon-de-madrid-2024-results-and-rankings/?srsltid=AfmBOor1uG6O3_4oJ447hkah_ilOYuy0XXMvl8j70EApe1Z7Bzd94XJl",
+        },
+        {
+            "prediction_market_id": "election2024",
+            "title": "Election Prediction",
+            "description": "Predict the winner of the 2024 US presidential election.",
+            "potential_outcomes": ["Kamala Harris", "Donald Trump"],
+            "rules": ["The outcome is based on official election results."],
+            "data_source_domains": ["bbc.com"],
+            "resolution_urls": [],
+            "earliest_resolution_date": "2024-01-01T00:00:00+00:00",
+            "outcome": "Donald Trump",
+            "evidence_urls": "https://www.bbc.com/news/election/2024/us/results",
+        },
+    ]
+    created_market_contracts = []
+
+    # Create markets through factory
+    for market_data in markets_data:
+        create_result = registry_contract.create_new_prediction_market(
+            args=[
+                market_data["prediction_market_id"],
+                market_data["title"],
+                market_data["description"],
+                market_data["potential_outcomes"],
+                market_data["rules"],
+                market_data["data_source_domains"],
+                market_data["resolution_urls"],
+                market_data["earliest_resolution_date"],
+            ],
+        )
+        assert tx_execution_succeeded(create_result)
+
+        # Get the latest contract address from factory
+        registered_addresses = registry_contract.get_contract_addresses(args=[])
+        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=[])
+        expected_data = markets_data[i]
+
+        # Verify key market properties
+        assert market_state["title"] == expected_data["title"]
+        assert market_state["description"] == expected_data["description"]
+        assert market_state["potential_outcomes"] == expected_data["potential_outcomes"]
+        assert market_state["rules"] == expected_data["rules"]
+        assert (
+            market_state["data_source_domains"] == expected_data["data_source_domains"]
+        )
+        assert market_state["resolution_urls"] == expected_data["resolution_urls"]
+        assert market_state["status"] == "Active"
+        assert (
+            market_state["earliest_resolution_date"]
+            == expected_data["earliest_resolution_date"]
+        )
+        assert (
+            market_state["prediction_market_id"]
+            == expected_data["prediction_market_id"]
+        )
+
+    # Resolve markets
+    for i, market_contract in enumerate(created_market_contracts):
+        resolve_result = market_contract.resolve(
+            args=[markets_data[i]["evidence_urls"]],
+        )
+        assert tx_execution_succeeded(resolve_result)
+
+        # Verify market was resolved and has the correct outcome
+        market_state = market_contract.get_dict(args=[])
+        assert market_state["status"] == "Resolved"
+        assert market_state["outcome"] == markets_data[i]["outcome"]

tests/examples/tests/test_llm_erc20.py

@@ -0,0 +1,41 @@
+from gltest import get_contract_factory, default_account, create_account
+from gltest.assertions import tx_execution_succeeded
+
+TOKEN_TOTAL_SUPPLY = 1000
+TRANSFER_AMOUNT = 100
+
+
+def test_llm_erc20():
+    # Account Setup
+    from_account_a = 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=[])
+    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]
+    )
+    assert tx_execution_succeeded(transaction_response_call_1)
+
+    # Get Updated State
+    contract_state_2_1 = contract.get_balances(args=[])
+    assert (
+        contract_state_2_1[from_account_a.address]
+        == TOKEN_TOTAL_SUPPLY - TRANSFER_AMOUNT
+    )
+    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])
+    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])
+    assert contract_state_2_3 == TRANSFER_AMOUNT

tests/examples/tests/test_log_indexer.py

@@ -0,0 +1,63 @@
+from gltest import get_contract_factory
+from gltest.assertions import tx_execution_succeeded
+
+
+def test_log_indexer():
+    # Deploy Contract
+    factory = get_contract_factory("LogIndexer")
+    contract = factory.deploy(args=[])
+
+    # Get closest vector when empty
+    closest_vector_log_0 = contract.get_closest_vector(args=["I like mango"])
+    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])
+    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 = 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])
+    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 = 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"]
+    )
+    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 = 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])
+    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 = 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])
+    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"])
+    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

@@ -0,0 +1,15 @@
+from gltest import get_contract_factory
+from gltest.assertions import tx_execution_succeeded
+
+
+def test_multi_file_contract():
+    # Multi file contracts are considered if they are defined in a __init__.py file
+    # Deploy Contract, it will deploy other.py as well
+    factory = get_contract_factory("MultiFileContract")
+    contract = factory.deploy(args=[])
+
+    wait_response = contract.wait(args=[])
+    assert tx_execution_succeeded(wait_response)
+
+    res = contract.test(args=[])
+    assert res == "123"

tests/examples/tests/test_multi_file_contract_legacy.py

@@ -0,0 +1,15 @@
+from gltest import get_contract_factory
+from gltest.assertions import tx_execution_succeeded
+
+
+def test_multi_file_contract_legacy():
+    # Multi file contracts are considered if they are defined in a __init__.gpy file
+    # Deploy Contract, it will deploy other.gpy as well
+    factory = get_contract_factory("MultiFileContractLegacy")
+    contract = factory.deploy(args=[])
+
+    wait_response = contract.wait(args=[])
+    assert tx_execution_succeeded(wait_response)
+
+    res = contract.test(args=[])
+    assert res == "123"

tests/examples/tests/test_multi_read_erc20.py

@@ -0,0 +1,85 @@
+from gltest import get_contract_factory, create_account
+from gltest.assertions import tx_execution_succeeded
+
+
+def test_multi_read_erc20():
+    """
+    This test verifies the functionality of a multi-read ERC20 contract. It deploys two separate ERC20 token contracts
+    (referred to as 'doge' and 'shiba') and a multi-read ERC20 contract. The test aims to:
+
+    1. Deploy two different ERC20 token contracts with a total supply of 1000 tokens each.
+    2. Deploy a multi-read ERC20 contract that can interact with multiple ERC20 tokens.
+    3. Test the ability of the multi-read contract to update and retrieve token balances for multiple ERC20 tokens
+       and multiple accounts simultaneously.
+    4. Ensure the multi-read contract correctly maintains and reports balances for different account-token combinations.
+
+    This test demonstrates the integration contract to contract reads
+    """
+    TOKEN_TOTAL_SUPPLY = 1000
+    from_account_doge = create_account()
+    from_account_shiba = create_account()
+
+    # LLM ERC20
+    llm_erc20_factory = get_contract_factory("LlmErc20")
+
+    ## Deploy first LLM ERC20 Contract
+    doge_contract = llm_erc20_factory.deploy(
+        args=[TOKEN_TOTAL_SUPPLY], account=from_account_doge
+    )
+
+    ## Deploy second LLM ERC20 Contract
+    shiba_contract = llm_erc20_factory.deploy(
+        args=[TOKEN_TOTAL_SUPPLY], account=from_account_shiba
+    )
+
+    # Deploy Multi Read ERC20 Contract
+    multi_read_erc20_factory = get_contract_factory("multi_read_erc20")
+
+    multi_read_contract = multi_read_erc20_factory.deploy(
+        args=[], account=from_account_doge
+    )
+
+    # update balances for doge account
+    transaction_response_call = multi_read_contract.update_token_balances(
+        args=[
+            from_account_doge.address,
+            [doge_contract.address, shiba_contract.address],
+        ]
+    )
+    assert tx_execution_succeeded(transaction_response_call)
+
+    # check balances
+    call_method_response_get_balances = multi_read_contract.get_balances(args=[])
+    assert call_method_response_get_balances == {
+        from_account_doge.address: {
+            doge_contract.address: TOKEN_TOTAL_SUPPLY,
+            shiba_contract.address: 0,
+        }
+    }
+
+    # 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],
+        ]
+    )
+    assert tx_execution_succeeded(transaction_response_call)
+
+    # check balances
+    call_method_response_get_balances = multi_read_contract.connect(
+        from_account_shiba
+    ).get_balances(args=[])
+
+    assert call_method_response_get_balances == {
+        from_account_doge.address: {
+            doge_contract.address: TOKEN_TOTAL_SUPPLY,
+            shiba_contract.address: 0,
+        },
+        from_account_shiba.address: {
+            doge_contract.address: 0,
+            shiba_contract.address: TOKEN_TOTAL_SUPPLY,
+        },
+    }

tests/examples/tests/test_multi_tenant_storage.py

@@ -0,0 +1,58 @@
+from gltest import get_contract_factory, create_account
+from gltest.assertions import tx_execution_succeeded
+
+
+def test_multi_tenant_storage():
+    """
+    This test verifies the functionality of a multi-tenant storage contract. It deploys two separate storage contracts
+    and a multi-tenant storage contract that manages them. The test aims to:
+
+    1. Deploy two different storage contracts with initial storage values.
+    2. Deploy a multi-tenant storage contract that can interact with multiple storage contracts.
+    3. Test the ability of the multi-tenant contract to update and retrieve storage values for multiple users
+       across different storage contracts.
+    4. Ensure the multi-tenant contract correctly assigns users to storage contracts and manages their data.
+
+    This test demonstrates contract-to-contract interactions and multi-tenant data management.
+    """
+    user_account_a = create_account()
+    user_account_b = create_account()
+
+    # Storage Contracts
+    storage_factory = get_contract_factory("Storage")
+
+    ## Deploy first Storage Contract
+    first_storage_contract = storage_factory.deploy(args=["initial_storage_a"])
+
+    ## Deploy second Storage Contract
+    second_storage_contract = storage_factory.deploy(args=["initial_storage_b"])
+
+    # Deploy Multi Tenant Storage Contract
+    multi_tenant_storage_factory = get_contract_factory("MultiTentantStorage")
+    multi_tenant_storage_contract = multi_tenant_storage_factory.deploy(
+        args=[
+            [
+                first_storage_contract.address,
+                second_storage_contract.address,
+            ]
+        ]
+    )
+    # update storage for first contract
+    transaction_response_call = multi_tenant_storage_contract.connect(
+        account=user_account_a
+    ).update_storage(args=["user_a_storage"])
+    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"])
+    assert tx_execution_succeeded(transaction_response_call)
+
+    # get all storages
+    storages = multi_tenant_storage_contract.get_all_storages(args=[])
+
+    assert storages == {
+        second_storage_contract.address: "user_a_storage",
+        first_storage_contract.address: "user_b_storage",
+    }

tests/examples/tests/test_read_erc20.py

@@ -0,0 +1,37 @@
+from gltest import get_contract_factory, default_account
+
+
+def test_read_erc20():
+    """
+    Tests that recursive contract calls work by:
+    1. creating an LLM ERC20 contract
+    2. creating a read_erc20 contract that reads the LLM ERC20 contract
+    3. creating a read_erc20 contract that reads the previous read_erc20 contract
+    Repeats step 3 a few times.
+
+    It's like a linked list, but with contracts.
+    """
+    TOKEN_TOTAL_SUPPLY = 1000
+
+    # LLM ERC20
+    llm_erc20_factory = get_contract_factory("LlmErc20")
+
+    # Deploy Contract
+    llm_erc20_contract = llm_erc20_factory.deploy(args=[TOKEN_TOTAL_SUPPLY])
+    last_contract_address = llm_erc20_contract.address
+
+    # Read ERC20
+    read_erc20_factory = get_contract_factory("read_erc20")
+
+    for i in range(5):
+        print(f"Deploying contract, iteration {i}")
+
+        # deploy contract
+        read_erc20_contract = read_erc20_factory.deploy(args=[last_contract_address])
+        last_contract_address = read_erc20_contract.address
+
+        # check balance
+        contract_state = read_erc20_contract.get_balance_of(
+            args=[default_account.address]
+        )
+        assert contract_state == TOKEN_TOTAL_SUPPLY

tests/examples/tests/test_storage.py

@@ -0,0 +1,23 @@
+from gltest import get_contract_factory
+from gltest.assertions import tx_execution_succeeded
+
+
+INITIAL_STATE = "a"
+UPDATED_STATE = "b"
+
+
+def test_storage():
+    factory = get_contract_factory("Storage")
+    contract = factory.deploy(args=[INITIAL_STATE])
+
+    # Get initial state
+    contract_state_1 = contract.get_storage(args=[])
+    assert contract_state_1 == INITIAL_STATE
+
+    # Update State
+    transaction_response_call_1 = contract.update_storage(args=[UPDATED_STATE])
+    assert tx_execution_succeeded(transaction_response_call_1)
+
+    # Get Updated State
+    contract_state_2 = contract.get_storage(args=[])
+    assert contract_state_2 == UPDATED_STATE

tests/examples/tests/test_storage_legacy.py

@@ -0,0 +1,23 @@
+from gltest import get_contract_factory
+from gltest.assertions import tx_execution_succeeded
+
+
+INITIAL_STATE = "a"
+UPDATED_STATE = "b"
+
+
+def test_storage_legacy():
+    factory = get_contract_factory("StorageLegacy")
+    contract = factory.deploy(args=[INITIAL_STATE])
+
+    # Get initial state
+    contract_state_1 = contract.get_storage(args=[])
+    assert contract_state_1 == INITIAL_STATE
+
+    # Update State
+    transaction_response_call_1 = contract.update_storage(args=[UPDATED_STATE])
+    assert tx_execution_succeeded(transaction_response_call_1)
+
+    # Get Updated State
+    contract_state_2 = contract.get_storage(args=[])
+    assert contract_state_2 == UPDATED_STATE

tests/examples/tests/test_user_storage.py

@@ -0,0 +1,57 @@
+from gltest import get_contract_factory, default_account, create_account
+from gltest.assertions import tx_execution_succeeded
+
+
+INITIAL_STATE_USER_A = "user_a_initial_state"
+UPDATED_STATE_USER_A = "user_a_updated_state"
+INITIAL_STATE_USER_B = "user_b_initial_state"
+UPDATED_STATE_USER_B = "user_b_updated_state"
+
+
+def test_user_storage():
+    # Account Setup
+    from_account_a = default_account
+    from_account_b = create_account()
+
+    factory = get_contract_factory("UserStorage")
+    contract = factory.deploy()
+
+    # GET Initial State
+    contract_state_1 = contract.get_complete_storage(args=[])
+    assert contract_state_1 == {}
+
+    # ADD User A State
+    transaction_response_call_1 = contract.update_storage(args=[INITIAL_STATE_USER_A])
+    assert tx_execution_succeeded(transaction_response_call_1)
+
+    # Get Updated State
+    contract_state_2_1 = contract.get_complete_storage(args=[])
+    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])
+    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]
+    )
+    assert tx_execution_succeeded(transaction_response_call_2)
+
+    # Get Updated State
+    contract_state_3 = contract.get_complete_storage(args=[])
+    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])
+    assert tx_execution_succeeded(transaction_response_call_3)
+
+    # Get Updated State
+    contract_state_4_1 = contract.get_complete_storage(args=[])
+    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])
+    assert contract_state_4_2 == INITIAL_STATE_USER_B