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

tests/examples/contracts/intelligent_oracle.py

@@ -1,370 +0,0 @@
-# v0.1.0
-# { "Depends": "py-genlayer:test" }
-
-import json
-from enum import Enum
-from datetime import datetime, timezone
-from urllib.parse import urlparse
-from genlayer import *
-
-
-class Status(Enum):
-    ACTIVE = "Active"
-    RESOLVED = "Resolved"
-    ERROR = "Error"
-
-
-class IntelligentOracle(gl.Contract):
-    # Declare persistent storage fields
-    prediction_market_id: str
-    title: str
-    description: str
-    potential_outcomes: DynArray[str]
-    rules: DynArray[str]
-    data_source_domains: DynArray[str]
-    resolution_urls: DynArray[str]
-    earliest_resolution_date: str  # Store as ISO format string
-    status: str  # Store as string since Enum isn't supported
-    analysis: str  # Store analysis results
-    outcome: str
-
-    def __init__(
-        self,
-        prediction_market_id: str,
-        title: str,
-        description: str,
-        potential_outcomes: list[str],
-        rules: list[str],
-        data_source_domains: list[str],
-        resolution_urls: list[str],
-        earliest_resolution_date: str,
-    ):
-        if (
-            not prediction_market_id
-            or not title
-            or not description
-            or not potential_outcomes
-            or not rules
-            or not earliest_resolution_date
-        ):
-            raise ValueError("Missing required fields.")
-
-        if not resolution_urls and not data_source_domains:
-            raise ValueError("Missing resolution URLs or data source domains.")
-
-        if len(resolution_urls) > 0 and len(data_source_domains) > 0:
-            raise ValueError(
-                "Cannot provide both resolution URLs and data source domains."
-            )
-
-        if len(potential_outcomes) < 2:
-            raise ValueError("At least two potential outcomes are required.")
-
-        if len(potential_outcomes) != len(set(potential_outcomes)):
-            raise ValueError("Potential outcomes must be unique.")
-
-        self.prediction_market_id = prediction_market_id
-        self.title = title
-        self.description = description
-
-        for outcome in potential_outcomes:
-            self.potential_outcomes.append(outcome.strip())
-
-        for rule in rules:
-            self.rules.append(rule)
-
-        for datasource in data_source_domains:
-            self.data_source_domains.append(
-                datasource.strip()
-                .lower()
-                .replace("http://", "")
-                .replace("https://", "")
-                .replace("www.", "")
-            )
-
-        for url in resolution_urls:
-            self.resolution_urls.append(url.strip())
-
-        self.earliest_resolution_date = earliest_resolution_date
-        self.status = Status.ACTIVE.value
-
-        self.outcome = ""
-
-    @gl.public.view
-    def _check_evidence_domain(self, evidence: str) -> bool:
-        try:
-            parsed_url = urlparse(evidence)
-            evidence_domain = parsed_url.netloc.lower().replace("www.", "")
-            return evidence_domain in self.data_source_domains
-        except Exception:
-            return False
-
-    @gl.public.write
-    def resolve(self, evidence_url: str = "") -> None:
-        if self.status == Status.RESOLVED.value:
-            raise ValueError("Cannot resolve an already resolved oracle.")
-
-        current_time = datetime.now().astimezone().date()
-        earliest_time = datetime.fromisoformat(self.earliest_resolution_date).date()
-        if current_time < earliest_time:
-            raise ValueError("Cannot resolve before the earliest resolution date.")
-
-        if len(self.resolution_urls) > 0 and evidence_url:
-            raise ValueError(
-                "An evidence URL was provided but the oracle is configured to use resolution URLs already provided."
-            )
-
-        if len(self.resolution_urls) == 0 and not evidence_url:
-            raise ValueError(
-                "No evidence URL provided and the oracle is not configured to use resolution URLs."
-            )
-
-        if evidence_url:
-            is_valid = self._check_evidence_domain(evidence_url)
-            if not is_valid:
-                raise ValueError(
-                    "The evidence URL does not match any of the data source domains."
-                )
-
-        analyzed_outputs = []
-        resources_to_check = (
-            self.resolution_urls if len(self.resolution_urls) > 0 else [evidence_url]
-        )
-
-        title = self.title
-        description = self.description
-        potential_outcomes = list(self.potential_outcomes)
-        rules = list(self.rules)
-        earliest_resolution_date = self.earliest_resolution_date
-
-        for resource_url in resources_to_check:
-
-            def evaluate_single_source() -> str:
-                resource_web_data = gl.nondet.web.render(resource_url, mode="text")
-                print(resource_web_data)
-
-                task = f"""
-You are an AI Validator tasked with resolving a prediction market.
-Your goal is to determine the correct outcome based on the user-defined rules,
-the provided webpage HTML content, the resolution date, and the list of potential outcomes.
-
-### Inputs
-<title>
-{title}
-</title>
-
-<description>
-{description}
-</description>
-
-<potential_outcomes>
-{potential_outcomes}
-</potential_outcomes>
-
-<rules>
-{rules}
-</rules>
-
-<source_url>
-{resource_url}
-</source_url>
-
-<webpage_content>
-{resource_web_data}
-</webpage_content>
-
-<current_date>
-{datetime.now().astimezone()}
-</current_date>
-
-<earliest_resolution_date>
-{earliest_resolution_date}
-</earliest_resolution_date>
-
-
-
-
-### **Your Task:**
-1. **Analyze the Inputs:**
-- Carefully read and interpret the user-defined rules.
-- Parse the HTML content to extract meaningful information relevant to the rules.
-- Determine if the source pertains to the event that is being predicted.
-- Determine if the event has occurred yet.
-
-2. **Provide Reasoning:**
-- Write a clear, self-contained reasoning for the outcome.
-- Reference specific parts of the rules and the extracted data that support your decision.
-- Ensure that someone reading the reasoning can understand it without needing additional information.
-
-3. **Determine The Outcome:**
-- Based on your analysis, decide which potential outcome is correct.
-- If an outcome can be determined, but the outcome is not in the list of potential outcomes, the outcome should be `ERROR`.
-- If the information is insufficient or inconclusive, or the event has not occurred yet, and you cannot confidently determine an outcome based on this source, the outcome should be `UNDETERMINED`.
-
-
-
-
-### **Output Format:**
-
-Provide your response in **valid JSON** format with the following structure:
-
-```json
-{{
-    "valid_source": "true | false",
-    "event_has_occurred": "true | false",
-    "reasoning": "Your detailed reasoning here",
-    "outcome": "Chosen outcome from the potential outcomes list, `UNDETERMINED` if no outcome can be determined based on this source, `ERROR` if the outcome is not in the potential outcomes list"
-}}
-```
-
-### **Constraints and Considerations:**
-
-- **Accuracy:** Base your decision strictly on the provided inputs.
-- **Objectivity:** Remain neutral and unbiased.
-- **Clarity:** Make sure your reasoning is easy to understand.
-- **Validity:** Ensure the JSON output is properly formatted and free of errors. Do not include trailing commas.
-                """
-                result = gl.nondet.exec_prompt(task)
-                print(result)
-                return result
-
-            result = gl.eq_principle.prompt_comparative(
-                evaluate_single_source,
-                principle="`outcome` field must be exactly the same. All other fields must be similar",
-            )
-
-            result_dict = _parse_json_dict(result)
-            analyzed_outputs.append((resource_url, result_dict))
-
-        def evaluate_all_sources() -> str:
-            task = f"""
-    You are an AI Validator tasked with resolving a prediction market Oracle. Your goal is to determine
-    the correct outcome based on processed data from all of the individial data sources. Here are your inputs
-
-    ### Inputs
-    <title>
-    {title}
-    </title>
-
-    <description>
-    {description}
-    </description>
-
-    <potential_outcomes>
-    {potential_outcomes}
-    </potential_outcomes>
-
-    <rules>
-    {rules}
-    </rules>
-
-    <processed_data>
-    {analyzed_outputs}
-    </processed_data>
-
-    <current_date>
-    {datetime.now().astimezone()}
-    </current_date>
-
-    <earliest_resolution_date>
-    {earliest_resolution_date}
-    </earliest_resolution_date>
-
-    ### **Your Task:**
-    1. **Analyze the Inputs:**
-    - Carefully read and interpret the user-defined rules.
-    - Take into account all the processed data form the sources.
-    - Consider the resolution date in your analysis to ensure timeliness of the data.
-
-    2. **Determine The Outcome:**
-    - The output should be determined from the processed data form the resolution sources.
-    - Based on your analysis, decide which potential outcome is correct.
-    - If an outcome can be determined, but the outcome is not in the list of potential outcomes, the outcome should be `ERROR`.
-    - If the information is insufficient or inconclusive, and you cannot confidently determine an outcome, the outcome should be `UNDETERMINED`.
-    - Your response should reflect a coherent summary outcome from the previous analysis.
-    - If multiple sources contradict each other, refer to the rules to determine how to resolve the contradiction.
-    - If the rules do not provide a clear resolution, the outcome should be `ERROR`.
-
-    ### **Output Format:**
-
-    Provide your response in **valid JSON** format with the following structure:
-
-    ```json
-    {{
-    "relevant_sources": "List of URLs that are relevant to the outcome",
-    "reasoning": "Your detailed reasoning here",
-    "outcome": "Chosen outcome from the potential outcomes list, `UNDETERMINED` if undetermined, `ERROR` if the outcome is not in the potential outcomes list"
-    }}
-    ```
-
-    ### **Constraints and Considerations:**
-
-    - **Accuracy:** Base your decision strictly on the provided inputs.
-    - **Objectivity:** Remain neutral and unbiased.
-    - **Clarity:** Make sure your reason is easy to understand.
-    - **Validity:** Ensure the JSON output is properly formatted and free of errors. Do not include trailing commas.
-
-            """
-
-            result = gl.nondet.exec_prompt(task)
-            print(result)
-            return result
-
-        result = gl.eq_principle.prompt_comparative(
-            evaluate_all_sources,
-            principle="`outcome` field must be exactly the same. All other fields must be similar",
-        )
-
-        result_dict = _parse_json_dict(result)
-        self.analysis = json.dumps(result_dict)
-
-        if result_dict["outcome"] == "UNDETERMINED":
-            return
-
-        if (
-            result_dict["outcome"] == "ERROR"
-            or result_dict["outcome"] not in self.potential_outcomes
-        ):
-            self.status = Status.ERROR.value
-            return
-
-        self.outcome = result_dict["outcome"]
-        self.status = Status.RESOLVED.value
-
-    @gl.public.view
-    def get_dict(self) -> dict[str, str | list[str]]:
-        return {
-            "title": self.title,
-            "description": self.description,
-            "potential_outcomes": list(self.potential_outcomes),
-            "rules": list(self.rules),
-            "data_source_domains": list(self.data_source_domains),
-            "resolution_urls": list(self.resolution_urls),
-            "status": self.status,
-            "earliest_resolution_date": self.earliest_resolution_date,
-            "analysis": self.analysis,
-            "outcome": self.outcome,
-            "prediction_market_id": self.prediction_market_id,
-        }
-
-    @gl.public.view
-    def get_status(self) -> str:
-        return self.status
-
-
-def _parse_json_dict(json_str: str) -> dict:
-    """
-    Used to sanitize the JSON output from the LLM.
-    Remove everything before the first '{' and after the last '}', and remove trailing commas before closing braces/brackets
-    """
-    first_brace = json_str.find("{")
-    last_brace = json_str.rfind("}")
-    json_str = json_str[first_brace : last_brace + 1]
-
-    # Remove trailing commas before closing braces/brackets
-    import re
-
-    json_str = re.sub(r",(?!\s*?[\{\[\"\'\w])", "", json_str)
-    print(json_str)
-
-    return json.loads(json_str)

