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

tests/examples/contracts/read_erc20.py

@@ -1,19 +0,0 @@
-# v0.1.0
-# { "Depends": "py-genlayer:test" }
-
-from genlayer import *
-
-
-class read_erc20(gl.Contract):
-    token_contract: Address
-
-    def __init__(self, token_contract: str):
-        self.token_contract = Address(token_contract)
-
-    @gl.public.view
-    def get_balance_of(self, account_address: str) -> int:
-        return (
-            gl.get_contract_at(self.token_contract)
-            .view()
-            .get_balance_of(account_address)
-        )

tests/examples/contracts/simple_time_contract.py

@@ -1,85 +0,0 @@
-# {
-#   "Seq": [
-#     { "Depends": "py-lib-genlayer-embeddings:09h0i209wrzh4xzq86f79c60x0ifs7xcjwl53ysrnw06i54ddxyi" },
-#     { "Depends": "py-genlayer:1j12s63yfjpva9ik2xgnffgrs6v44y1f52jvj9w7xvdn7qckd379" }
-#   ]
-# }
-
-from datetime import datetime, timezone
-from genlayer import *
-
-
-class SimpleTimeContract(gl.Contract):
-    """
-    A simple contract that demonstrates time-based function availability.
-    """
-
-    start_date: str  # ISO format datetime string
-    data: str
-    is_active: bool
-
-    def __init__(self, start_datetime_iso: str):
-        """
-        Initialize the contract with a required start date (ISO 8601).
-        """
-        self.start_date = start_datetime_iso
-        self.is_active = False
-        self.data = ""
-
-    def _days_since_start(self) -> int:
-        """Calculate days elapsed since start date."""
-        current = datetime.now(timezone.utc)
-        start = datetime.fromisoformat(self.start_date)
-        print(f"Current: {current}, Start: {start}")
-        delta = current - start
-        print(f"Delta: {delta}")
-        return delta.days
-
-    @gl.public.write
-    def activate(self):
-        """
-        Activate the contract.
-        Only works if current date is after start date.
-        """
-        days = self._days_since_start()
-
-        if days < 0:
-            raise ValueError(
-                f"Cannot activate before start date. Days until start: {abs(days)}"
-            )
-
-        self.is_active = True
-
-    @gl.public.write
-    def set_data(self, value: str):
-        """
-        Set data in the contract.
-        Only works if contract is active and within 30 days of start.
-        """
-        if not self.is_active:
-            raise ValueError("Contract must be activated first")
-
-        days = self._days_since_start()
-
-        if days > 30:
-            raise ValueError(
-                f"Function expired. Was available for 30 days after start, now at day {days}"
-            )
-
-        self.data = value
-
-    @gl.public.view
-    def get_status(self) -> dict:
-        """Get current contract status."""
-        days = self._days_since_start()
-        current = datetime.now(timezone.utc)
-
-        return {
-            "start_date": self.start_date,
-            "current_time": current.isoformat(),
-            "days_since_start": days,
-            "is_active": self.is_active,
-            "data": self.data,
-            "can_activate": days >= 0 and not self.is_active,
-            "can_set_data": self.is_active and 0 <= days <= 30,
-        }

tests/examples/contracts/storage.py

@@ -1,23 +0,0 @@
-# v0.1.0
-# { "Depends": "py-genlayer:latest" }
-
-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

@@ -1,25 +0,0 @@
-# v0.1.0
-# { "Depends": "py-genlayer:latest" }
-
-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

@@ -1,57 +0,0 @@
-# v0.1.0
-# { "Depends": "py-genlayer:latest" }
-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.nondet.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

@@ -1,38 +0,0 @@
-from gltest import get_contract_factory
-from gltest.assertions import tx_execution_succeeded
-import json
-
-
-def test_football_prediction_market(setup_validators):
-
-    # Setup validators with mock response
-    team_1 = "Georgia"
-    team_2 = "Portugal"
-    score = "2:0"
-    winner = 1
-    mock_response = {
-        "response": {
-            f"Team 1: {team_1}\nTeam 2: {team_2}": json.dumps(
-                {
-                    "score": score,
-                    "winner": winner,
-                }
-            ),
-        }
-    }
-    setup_validators(mock_response)
-
-    # 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=[]).transact()
-    assert tx_execution_succeeded(transaction_response_call_1)
-
-    # Get Updated State
-    contract_state_2 = contract.get_resolution_data(args=[]).call()
-
-    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

