genlayer-test 0.7.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

tests/examples/tests/test_multi_read_erc20.py

@@ -1,103 +0,0 @@
-from gltest import get_contract_factory, create_account, get_accounts
-from gltest.assertions import tx_execution_succeeded
-from gltest_cli.config.general import get_general_config
-from genlayer_py.chains import testnet_asimov
-
-
-def test_multi_read_erc20(setup_validators):
-    """
-    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
-    """
-    setup_validators()
-    general_config = get_general_config()
-    chain = general_config.get_chain()
-
-    TOKEN_TOTAL_SUPPLY = 1000
-
-    if chain.id == testnet_asimov.id:
-        accounts = get_accounts()
-        if len(accounts) < 2:
-            raise ValueError(
-                f"Test requires at least 2 accounts, but only {len(accounts)} available"
-            )
-        from_account_doge = accounts[0]
-        from_account_shiba = accounts[1]
-    else:
-        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],
-        ]
-    ).transact()
-    assert tx_execution_succeeded(transaction_response_call)
-
-    # check balances
-    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,
-            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],
-            ]
-        )
-        .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()
-    )
-
-    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

@@ -1,76 +0,0 @@
-from gltest import get_contract_factory, create_account, get_accounts
-from gltest.assertions import tx_execution_succeeded
-from gltest_cli.config.general import get_general_config
-from genlayer_py.chains import testnet_asimov
-
-
-def test_multi_tenant_storage(setup_validators):
-    """
-    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.
-    """
-    setup_validators()
-    general_config = get_general_config()
-    chain = general_config.get_chain()
-
-    if chain.id == testnet_asimov.id:
-        user_account_a = get_accounts()[0]
-        user_account_b = get_accounts()[1]
-    else:
-        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"])
-        .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"])
-        .transact(
-            wait_triggered_transactions=True,
-        )
-    )
-    assert tx_execution_succeeded(transaction_response_call)
-
-    # get all storages
-    storages = multi_tenant_storage_contract.get_all_storages(args=[]).call()
-
-    assert storages == {
-        second_storage_contract.address: "user_a_storage",
-        first_storage_contract.address: "user_b_storage",
-    }

tests/examples/tests/test_read_erc20.py

@@ -1,38 +0,0 @@
-from gltest import get_contract_factory, get_default_account
-
-
-def test_read_erc20(setup_validators):
-    """
-    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.
-    """
-    setup_validators()
-    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=[get_default_account().address]
-        ).call()
-        assert contract_state == TOKEN_TOTAL_SUPPLY

tests/examples/tests/test_simple_time_contract.py

@@ -1,90 +0,0 @@
-from gltest import get_contract_factory
-from datetime import datetime, timedelta, timezone
-from gltest.assertions import tx_execution_succeeded, tx_execution_failed
-
-
-def test_simple_time_contract():
-    """Test all time-based functionality in a single comprehensive test."""
-
-    factory = get_contract_factory("SimpleTimeContract")
-
-    # Test 1: Deploy with past start date (10 days ago)
-    now = datetime.now(timezone.utc)
-    past_date = (now - timedelta(days=10)).isoformat()
-    contract = factory.deploy(args=[past_date])
-
-    # Test 1: Check initial status (10 days after start)
-    status = contract.get_status().call()
-    assert status["is_active"] == False
-    assert status["days_since_start"] == 10
-    assert status["can_activate"] == True
-
-    # Test 2: Try to activate before start date (simulate going back in time)
-    before_start_date = now - timedelta(days=15)  # 5 days before start
-    before_start_date_receipt = contract.activate().transact(
-        transaction_context={
-            "genvm_datetime": before_start_date.isoformat(),
-        },
-    )
-    assert tx_execution_failed(before_start_date_receipt)
-
-    # Test 3: Activate after start date
-    activate_date = now - timedelta(days=5)  # 5 days after start (15 days ago + 10)
-    activate_receipt = contract.activate().transact(
-        transaction_context={
-            "genvm_datetime": activate_date.isoformat(),
-        },
-    )
-    assert tx_execution_succeeded(activate_receipt)
-
-    # Test 4: Verify activation and check status
-    status = contract.get_status().call(
-        transaction_context={
-            "genvm_datetime": activate_date.isoformat(),
-        },
-    )
-    assert status["is_active"] == True
-    assert status["days_since_start"] == 5
-    assert status["can_set_data"] == True
-
-    # Test 5: Set data within valid period (within 30 days)
-    set_data_date = now - timedelta(days=2)  # 8 days after start
-    test_data = "Test data within valid period"
-    set_data_receipt = contract.set_data(
-        args=[test_data],
-    ).transact(
-        transaction_context={
-            "genvm_datetime": set_data_date.isoformat(),
-        }
-    )
-    assert tx_execution_succeeded(set_data_receipt)
-
-    # Test 6: Verify data was set
-    status = contract.get_status().call(
-        transaction_context={
-            "genvm_datetime": set_data_date.isoformat(),
-        },
-    )
-    assert status["data"] == test_data
-    assert status["days_since_start"] == 8
-
-    # Test 7: Try to set data after 30 days (should fail)
-    expired_date = now + timedelta(days=25)  # 35 days after start
-    expired_date_receipt = contract.set_data(
-        args=["Should fail - expired"],
-    ).transact(
-        transaction_context={
-            "genvm_datetime": expired_date.isoformat(),
-        }
-    )
-    assert tx_execution_failed(expired_date_receipt)
-
-    # Test 8: Check status shows expired
-    status = contract.get_status().call(
-        transaction_context={
-            "genvm_datetime": expired_date.isoformat(),
-        },
-    )
-    assert status["is_active"] == True  # Still active
-    assert status["can_set_data"] == False  # But can't set data
-    assert status["days_since_start"] == 35