tests/examples/contracts/intelligent_oracle_factory.py

@@ -1,49 +0,0 @@
-# v0.1.0
-# { "Depends": "py-genlayer:test" }
-
-from genlayer import *
-
-
-class Registry(gl.Contract):
-    # Declare persistent storage fields
-    contract_addresses: DynArray[str]
-    intelligent_oracle_code: str
-
-    def __init__(self, intelligent_oracle_code: str):
-        self.intelligent_oracle_code = intelligent_oracle_code
-
-    @gl.public.write
-    def create_new_prediction_market(
-        self,
-        prediction_market_id: str,
-        title: str,
-        description: str,
-        potential_outcomes: list[str],
-        rules: list[str],
-        data_source_domains: list[str],
-        resolution_urls: list[str],
-        earliest_resolution_date: str,
-    ) -> None:
-        registered_contracts = len(self.contract_addresses)
-        contract_address = gl.deploy_contract(
-            code=self.intelligent_oracle_code.encode("utf-8"),
-            args=[
-                prediction_market_id,
-                title,
-                description,
-                potential_outcomes,
-                rules,
-                data_source_domains,
-                resolution_urls,
-                earliest_resolution_date,
-            ],
-            salt_nonce=registered_contracts + 1,
-            on="accepted",
-        )
-        print("contract_address", contract_address)
-        print("contract_address type", type(contract_address))
-        self.contract_addresses.append(contract_address.as_hex)
-
-    @gl.public.view
-    def get_contract_addresses(self) -> list[str]:
-        return list(self.contract_addresses)

