prediction-market-agent-tooling 0.64.11.dev653__tar.gz → 0.64.12__tar.gz

{prediction_market_agent_tooling-0.64.11.dev653 → prediction_market_agent_tooling-0.64.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prediction-market-agent-tooling
-Version: 0.64.11.dev653
+Version: 0.64.12
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.13

prediction_market_agent_tooling-0.64.12/prediction_market_agent_tooling/chains.py

@@ -0,0 +1,4 @@
+from prediction_market_agent_tooling.gtypes import ChainID
+
+ETHEREUM_ID = ChainID(1)
+GNOSIS_CHAIN_ID = ChainID(100)

{prediction_market_agent_tooling-0.64.11.dev653 → prediction_market_agent_tooling-0.64.12}/prediction_market_agent_tooling/config.py

@@ -12,6 +12,7 @@ from safe_eth.eth import EthereumClient
 from safe_eth.safe.safe import SafeV141
 from web3 import Account, Web3
 
+from prediction_market_agent_tooling.chains import ETHEREUM_ID, GNOSIS_CHAIN_ID
 from prediction_market_agent_tooling.deploy.gcp.utils import gcp_get_secret_value
 from prediction_market_agent_tooling.gtypes import (
     ChainID,
@@ -278,9 +279,9 @@ class RPCConfig(BaseSettings):
         env_file=".env", env_file_encoding="utf-8", extra="ignore"
     )
 
-    ETHEREUM_RPC_URL: URI = Field(default=URI("https://ethereum-rpc.publicnode.com"))
-    GNOSIS_RPC_URL: URI = Field(default=URI("https://rpc.gnosischain.com"))
-    CHAIN_ID: ChainID = Field(default=ChainID(100))
+    ETHEREUM_RPC_URL: URI = Field(default=URI("https://rpc.eth.gateway.fm"))
+    GNOSIS_RPC_URL: URI = Field(default=URI("https://rpc.gnosis.gateway.fm"))
+    CHAIN_ID: ChainID = Field(default=GNOSIS_CHAIN_ID)
 
     @property
     def ethereum_rpc_url(self) -> URI:
@@ -299,9 +300,9 @@ class RPCConfig(BaseSettings):
         return check_not_none(self.CHAIN_ID, "CHAIN_ID missing in the environment.")
 
     def chain_id_to_rpc_url(self, chain_id: ChainID) -> URI:
-        if chain_id == ChainID(1):
+        if chain_id == ETHEREUM_ID:
             return self.ethereum_rpc_url
-        elif chain_id == ChainID(100):
+        elif chain_id == GNOSIS_CHAIN_ID:
             return self.gnosis_rpc_url
         else:
             raise ValueError(f"Unsupported chain ID: {chain_id}")

prediction_market_agent_tooling-0.64.12/prediction_market_agent_tooling/logprobs_parser.py

@@ -0,0 +1,155 @@
+import math
+from itertools import product
+from typing import Any, Tuple, Type
+
+from pydantic import BaseModel, ValidationError
+from pydantic.fields import FieldInfo
+from pydantic.type_adapter import TypeAdapter
+
+from prediction_market_agent_tooling.loggers import logger
+
+
+class LogprobDetail(BaseModel):
+    token: str
+    logprob: float
+    prob: float
+
+
+class FieldLogprobs(BaseModel):
+    key: str
+    logprobs: list[LogprobDetail]
+
+
+class LogprobsParser:
+    def __init__(
+        self,
+        skip_fields: list[str] | None = None,
+        max_top_logprobs_length: int = 3,
+        max_logprobs_length: int = 5,
+    ):
+        base_skip_fields = ["logprobs"]
+        self.skip_fields = base_skip_fields + (skip_fields or [])
+        self.max_top_logprobs_length = max_top_logprobs_length
+        self.max_logprobs_length = max_logprobs_length
+
+    def _get_logprobs_key_index(
+        self, logprobs: list[dict[str, Any]], field_name: str
+    ) -> int:
+        key_candidate = ""
+        for i, token in enumerate(logprobs):
+            if token["token"] in field_name:
+                key_candidate = key_candidate + token["token"]
+            else:
+                key_candidate = ""
+            if key_candidate == field_name:
+                return i
+
+        return -1
+
+    def _get_logprobs_indexes_for_result(
+        self, logprobs: list[dict[str, Any]], key_index: int
+    ) -> Tuple[int, int]:
+        result_start_index = next(
+            (
+                i
+                for i in range(key_index + 1, len(logprobs))
+                if logprobs[i]["token"] in {":", ",", " ", ' "', '"', "\t", "\u00A0"}
+            ),
+            -1,
+        )
+        result_end_index = next(
+            (
+                i
+                for i in range(result_start_index, len(logprobs))
+                if logprobs[i]["token"] in {",", '"', ",\n", "\",\n'", '",\n'}
+            ),
+            len(logprobs) - 1,
+        )
+        return result_start_index + 1, result_end_index
+
+    def _is_correct_type(self, token: str, key_type: type | None) -> bool:
+        if key_type is None:
+            return True
+
+        try:
+            TypeAdapter(key_type).validate_python(token)
+            return True
+        except ValidationError:
+            return False
+
+    def _parse_valid_tokens_with__agg_probs(
+        self,
+        logprobs_list: list[tuple[dict[str, Any]]],
+        field_info: FieldInfo,
+        top_logprobs: int,
+    ) -> list[dict[str, Any]]:
+        results: list[dict[str, Any]] = [
+            {
+                "token": "".join(str(logprob["token"]) for logprob in logprobs),
+                "logprob": sum(float(logprob["logprob"]) for logprob in logprobs),
+                "prob": math.exp(
+                    sum(float(logprob["logprob"]) for logprob in logprobs)
+                ),
+            }
+            for logprobs in logprobs_list
+        ]
+
+        results_filtered: list[dict[str, Any]] = [
+            result
+            for result in results
+            if self._is_correct_type(result["token"], field_info.annotation)
+        ]
+
+        sorted_results = sorted(
+            results_filtered, key=lambda x: x["logprob"], reverse=True
+        )
+        return (
+            sorted_results[:top_logprobs]
+            if len(sorted_results) > top_logprobs
+            else sorted_results
+        )
+
+    def parse_logprobs(
+        self, logprobs: list[dict[str, Any]], target_model_cls: Type[BaseModel]
+    ) -> list[FieldLogprobs]:
+        results_for_keys = []
+
+        for field_name, field_info in target_model_cls.model_fields.items():
+            if field_name in self.skip_fields:
+                continue
+
+            key_index = self._get_logprobs_key_index(logprobs, field_name)
+
+            if key_index < 0:
+                logger.warning(f"Key {field_name} not found in logprobs")
+                continue
+
+            (
+                result_start_index,
+                result_end_index,
+            ) = self._get_logprobs_indexes_for_result(logprobs, key_index)
+
+            if result_start_index < 0 or result_end_index < 0:
+                logger.warning(f"Error in parsing result for {field_name} in logprobs")
+                continue
+
+            valid_logprobs_raw = [
+                logprobs[i]["top_logprobs"][: self.max_top_logprobs_length]
+                for i in range(result_start_index, result_end_index)
+                if logprobs[i]["top_logprobs"] is not None
+            ]
+
+            parsed_logprobs_data = self._parse_valid_tokens_with__agg_probs(
+                list(product(*valid_logprobs_raw[: self.max_logprobs_length])),
+                field_info,
+                min(len(sublist) for sublist in valid_logprobs_raw),
+            )
+
+            results_for_keys.append(
+                FieldLogprobs(
+                    key=field_name,
+                    logprobs=[LogprobDetail(**item) for item in parsed_logprobs_data],
+                )
+            )
+
+        return results_for_keys

{prediction_market_agent_tooling-0.64.11.dev653 → prediction_market_agent_tooling-0.64.12}/prediction_market_agent_tooling/markets/data_models.py

@@ -10,6 +10,7 @@ from prediction_market_agent_tooling.gtypes import (
     OutcomeToken,
     Probability,
 )
+from prediction_market_agent_tooling.logprobs_parser import FieldLogprobs
 from prediction_market_agent_tooling.tools.utils import DatetimeUTC
 
 
@@ -77,6 +78,7 @@ class ProbabilisticAnswer(BaseModel):
     p_yes: Probability
     confidence: float
     reasoning: str | None = None
+    logprobs: list[FieldLogprobs] | None = None
 
     @property
     def p_no(self) -> Probability:

{prediction_market_agent_tooling-0.64.11.dev653 → prediction_market_agent_tooling-0.64.12}/prediction_market_agent_tooling/markets/omen/omen.py

@@ -90,7 +90,7 @@ from prediction_market_agent_tooling.tools.web3_utils import get_receipt_block_t
 
 OMEN_DEFAULT_REALITIO_BOND_VALUE = xDai(0.01)
 # Too low value would work with the Omen contract, but causes CoW orders (when buying the specific market's tokens) to fail.
-OMEN_TINY_BET_AMOUNT = USD(0.001)
+OMEN_TINY_BET_AMOUNT = USD(0.01)
 
 
 class OmenAgentMarket(AgentMarket):

{prediction_market_agent_tooling-0.64.11.dev653 → prediction_market_agent_tooling-0.64.12}/prediction_market_agent_tooling/markets/omen/omen_contracts.py

@@ -431,6 +431,12 @@ class OmenFixedProductMarketMakerContract(ContractOnGnosisChain):
         )
 
 