@@ -1,162 +0,0 @@
-import json
-
-from gltest import get_contract_factory
-from gltest.assertions import tx_execution_succeeded
-
-
-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."
-    reasoning_single_source_election = "The URL is a valid news page. The election has occurred, and Donald Trump is reported to have won with 312 votes. The rule specifies that the outcome is based on official election results."
-    reasoning_all_sources_election = "The only data source provided is from BBC News. It reports that Donald Trump won the 2024 US presidential election with 312 votes. The rule specifies that the outcome is based on official election results. There are no other sources contradicting this information."
-
-    return {
-        "response": {
-            f"outcomes.\n\n### Inputs\n<title>\n{markets_data[0]['title']}": json.dumps(
-                {
-                    "valid_source": "true",
-                    "event_has_occurred": "true",
-                    "reasoning": reasoning_single_source_marathon,
-                    "outcome": markets_data[0]["outcome"],
-                }
-            ),
-            f"inputs\n\n    ### Inputs\n    <title>\n    {markets_data[0]['title']}\n": json.dumps(
-                {
-                    "relevant_sources": [markets_data[0]["evidence_urls"]],
-                    "reasoning": reasoning_all_sources_marathon,
-                    "outcome": markets_data[0]["outcome"],
-                }
-            ),
-            f"outcomes.\n\n### Inputs\n<title>\n{markets_data[1]['title']}": json.dumps(
-                {
-                    "valid_source": "true",
-                    "event_has_occurred": "true",
-                    "reasoning": reasoning_single_source_election,
-                    "outcome": markets_data[1]["outcome"],
-                }
-            ),
-            f"inputs\n\n    ### Inputs\n    <title>\n    {markets_data[1]['title']}\n": json.dumps(
-                {
-                    "relevant_sources": [markets_data[1]["evidence_urls"]],
-                    "reasoning": reasoning_all_sources_election,
-                    "outcome": markets_data[1]["outcome"],
-                }
-            ),
-        },
-        "eq_principle_prompt_comparative": {
-            reasoning_single_source_marathon: True,
-            reasoning_all_sources_marathon: True,
-            reasoning_single_source_election: True,
-            reasoning_all_sources_election: True,
-        },
-    }
-
-
-def test_intelligent_oracle_factory_pattern(setup_validators):
-    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",
-        },
-    ]
-
-    mock_response = create_mock_response(markets_data)
-
-    setup_validators(mock_response)
-
-    # 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]
-    )
-
-    # Create markets through factory
-    created_market_contracts = []
-    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"],
-            ],
-        ).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=[]).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)
-
-    # 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=[]).call()
-        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"]],
-        ).transact()
-        assert tx_execution_succeeded(resolve_result)
-
-        # Verify market was resolved and has the correct outcome
-        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_invalid_deploy.py

@@ -1,24 +0,0 @@
-import pytest
-from gltest import get_contract_factory
-from gltest.assertions import tx_execution_failed
-from gltest.exceptions import DeploymentError
-
-
-def test_invalid_deploy_basic_exception(setup_validators):
-    """Test deployment failure with basic exception"""
-    setup_validators()
-    factory = get_contract_factory("InvalidDeploy")
-
-    # Deployment should fail with exception
-    with pytest.raises(DeploymentError):
-        factory.deploy()
-
-
-def test_invalid_deploy_receipt_only(setup_validators):
-    """Test deployment failure using deploy_contract_tx() method that returns receipt only"""
-    setup_validators()
-    factory = get_contract_factory("InvalidDeploy")
-
-    # Deploy and get receipt - should show failure
-    receipt = factory.deploy_contract_tx()
-    assert tx_execution_failed(receipt)

tests/examples/tests/test_llm_erc20.py

@@ -1,60 +0,0 @@
-from gltest import get_contract_factory, get_default_account, create_account
-from gltest.assertions import tx_execution_succeeded
-import json
-
-TOKEN_TOTAL_SUPPLY = 1000
-TRANSFER_AMOUNT = 100
-
-
-def test_llm_erc20(setup_validators):
-    # Account Setup
-    from_account_a = get_default_account()
-    from_account_b = create_account()
-
-    # Mock Response
-    mock_response = {
-        "response": {
-            "The balance of the sender": json.dumps(
-                {
-                    "transaction_success": True,
-                    "transaction_error": "",
-                    "updated_balances": {
-                        from_account_a.address: TOKEN_TOTAL_SUPPLY - TRANSFER_AMOUNT,
-                        from_account_b.address: TRANSFER_AMOUNT,
-                    },
-                }
-            )
-        },
-        "eq_principle_prompt_non_comparative": {"The balance of the sender": True},
-    }
-    setup_validators(mock_response=mock_response)
-
-    # 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
-    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=[]).call()
-    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]).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]).call()
-    assert contract_state_2_3 == TRANSFER_AMOUNT

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"