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

tests/examples/tests/test_llm_erc20_analyze.py

@@ -1,54 +0,0 @@
-from gltest import get_contract_factory, get_default_account, create_account
-from datetime import datetime, timezone
-
-
-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,
-        genvm_datetime=datetime.now(timezone.utc).isoformat(),
-    )
-
-    # 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

@@ -1,76 +0,0 @@
-from gltest import get_contract_factory
-from gltest.assertions import tx_execution_succeeded
-
-
-def test_log_indexer(setup_validators):
-    setup_validators()
-    # 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"]).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]
-    ).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"]).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]
-    ).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"]).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"]
-    ).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]).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"]
-    ).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]
-    ).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"]
-    ).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,15 +0,0 @@
-from gltest import get_contract_factory
-
-
-def test_multi_file_contract(setup_validators):
-    # Multi file contracts are considered if they are defined in a __init__.py file
-    # Deploy Contract, it will deploy other.py as well
-    setup_validators()
-    factory = get_contract_factory("MultiFileContract")
-    contract = factory.deploy(
-        args=[],
-        wait_triggered_transactions=True,
-    )
-
-    res = contract.test(args=[]).call()
-    assert res == "123"

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