+class MetriSuperGroup(ContractERC20OnGnosisChain):
+    address: ChecksumAddress = Web3.to_checksum_address(
+        "0x7147A7405fCFe5CFa30c6d5363f9f357a317d082"
+    )
+
+
 class GNOContract(ContractERC20OnGnosisChain):
     address: ChecksumAddress = Web3.to_checksum_address(
         "0x9c58bacc331c9aa871afd802db6379a98e80cedb"
@@ -923,10 +929,12 @@ class CollateralTokenChoice(str, Enum):
     wxdai = "wxdai"
     sdai = "sdai"
     gno = "gno"
+    metri_super_user = "metri_super_user"
 
 
 COLLATERAL_TOKEN_CHOICE_TO_ADDRESS = {
     CollateralTokenChoice.wxdai: WrappedxDaiContract().address,
     CollateralTokenChoice.sdai: sDaiContract().address,
     CollateralTokenChoice.gno: GNOContract().address,
+    CollateralTokenChoice.metri_super_user: MetriSuperGroup().address,
 }

{prediction_market_agent_tooling-0.64.11.dev653 → prediction_market_agent_tooling-0.64.12}/prediction_market_agent_tooling/tools/contract.py

@@ -4,6 +4,8 @@ import time
 import typing as t
 from contextlib import contextmanager
 
+import eth_abi
+from eth_abi.exceptions import DecodingError
 from pydantic import BaseModel, field_validator
 from web3 import Web3
 from web3.constants import CHECKSUM_ADDRESSS_ZERO
@@ -20,6 +22,7 @@ from prediction_market_agent_tooling.gtypes import (
     TxReceipt,
     Wei,
 )
+from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.tools.utils import DatetimeUTC
 from prediction_market_agent_tooling.tools.web3_utils import (
     call_function_on_contract,
@@ -591,27 +594,64 @@ def contract_implements_function(
     look_for_proxy_contract: bool = True,
 ) -> bool:
     function_signature = f"{function_name}({','.join(function_arg_types or [])})"
-    function_hash = web3.keccak(text=function_signature)[0:4].hex()[2:]
+    function_selector = web3.keccak(text=function_signature)[0:4].hex()[2:]
+    # 1. Check directly in bytecode
+    bytecode = web3.eth.get_code(contract_address).hex()
+    if function_selector in bytecode:
+        return True
     contract_code = web3.eth.get_code(contract_address).hex()
-    implements = function_hash in contract_code
-    if (
-        not implements
-        and look_for_proxy_contract
-        and contract_implements_function(
+    implements = function_selector in contract_code
+
+    # If not found directly and we should check proxies
+    if not implements and look_for_proxy_contract:
+        # Case 1: Check if it's a standard proxy (has implementation() function)
+        if contract_implements_function(
             contract_address, "implementation", web3, look_for_proxy_contract=False
-        )
-    ):
-        implementation_address = ContractProxyOnGnosisChain(
-            address=contract_address
-        ).implementation()
-        implements = contract_implements_function(
-            implementation_address,
+        ):
+            # Get the implementation address and check the function there
+            implementation_address = ContractProxyOnGnosisChain(
+                address=contract_address
+            ).implementation()
+            implements = contract_implements_function(
+                implementation_address,
+                function_name=function_name,
+                web3=web3,
+                function_arg_types=function_arg_types,
+                look_for_proxy_contract=False,
+            )
+        else:
+            # Case 2: Check if it's a minimal proxy contract
+            implements = minimal_proxy_implements_function(
+                contract_address=contract_address,
+                function_name=function_name,
+                web3=web3,
+                function_arg_types=function_arg_types,
+            )
+
+    return implements
+
+
+def minimal_proxy_implements_function(
+    contract_address: ChecksumAddress,
+    function_name: str,
+    web3: Web3,
+    function_arg_types: list[str] | None = None,
+) -> bool:
+    try:
+        # Read storage slot 0 which should contain the implementation address in minimal proxies
+        raw_slot_0 = web3.eth.get_storage_at(contract_address, 0)
+        singleton_address = eth_abi.decode(["address"], raw_slot_0)[0]
+        # Recurse into singleton
+        return contract_implements_function(
+            Web3.to_checksum_address(singleton_address),
             function_name=function_name,
             web3=web3,
             function_arg_types=function_arg_types,
             look_for_proxy_contract=False,
         )
-    return implements
+    except DecodingError:
+        logger.info(f"Error decoding contract address for singleton")
+        return False
 
 
 def init_collateral_token_contract(

{prediction_market_agent_tooling-0.64.11.dev653 → prediction_market_agent_tooling-0.64.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "prediction-market-agent-tooling"
-version = "0.64.11.dev653"
+version = "0.64.12"
 description = "Tools to benchmark, deploy and monitor prediction market agents."
 authors = ["Gnosis"]
 readme = "README.md"

prediction_market_agent_tooling-0.64.11.dev653/prediction_market_agent_tooling/logprobs_parser.py

@@ -1,117 +0,0 @@
-import math
-from itertools import product
-from typing import Any, Tuple
-
-from pydantic import BaseModel
-
-from prediction_market_agent_tooling.loggers import logger
-
-
-class LogprobKey(BaseModel):
-    name: str
-    key_type: type
-    valid_values: set[Any] | None
-
-
-class LogprobsParser:
-    def _get_logprobs_key_index(
-        self, logprobs: list[dict[str, Any]], key: LogprobKey
-    ) -> int:
-        key_candidate = ""
-        for i, token in enumerate(logprobs):
-            if token["token"] in key.name:
-                key_candidate = key_candidate + token["token"]
-            else:
-                key_candidate = ""
-            if key_candidate == key.name:
-                return i
-
-        return -1
-
-    def _get_logprobs_indexes_for_result(
-        self, logprobs: list[dict[str, Any]], key_index: int
-    ) -> Tuple[int, int]:
-        result_start_index = next(
-            (
-                i
-                for i in range(key_index + 1, len(logprobs))
-                if logprobs[i]["token"] in {":", ",", " ", ' "', '"', "\t", "\u00A0"}
-            ),
-            -1,
-        )
-        result_end_index = next(
-            (
-                i
-                for i in range(result_start_index, len(logprobs))
-                if logprobs[i]["token"] in {",", '"', ",\n", "\",\n'", '",\n'}
-            ),
-            -1,
-        )
-        return result_start_index + 1, result_end_index
-
-    def _is_correct_type(self, token: str, key_type: type) -> bool:
-        try:
-            key_type(token)
-            return True
-        except ValueError:
-            return False
-
-    def _parse_valid_tokens_with__agg_probs(
-        self, logprobs_list: list[tuple[dict[str, Any]]], key: LogprobKey
-    ) -> list[dict[str, Any]]:
-        results: list[dict[str, Any]] = [
-            {
-                "token": "".join(str(logprob["token"]) for logprob in logprobs),
-                "logprob": sum(float(logprob["logprob"]) for logprob in logprobs),
-                "prob": math.exp(
-                    sum(float(logprob["logprob"]) for logprob in logprobs)
-                ),
-            }
-            for logprobs in logprobs_list
-        ]
-
-        results_filtered: list[dict[str, Any]] = [
-            result
-            for result in results
-            if self._is_correct_type(result["token"], key.key_type)
-            and (key.valid_values is None or result["token"] in key.valid_values)
-        ]
-
-        return sorted(results_filtered, key=lambda x: x["logprob"], reverse=True)[
-            : len(logprobs_list[0])
-        ]
-
-    def parse_logprobs(
-        self, logprobs: list[dict[str, Any]], keys: list[LogprobKey]
-    ) -> list[dict[str, Any]]:
-        results_for_keys = []
-
-        for key in keys:
-            key_index = self._get_logprobs_key_index(logprobs, key)
-            if key_index < 0:
-                logger.warning(f"Key {key.name} not found in logprobs")
-                continue
-
-            (
-                result_start_index,
-                result_end_index,
-            ) = self._get_logprobs_indexes_for_result(logprobs, key_index)
-            if result_start_index < 0 or result_end_index < 0:
-                logger.warning(f"Error in parsing result for {key.name} in logprobs")
-                continue
-
-            valid_logprobs = [
-                logprobs[i]["top_logprobs"]
-                for i in range(result_start_index, result_end_index)
-            ]
-
-            results_for_keys.append(
-                {
-                    "key": key.name,
-                    "logprobs": self._parse_valid_tokens_with__agg_probs(
-                        list(product(*valid_logprobs)), key
-                    ),
-                }
-            )
-
-        return results_for_keys