tests/examples/contracts/invalid_deploy.py

@@ -1,10 +0,0 @@
-# { "Depends": "py-genlayer:test" }
-
-import genlayer as gl
-
-
-class InvalidDeploy(gl.Contract):
-    """Contract that always fails during deployment"""
-
-    def __init__(self):
-        raise Exception("This is an invalid deploy")

tests/examples/contracts/llm_erc20.py

@@ -1,70 +0,0 @@
-# v0.1.0
-# { "Depends": "py-genlayer:latest" }
-
-import json
-
-from genlayer import *
-
-
-class LlmErc20(gl.Contract):
-    balances: TreeMap[Address, u256]
-
-    def __init__(self, total_supply: int) -> None:
-        self.balances[gl.message.sender_address] = u256(total_supply)
-
-    @gl.public.write
-    def transfer(self, amount: int, to_address: str) -> None:
-        input = f"""
-You keep track of transactions between users and their balance in coins.
-The current balance for all users in JSON format is:
-{json.dumps(self.get_balances())}
-The transaction to compute is: {{
-sender: "{gl.message.sender_address.as_hex}",
-recipient: "{Address(to_address).as_hex}",
-amount: {amount},
-}}
-
-"""
-        task = """For every transaction, validate that the user sending the Coins has
-enough balance. If any transaction is invalid, it shouldn't be processed.
-Update the balances based on the valid transactions only.
-Given the current balance in JSON format and the transaction provided,
-please provide the result of your calculation with the following format:
-{{
-"transaction_success": bool,          // Whether the transaction was successful
-"transaction_error": str,             // Empty if transaction is successful
-"updated_balances": object<str, int>  // Updated balances after the transaction
-}}
-
-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 parsable by a JSON parser without errors.
-"""
-
-        criteria = """
-The balance of the sender should have decreased by the amount sent.
-The balance of the receiver should have increased by the amount sent.
-The total sum of all balances should remain the same before and after the transaction"""
-
-        final_result = (
-            gl.eq_principle.prompt_non_comparative(
-                lambda: input,
-                task=task,
-                criteria=criteria,
-            )
-            .replace("```json", "")
-            .replace("```", "")
-        )
-        print("final_result: ", final_result)
-        result_json = json.loads(final_result)
-        for k, v in result_json["updated_balances"].items():
-            self.balances[Address(k)] = v
-
-    @gl.public.view
-    def get_balances(self) -> dict[str, int]:
-        return {k.as_hex: v for k, v in self.balances.items()}
-
-    @gl.public.view
-    def get_balance_of(self, address: str) -> int:
-        return self.balances.get(Address(address), 0)

