genlayer-test 0.1.0b6__py3-none-any.whl → 0.1.2__py3-none-any.whl

tests/examples/contracts/intelligent_oracle.py

@@ -0,0 +1,369 @@
+# { "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.get_webpage(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.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.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]:
+        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

@@ -0,0 +1,47 @@
+# { "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,
+        )
+        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/llm_erc20.py

@@ -0,0 +1,69 @@
+# { "Depends": "py-genlayer:test" }
+
+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

@@ -0,0 +1,67 @@
+# {
+#   "Seq": [
+#     { "Depends": "py-lib-genlayermodelwrappers:test" },
+#     { "Depends": "py-genlayer:test" }
+#   ]
+# }
+
+import numpy as np
+from genlayer import *
+import genlayermodelwrappers
+from dataclasses import dataclass
+import typing
+
+
+@allow_storage
+@dataclass
+class StoreValue:
+    log_id: u256
+    text: str
+
+
+# contract class
+class LogIndexer(gl.Contract):
+    vector_store: VecDB[np.float32, typing.Literal[384], StoreValue]
+
+    def __init__(self):
+        pass
+
+    def get_embedding_generator(self):
+        return genlayermodelwrappers.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

@@ -0,0 +1,20 @@
+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=1
+        )
+
+    @gl.public.write
+    def wait(self) -> None:
+        pass
+
+    @gl.public.view
+    def test(self) -> str:
+        return gl.ContractAt(self.other_addr).view().test()

tests/examples/contracts/multi_file_contract/other.py

@@ -0,0 +1,14 @@
+# { "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

@@ -0,0 +1,28 @@
+# { "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.ContractAt(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

@@ -0,0 +1,48 @@
+# { "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.ContractAt(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.ContractAt(contract_to_use).emit(gas=100000).update_storage(new_storage)

tests/examples/contracts/read_erc20.py

@@ -0,0 +1,14 @@
+# { "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.ContractAt(self.token_contract).view().get_balance_of(account_address)