tests/examples/tests/test_storage.py

@@ -1,26 +0,0 @@
-from gltest import get_contract_factory
-from gltest.assertions import tx_execution_succeeded
-
-
-INITIAL_STATE = "a"
-UPDATED_STATE = "b"
-
-
-def test_storage(setup_validators):
-    setup_validators()
-    factory = get_contract_factory("Storage")
-    contract = factory.deploy(args=[INITIAL_STATE], wait_retries=40)
-
-    # Get initial state
-    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]
-    ).transact(wait_retries=40)
-    assert tx_execution_succeeded(transaction_response_call_1)
-
-    # Get Updated State
-    contract_state_2 = contract.get_storage(args=[]).call()
-    assert contract_state_2 == UPDATED_STATE

tests/examples/tests/test_user_storage.py

@@ -1,87 +0,0 @@
-from gltest import (
-    get_contract_factory,
-    get_default_account,
-    create_account,
-    get_accounts,
-)
-from gltest.assertions import tx_execution_succeeded
-from gltest_cli.config.general import get_general_config
-from genlayer_py.chains import testnet_asimov
-
-
-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(setup_validators):
-    setup_validators()
-    general_config = get_general_config()
-    chain = general_config.get_chain()
-
-    # Account Setup
-    if chain.id == testnet_asimov.id:
-        accounts = get_accounts()
-        if len(accounts) < 2:
-            raise ValueError(
-                f"Test requires at least 2 accounts, but only {len(accounts)} available"
-            )
-        from_account_a = accounts[0]
-        from_account_b = accounts[1]
-    else:
-        from_account_a = get_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=[]).call()
-    assert contract_state_1 == {}
-
-    # ADD User A State
-    transaction_response_call_1 = contract.update_storage(
-        args=[INITIAL_STATE_USER_A]
-    ).transact()
-    assert tx_execution_succeeded(transaction_response_call_1)
-
-    # Get Updated State
-    contract_state_2_1 = contract.get_complete_storage(args=[]).call()
-    assert contract_state_2_1[from_account_a.address] == INITIAL_STATE_USER_A
-
-    # Get Updated State
-    contract_state_2_2 = contract.get_account_storage(
-        args=[from_account_a.address]
-    ).call()
-    assert contract_state_2_2 == INITIAL_STATE_USER_A
-
-    # ADD User B State
-    transaction_response_call_2 = (
-        contract.connect(from_account_b)
-        .update_storage(args=[INITIAL_STATE_USER_B])
-        .transact()
-    )
-    assert tx_execution_succeeded(transaction_response_call_2)
-
-    # Get Updated State
-    contract_state_3 = contract.get_complete_storage(args=[]).call()
-    assert contract_state_3[from_account_a.address] == INITIAL_STATE_USER_A
-    assert contract_state_3[from_account_b.address] == INITIAL_STATE_USER_B
-
-    # UPDATE User A State
-    transaction_response_call_3 = contract.update_storage(
-        args=[UPDATED_STATE_USER_A]
-    ).transact()
-    assert tx_execution_succeeded(transaction_response_call_3)
-
-    # Get Updated State
-    contract_state_4_1 = contract.get_complete_storage(args=[]).call()
-    assert contract_state_4_1[from_account_a.address] == UPDATED_STATE_USER_A
-    assert contract_state_4_1[from_account_b.address] == INITIAL_STATE_USER_B
-
-    # Get Updated State
-    contract_state_4_2 = contract.get_account_storage(
-        args=[from_account_b.address]
-    ).call()
-    assert contract_state_4_2 == INITIAL_STATE_USER_B