tests/examples/contracts/log_indexer.py

@@ -1,69 +0,0 @@
-# v0.1.0
-# {
-#   "Seq": [
-#     { "Depends": "py-lib-genlayer-embeddings:09h0i209wrzh4xzq86f79c60x0ifs7xcjwl53ysrnw06i54ddxyi" },
-#     { "Depends": "py-genlayer:latest" }
-#   ]
-# }
-
-import numpy as np
-from genlayer import *
-import genlayer_embeddings as gle
-
-from dataclasses import dataclass
-import typing
-
-
-@allow_storage
-@dataclass
-class StoreValue:
-    log_id: u256
-    text: str
-
-
-# contract class
-class LogIndexer(gl.Contract):
-    vector_store: gle.VecDB[np.float32, typing.Literal[384], StoreValue]
-
-    def __init__(self):
-        pass
-
-    def get_embedding_generator(self):
-        return gle.SentenceTransformer("all-MiniLM-L6-v2")
-
-    def get_embedding(
-        self, txt: str
-    ) -> np.ndarray[tuple[typing.Literal[384]], np.dtypes.Float32DType]:
-        return self.get_embedding_generator()(txt)
-
-    @gl.public.view
-    def get_closest_vector(self, text: str) -> dict | None:
-        emb = self.get_embedding(text)
-        result = list(self.vector_store.knn(emb, 1))
-        if len(result) == 0:
-            return None
-        result = result[0]
-        return {
-            "vector": list(str(x) for x in result.key),
-            "similarity": str(1 - result.distance),
-            "id": result.value.log_id,
-            "text": result.value.text,
-        }
-
-    @gl.public.write
-    def add_log(self, log: str, log_id: int) -> None:
-        emb = self.get_embedding(log)
-        self.vector_store.insert(emb, StoreValue(text=log, log_id=u256(log_id)))
-
-    @gl.public.write
-    def update_log(self, log_id: int, log: str) -> None:
-        emb = self.get_embedding(log)
-        for elem in self.vector_store.knn(emb, 2):
-            if elem.value.text == log:
-                elem.value.log_id = u256(log_id)
-
-    @gl.public.write
-    def remove_log(self, id: int) -> None:
-        for el in self.vector_store:
-            if el.value.log_id == id:
-                el.remove()

tests/examples/contracts/multi_file_contract/__init__.py

@@ -1,24 +0,0 @@
-from genlayer import *
-
-
-class MultiFileContract(gl.Contract):
-    other_addr: Address
-
-    def __init__(self):
-        with open("/contract/other.py", "rt") as f:
-            text = f.read()
-        self.other_addr = gl.deploy_contract(
-            code=text.encode("utf-8"),
-            args=["123"],
-            salt_nonce=u256(1),
-            value=u256(0),
-            on="accepted",
-        )
-
-    @gl.public.write
-    def wait(self) -> None:
-        pass
-
-    @gl.public.view
-    def test(self) -> str:
-        return gl.get_contract_at(self.other_addr).view().test()

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
-        )