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

tests/examples/contracts/multi_file_contract/other.py

@@ -1,14 +0,0 @@
-# { "Depends": "py-genlayer:test" }
-
-from genlayer import *
-
-
-class Other(gl.Contract):
-    data: str
-
-    def __init__(self, data: str):
-        self.data = data
-
-    @gl.public.view
-    def test(self) -> str:
-        return self.data

tests/examples/contracts/multi_read_erc20.py

@@ -1,29 +0,0 @@
-# v0.1.0
-# { "Depends": "py-genlayer:test" }
-
-from genlayer import *
-
-
-class multi_read_erc20(gl.Contract):
-    balances: TreeMap[Address, TreeMap[Address, u256]]
-
-    def __init__(self):
-        pass
-
-    @gl.public.write
-    def update_token_balances(
-        self, account_address: str, token_contracts: list[str]
-    ) -> None:
-        for token_contract in token_contracts:
-            contract = gl.get_contract_at(Address(token_contract))
-            balance = contract.view().get_balance_of(account_address)
-            self.balances.get_or_insert_default(Address(account_address))[
-                Address(token_contract)
-            ] = balance
-
-    @gl.public.view
-    def get_balances(self) -> dict[str, dict[str, int]]:
-        return {
-            k.as_hex: {k.as_hex: v for k, v in v.items()}
-            for k, v in self.balances.items()
-        }

tests/examples/contracts/multi_tenant_storage.py

@@ -1,51 +0,0 @@
-# v0.1.0
-# { "Depends": "py-genlayer:test" }
-
-from genlayer import *
-
-
-class MultiTentantStorage(gl.Contract):
-    """
-    Same functionality as UserStorage, but implemented with multiple storage contracts.
-    Each user is assigned to a storage contract, and all storage contracts are managed by this same contract.
-    This contract does not prevent users from directly interacting with the storage contracts, but it doesn't bother us for testing purposes.
-    This is done to test contract calls between different contracts.
-    """
-
-    all_storage_contracts: DynArray[Address]
-    available_storage_contracts: DynArray[Address]
-    mappings: TreeMap[
-        Address, Address
-    ]  # mapping of user address to storage contract address
-
-    def __init__(self, storage_contracts: list[str]):
-        for el in storage_contracts:
-            self.all_storage_contracts.append(Address(el))
-            self.available_storage_contracts.append(Address(el))
-
-    @gl.public.view
-    def get_available_contracts(self) -> list[str]:
-        return [x.as_hex for x in self.available_storage_contracts]
-
-    @gl.public.view
-    def get_all_storages(self) -> dict[str, str]:
-        return {
-            storage_contract.as_hex: gl.get_contract_at(storage_contract)
-            .view()
-            .get_storage()
-            for storage_contract in self.all_storage_contracts
-        }
-
-    @gl.public.write
-    def update_storage(self, new_storage: str) -> None:
-        # Assign user to a storage contract if not already assigned
-        if gl.message.sender_address not in self.mappings:
-            self.mappings[gl.message.sender_address] = self.available_storage_contracts[
-                -1
-            ]
-            self.available_storage_contracts.pop()
-
-        contract_to_use = self.mappings[gl.message.sender_address]
-        gl.get_contract_at(contract_to_use).emit(on="accepted").update_storage(
-            new_storage
-        )

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_custom_validators.py

@@ -1,65 +0,0 @@
-from gltest import get_contract_factory
-from gltest.assertions import tx_execution_succeeded
-from gltest import get_validator_factory
-from gltest.types import MockedLLMResponse
-import json
-
-
-def test_custom_validators():
-
-    validator_factory = get_validator_factory()
-    validators = validator_factory.batch_create_validators(
-        count=5,
-        stake=8,
-        provider="openai",
-        model="gpt-4o",
-        config={"temperature": 0.75, "max_tokens": 500},
-        plugin="openai-compatible",
-        plugin_config={
-            "api_key_env_var": "OPENAIKEY",
-            "api_url": "https://api.openai.com",
-        },
-    )
-
-    factory = get_contract_factory("WizardOfCoin")
-    contract = factory.deploy(
-        args=[True],
-        transaction_context={"validators": [v.to_dict() for v in validators]},
-    )
-
-    transaction_response_call_1 = contract.ask_for_coin(
-        args=["Can you please give me my coin?"]
-    ).transact(transaction_context={"validators": [v.to_dict() for v in validators]})
-    assert tx_execution_succeeded(transaction_response_call_1)
-
-
-def test_custom_mocked_validators():
-    mock_llm_response: MockedLLMResponse = {
-        "nondet_exec_prompt": {
-            "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
-        },
-    }
-    validator_factory = get_validator_factory()
-    validators = validator_factory.batch_create_mock_validators(
-        count=5,
-        mock_llm_response=mock_llm_response,
-    )
-
-    factory = get_contract_factory("WizardOfCoin")
-    contract = factory.deploy(
-        args=[True],
-        transaction_context={"validators": [v.to_dict() for v in validators]},
-    )
-
-    transaction_response_call_1 = contract.ask_for_coin(
-        args=["Can you please give me my coin?"]
-    ).transact(transaction_context={"validators": [v.to_dict() for v in validators]})
-    assert tx_execution_succeeded(transaction_response_call_1)

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