tests/examples/tests/test_wizard_of_coin.py

@@ -1,27 +0,0 @@
-from gltest import get_contract_factory
-from gltest.assertions import tx_execution_succeeded
-import json
-
-
-def test_wizard_of_coin(setup_validators):
-    mock_response = {
-        "response": {
-            "wizard": json.dumps(
-                {
-                    "reasoning": "I am a grumpy wizard and I never give away my coins!",
-                    "give_coin": False,
-                }
-            ),
-        },
-        "eq_principle_prompt_comparative": {
-            "The value of give_coin has to match": True
-        },
-    }
-    setup_validators(mock_response)
-    factory = get_contract_factory("WizardOfCoin")
-    contract = factory.deploy(args=[True])
-
-    transaction_response_call_1 = contract.ask_for_coin(
-        args=["Can you please give me my coin?"]
-    ).transact()
-    assert tx_execution_succeeded(transaction_response_call_1)

tests/gltest/artifact/contracts/duplicate_ic_contract_1.py

@@ -1,22 +0,0 @@
-# { "Depends": "py-genlayer:test" }
-
-from genlayer import *
-
-
-# contract class
-class DuplicateContract(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/gltest/artifact/contracts/duplicate_ic_contract_2.py

@@ -1,22 +0,0 @@
-# { "Depends": "py-genlayer:test" }
-
-from genlayer import *
-
-
-# contract class
-class DuplicateContract(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/gltest/artifact/contracts/not_ic_contract.py

@@ -1,22 +0,0 @@
-# { "Depends": "py-genlayer:test" }
-
-from genlayer import *
-
-
-# contract class that is not an IC contract
-class NotICContract:
-    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/gltest/artifact/test_contract_definition.py

@@ -1,55 +0,0 @@
-import pytest
-from gltest.artifacts.contract import (
-    find_contract_definition_from_name,
-    compute_contract_code,
-)
-from gltest_cli.config.general import get_general_config
-from pathlib import Path
-
-CONTRACTS_DIR = Path("tests/examples/contracts")
-
-
-def test_single_file():
-    general_config = get_general_config()
-    general_config.set_contracts_dir(Path("."))
-    contract_definition = find_contract_definition_from_name("PredictionMarket")
-
-    assert contract_definition.contract_name == "PredictionMarket"
-
-    # Assert complete contract definition
-    expected_main_file_path = CONTRACTS_DIR / "football_prediction_market.py"
-    expected_runner_file_path = None
-    contract_code = compute_contract_code(
-        expected_main_file_path, expected_runner_file_path
-    )
-    assert contract_definition.contract_code == contract_code
-    assert str(contract_definition.main_file_path) == str(
-        CONTRACTS_DIR / "football_prediction_market.py"
-    )
-    assert contract_definition.runner_file_path is None
-
-
-def test_multiple_files():
-    general_config = get_general_config()
-    general_config.set_contracts_dir(Path("."))
-    contract_definition = find_contract_definition_from_name("MultiFileContract")
-
-    assert contract_definition.contract_name == "MultiFileContract"
-
-    # Assert complete contract definition
-    expected_main_file_path = CONTRACTS_DIR / "multi_file_contract/__init__.py"
-    expected_runner_file_path = CONTRACTS_DIR / "multi_file_contract/runner.json"
-    assert contract_definition.main_file_path == expected_main_file_path
-    assert contract_definition.runner_file_path == expected_runner_file_path
-    contract_code = compute_contract_code(
-        expected_main_file_path, expected_runner_file_path
-    )
-    assert contract_definition.contract_code == contract_code
-
-
-def test_class_is_not_intelligent_contract():
-    general_config = get_general_config()
-    general_config.set_contracts_dir(Path("."))
-
-    with pytest.raises(FileNotFoundError):
-        _ = find_contract_definition_from_name("NotICContract")