prediction-market-agent-tooling 0.43.1__py3-none-any.whl → 0.43.4__py3-none-any.whl

prediction_market_agent_tooling/markets/polymarket/data_models_web.py

@@ -34,7 +34,7 @@ class Event(BaseModel):
     slug: str
     ticker: str
     title: str
-    series: str | None
+    series: t.Any | None = None
 
 
 class Event1(BaseModel):
@@ -46,7 +46,7 @@ class Market1(BaseModel):
     slug: str
     question: str
     image: str
-    volume: USDC | None
+    volume: USDC | None = None
     outcomes: list[str]
     outcomePrices: list[USDC]
     active: bool
@@ -54,7 +54,7 @@ class Market1(BaseModel):
     closed: bool
     orderPriceMinTickSize: USDC
     clobTokenIds: str
-    events: list[Event1]
+    events: list[Event1] | None = None
 
 
 class ResolutionData(BaseModel):
@@ -77,98 +77,98 @@ class Market(BaseModel):
     question: str
     conditionId: str
     slug: str
-    twitterCardImage: t.Any | None
+    twitterCardImage: t.Any | None = None
     resolutionSource: str
     endDate: datetime
-    category: t.Any | None
-    ammType: t.Any | None
+    category: t.Any | None = None
+    ammType: t.Any | None = None
     description: str
-    liquidity: str | None
+    liquidity: str | None = None
     startDate: datetime
     createdAt: datetime
-    xAxisValue: t.Any | None
-    yAxisValue: t.Any | None
-    denominationToken: t.Any | None
-    fee: str | None
-    lowerBound: t.Any | None
-    upperBound: t.Any | None
+    xAxisValue: t.Any | None = None
+    yAxisValue: t.Any | None = None
+    denominationToken: t.Any | None = None
+    fee: str | None = None
+    lowerBound: t.Any | None = None
+    upperBound: t.Any | None = None
     outcomes: list[str]
     image: str
     icon: str
-    imageOptimized: t.Any | None
-    iconOptimized: t.Any | None
+    imageOptimized: t.Any | None = None
+    iconOptimized: t.Any | None = None
     outcomePrices: list[USDC]
-    volume: USDC | None
+    volume: USDC | None = None
     active: bool
-    marketType: str | None
-    formatType: t.Any | None
-    lowerBoundDate: t.Any | None
-    upperBoundDate: t.Any | None
+    marketType: str | None = None
+    formatType: t.Any | None = None
+    lowerBoundDate: t.Any | None = None
+    upperBoundDate: t.Any | None = None
     closed: bool
     marketMakerAddress: HexAddress
-    closedTime: datetime | None
-    wideFormat: bool | None
+    closedTime: datetime | None = None
+    wideFormat: bool | None = None
     new: bool
-    sentDiscord: t.Any | None
-    mailchimpTag: t.Any | None
+    sentDiscord: t.Any | None = None
+    mailchimpTag: t.Any | None = None
     featured: bool
     submitted_by: str
-    subcategory: t.Any | None
-    categoryMailchimpTag: t.Any | None
+    subcategory: t.Any | None = None
+    categoryMailchimpTag: t.Any | None = None
     archived: bool
     resolvedBy: str
     restricted: bool
     groupItemTitle: str
     groupItemThreshold: str
     questionID: str
-    umaEndDate: t.Any | None
+    umaEndDate: t.Any | None = None
     enableOrderBook: bool
     orderPriceMinTickSize: float
     orderMinSize: int
-    umaResolutionStatus: t.Any | None
-    curationOrder: t.Any | None
-    volumeNum: USDC | None
-    liquidityNum: float | None
-    endDateIso: datetime | None
-    startDateIso: datetime | None
-    umaEndDateIso: datetime | None
-    commentsEnabled: bool | None
-    disqusThread: t.Any | None
-    gameStartTime: datetime | None
-    secondsDelay: int | None
+    umaResolutionStatus: t.Any | None = None
+    curationOrder: t.Any | None = None
+    volumeNum: USDC | None = None
+    liquidityNum: float | None = None
+    endDateIso: datetime | None = None
+    startDateIso: datetime | None = None
+    umaEndDateIso: datetime | None = None
+    commentsEnabled: bool | None = None
+    disqusThread: t.Any | None = None
+    gameStartTime: datetime | None = None
+    secondsDelay: int | None = None
     clobTokenIds: list[str]
-    liquidityAmm: float | None
-    liquidityClob: float | None
-    makerBaseFee: int | None
-    takerBaseFee: int | None
-    negRisk: t.Any | None
-    negRiskRequestID: t.Any | None
-    negRiskMarketID: t.Any | None
+    liquidityAmm: float | None = None
+    liquidityClob: float | None = None
+    makerBaseFee: int | None = None
+    takerBaseFee: int | None = None
+    negRisk: t.Any | None = None
+    negRiskRequestID: t.Any | None = None
+    negRiskMarketID: t.Any | None = None
     events: list[Event]
     markets: list[Market1]
-    lower_bound_date: t.Any | None
-    upper_bound_date: t.Any | None
-    market_type: str | None
+    lower_bound_date: t.Any | None = None
+    upper_bound_date: t.Any | None = None
+    market_type: str | None = None
     resolution_source: str
     end_date: str
-    amm_type: t.Any | None
-    x_axis_value: t.Any | None
-    y_axis_value: t.Any | None
-    denomination_token: t.Any | None
+    amm_type: t.Any | None = None
+    x_axis_value: t.Any | None = None
+    y_axis_value: t.Any | None = None
+    denomination_token: t.Any | None = None
     resolved_by: str
-    upper_bound: t.Any | None
-    lower_bound: t.Any | None
+    upper_bound: t.Any | None = None
+    lower_bound: t.Any | None = None
     created_at: str
-    updated_at: t.Any | None
-    closed_time: t.Any | None
-    wide_format: bool | None
-    volume_num: USDC | None
-    liquidity_num: USDC | None
+    updated_at: t.Any | None = None
+    closed_time: t.Any | None = None
+    wide_format: bool | None = None
+    volume_num: USDC | None = None
+    liquidity_num: USDC | None = None
     image_raw: str
     resolutionData: ResolutionData
 
     @field_validator("closedTime", mode="before")
-    def field_validator_closedTime(cls, v: str | None) -> str | None:
+    def field_validator_closedTime(cls, v: str | None = None) -> str | None:
         return v.replace("+00", "") if v else None
 
     @property
@@ -232,7 +232,7 @@ class PolymarketFullMarket(BaseModel):
     ticker: str
     slug: str
     title: str
-    subtitle: t.Any | None
+    subtitle: t.Any | None = None
     description: str
     commentCount: int
     resolutionSource: str
@@ -240,35 +240,35 @@ class PolymarketFullMarket(BaseModel):
     endDate: datetime
     image: str
     icon: str
-    featuredImage: str | None
+    featuredImage: str | None = None
     active: bool
     closed: bool
     archived: bool
     new: bool
     featured: bool
     restricted: bool
-    liquidity: USDC | None
-    volume: USDC | None
-    volume24hr: USDC | None
-    competitive: float | None
-    openInterest: int | None
-    sortBy: str | None
+    liquidity: USDC | None = None
+    volume: USDC | None = None
+    volume24hr: USDC | None = None
+    competitive: float | None = None
+    openInterest: int | None = None
+    sortBy: str | None = None
     createdAt: datetime
-    commentsEnabled: bool | None
-    disqusThread: t.Any | None
+    commentsEnabled: bool | None = None
+    disqusThread: t.Any | None = None
     updatedAt: datetime
     enableOrderBook: bool
-    liquidityAmm: float | None
-    liquidityClob: float | None
-    imageOptimized: ImageOptimized | None
-    iconOptimized: IconOptimized | None
-    featuredImageOptimized: str | None
-    negRisk: t.Any | None
-    negRiskMarketID: t.Any | None
-    negRiskFeeBips: t.Any | None
+    liquidityAmm: float | None = None
+    liquidityClob: float | None = None
+    imageOptimized: ImageOptimized | None = None
+    iconOptimized: IconOptimized | None = None
+    featuredImageOptimized: str | None = None
+    negRisk: t.Any | None = None
+    negRiskMarketID: t.Any | None = None
+    negRiskFeeBips: t.Any | None = None
     markets: list[Market]
     categories: list[Category] | None = None
-    series: t.Any | None
+    series: t.Any | None = None
     image_raw: str
 
     @property
@@ -355,12 +355,12 @@ class State(BaseModel):
     )  # It's none if you go to the website and it says "Oops...we didn't forecast this".
     dataUpdateCount: int
     dataUpdatedAt: int
-    error: t.Any | None
+    error: t.Any | None = None
     errorUpdateCount: int
     errorUpdatedAt: int
     fetchFailureCount: int
-    fetchFailureReason: t.Any | None
-    fetchMeta: t.Any | None
+    fetchFailureReason: t.Any | None = None
+    fetchMeta: t.Any | None = None
     isInvalidated: bool
     status: str
     fetchStatus: str
@@ -381,7 +381,7 @@ class PageProps(BaseModel):
     key: str
     dehydratedState: DehydratedState
     eslug: str
-    mslug: str | None
+    mslug: str | None = None
     isSingleMarket: bool
 
 

prediction_market_agent_tooling/markets/polymarket/polymarket.py

@@ -41,7 +41,8 @@ class PolymarketAgentMarket(AgentMarket):
             volume=None,
         )
 
-    def get_tiny_bet_amount(self) -> BetAmount:
+    @classmethod
+    def get_tiny_bet_amount(cls) -> BetAmount:
         raise NotImplementedError("TODO: Implement to allow betting on Polymarket.")
 
     def place_bet(self, outcome: bool, amount: BetAmount) -> None:

prediction_market_agent_tooling/tools/contract.py

@@ -1,4 +1,5 @@
 import json
+import os
 import time
 import typing as t
 from contextlib import contextmanager
@@ -151,11 +152,33 @@ class ContractBaseClass(BaseModel):
         return Web3(Web3.HTTPProvider(cls.CHAIN_RPC_URL))
 
 
+class ContractProxyBaseClass(ContractBaseClass):
+    """
+    Contract base class for proxy contracts.
+    """
+
+    abi: ABI = abi_field_validator(
+        os.path.join(
+            os.path.dirname(os.path.realpath(__file__)), "../abis/proxy.abi.json"
+        )
+    )
+
+    def implementation(self, web3: Web3 | None = None) -> ChecksumAddress:
+        address = self.call("implementation", web3=web3)
+        return Web3.to_checksum_address(address)
+
+
 class ContractERC20BaseClass(ContractBaseClass):
     """
     Contract base class extended by ERC-20 standard methods.
     """
 
+    abi: ABI = abi_field_validator(
+        os.path.join(
+            os.path.dirname(os.path.realpath(__file__)), "../abis/erc20.abi.json"
+        )
+    )
+
     def approve(
         self,
         api_keys: APIKeys,
@@ -175,6 +198,41 @@ class ContractERC20BaseClass(ContractBaseClass):
             web3=web3,
         )
 
+    def transferFrom(
+        self,
+        api_keys: APIKeys,
+        sender: ChecksumAddress,
+        recipient: ChecksumAddress,
+        amount_wei: Wei,
+        tx_params: t.Optional[TxParams] = None,
+        web3: Web3 | None = None,
+    ) -> TxReceipt:
+        return self.send(
+            api_keys=api_keys,
+            function_name="transferFrom",
+            function_params=[sender, recipient, amount_wei],
+            tx_params=tx_params,
+            web3=web3,
+        )
+
+    def balanceOf(self, for_address: ChecksumAddress, web3: Web3 | None = None) -> Wei:
+        balance: Wei = self.call("balanceOf", [for_address], web3=web3)
+        return balance
+
+
+class ContractDepositableWrapperERC20BaseClass(ContractERC20BaseClass):
+    """
+    ERC-20 standard base class extended for wrapper tokens.
+    Altough this is not a standard, it's seems to be a common pattern for wrapped tokens (at least it checks out for wxDai and wETH).
+    """
+
+    abi: ABI = abi_field_validator(
+        os.path.join(
+            os.path.dirname(os.path.realpath(__file__)),
+            "../abis/depositablewrapper_erc20.abi.json",
+        )
+    )
+
     def deposit(
         self,
         api_keys: APIKeys,
@@ -190,41 +248,93 @@ class ContractERC20BaseClass(ContractBaseClass):
             web3=web3,
         )
 
-    def transferFrom(
+    def withdraw(
         self,
         api_keys: APIKeys,
-        sender: ChecksumAddress,
-        recipient: ChecksumAddress,
         amount_wei: Wei,
         tx_params: t.Optional[TxParams] = None,
         web3: Web3 | None = None,
     ) -> TxReceipt:
         return self.send(
             api_keys=api_keys,
-            function_name="transferFrom",
-            function_params=[sender, recipient, amount_wei],
+            function_name="withdraw",
+            function_params=[amount_wei],
             tx_params=tx_params,
             web3=web3,
         )
 
-    def withdraw(
+
+class ContractERC4626BaseClass(ContractERC20BaseClass):
+    """
+    Class for ERC-4626, which is a superset for ERC-20.
+    """
+
+    abi: ABI = abi_field_validator(
+        os.path.join(
+            os.path.dirname(os.path.realpath(__file__)), "../abis/erc4626.abi.json"
+        )
+    )
+
+    def asset(self, web3: Web3 | None = None) -> ChecksumAddress:
+        address = self.call("asset", web3=web3)
+        return Web3.to_checksum_address(address)
+
+    def deposit(
         self,
         api_keys: APIKeys,
         amount_wei: Wei,
+        receiver: ChecksumAddress,
         tx_params: t.Optional[TxParams] = None,
         web3: Web3 | None = None,
     ) -> TxReceipt:
         return self.send(
             api_keys=api_keys,
-            function_name="withdraw",
-            function_params=[amount_wei],
+            function_name="deposit",
+            function_params=[amount_wei, receiver],
             tx_params=tx_params,
             web3=web3,
         )
 
-    def balanceOf(self, for_address: ChecksumAddress, web3: Web3 | None = None) -> Wei:
-        balance: Wei = self.call("balanceOf", [for_address], web3=web3)
-        return balance
+    def convertToShares(self, assets: Wei, web3: Web3 | None = None) -> Wei:
+        shares: Wei = self.call("convertToShares", [assets], web3=web3)
+        return shares
+
+    def convertToAssets(self, shares: Wei, web3: Web3 | None = None) -> Wei:
+        assets: Wei = self.call("convertToAssets", [shares], web3=web3)
+        return assets
+
+    def get_asset_token_contract(
+        self, web3: Web3 | None = None
+    ) -> ContractERC20BaseClass | ContractDepositableWrapperERC20BaseClass:
+        web3 = web3 or self.get_web3()
+        contract = init_erc4626_or_wrappererc20_or_erc20_contract(
+            self.asset(), web3=web3
+        )
+        assert not isinstance(
+            contract, ContractERC4626OnGnosisChain
+        ), "Asset token should be either Depositable Wrapper ERC-20 or ERC-20."  # Shrinking down possible types.
+        return contract
+
+    def get_asset_token_balance(
+        self, for_address: ChecksumAddress, web3: Web3 | None = None
+    ) -> Wei:
+        asset_token_contract = self.get_asset_token_contract(web3=web3)
+        return asset_token_contract.balanceOf(for_address, web3=web3)
+
+    def deposit_asset_token(
+        self, asset_value: Wei, api_keys: APIKeys, web3: Web3 | None = None
+    ) -> TxReceipt:
+        for_address = api_keys.bet_from_address
+        web3 = web3 or self.get_web3()
+
+        asset_token_contract = self.get_asset_token_contract(web3=web3)
+        # Approve vault to withdraw the erc-20 token from the user.
+        asset_token_contract.approve(api_keys, self.address, asset_value, web3=web3)
+
+        # Deposit asset token (erc20) and we will receive shares in this vault.
+        receipt = self.deposit(api_keys, asset_value, for_address, web3=web3)
+
+        return receipt
 
 
 class ContractOnGnosisChain(ContractBaseClass):
@@ -236,7 +346,189 @@ class ContractOnGnosisChain(ContractBaseClass):
     CHAIN_RPC_URL = GNOSIS_RPC_URL
 
 
+class ContractProxyOnGnosisChain(ContractProxyBaseClass, ContractOnGnosisChain):
+    """
+    Proxy contract base class with Gnosis Chain configuration.
+    """
+
+
 class ContractERC20OnGnosisChain(ContractERC20BaseClass, ContractOnGnosisChain):
     """
     ERC-20 standard base class with Gnosis Chain configuration.
     """
+
+
+class ContractDepositableWrapperERC20OnGnosisChain(
+    ContractDepositableWrapperERC20BaseClass, ContractOnGnosisChain
+):
+    """
+    Depositable Wrapper ERC-20 standard base class with Gnosis Chain configuration.
+    """
+
+
+class ContractERC4626OnGnosisChain(ContractERC4626BaseClass, ContractOnGnosisChain):
+    """
+    ERC-4626 standard base class with Gnosis Chain configuration.
+    """
+
+
+def contract_implements_function(
+    contract_address: ChecksumAddress,
+    function_name: str,
+    web3: Web3,
+    function_arg_types: list[str] | None = None,
+    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:]
+    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(
+            contract_address, "implementation", web3, look_for_proxy_contract=False
+        )
+    ):
+        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,
+        )
+    return implements
+
+
+def init_erc4626_or_wrappererc20_or_erc20_contract(
+    address: ChecksumAddress,
+    web3: Web3,
+) -> (
+    ContractERC20BaseClass
+    | ContractERC4626BaseClass
+    | ContractDepositableWrapperERC20BaseClass
+):
+    """
+    Checks if the given contract is Depositable ERC-20, ERC-20 or ERC-4626 and returns the appropriate class instance.
+    Throws an error if the contract is neither of them.
+    """
+    if contract_implements_function(address, "asset", web3=web3):
+        return ContractERC4626BaseClass(address=address)
+
+    elif contract_implements_function(
+        address,
+        "deposit",
+        web3=web3,
+    ):
+        return ContractDepositableWrapperERC20BaseClass(address=address)
+
+    elif contract_implements_function(
+        address,
+        "balanceOf",
+        web3=web3,
+        function_arg_types=["address"],
+    ):
+        return ContractERC20BaseClass(address=address)
+
+    else:
+        raise ValueError(
+            f"Contract at {address} on Gnosis Chain is neither WrapperERC-20, ERC-20 nor ERC-4626."
+        )
+
+
+def auto_deposit_collateral_token(
+    collateral_token_contract: (
+        ContractERC20BaseClass
+        | ContractERC4626BaseClass
+        | ContractDepositableWrapperERC20BaseClass
+    ),
+    amount_wei: Wei,
+    api_keys: APIKeys,
+    web3: Web3 | None,
+) -> None:
+    for_address = api_keys.bet_from_address
+    # This might be in shares, if it's an erc-4626 token.
+    collateral_token_balance = collateral_token_contract.balanceOf(
+        for_address=for_address, web3=web3
+    )
+
+    if isinstance(collateral_token_contract, ContractERC4626BaseClass):
+        # In the more complex case, we need to deposit into the saving token, out of the erc-20 token.
+        # We need to compare with shares, because if erc-4626 is used, the liquidity in market will be in shares as well.
+        if collateral_token_balance < collateral_token_contract.convertToShares(
+            amount_wei
+        ):
+            asset_token_contract = collateral_token_contract.get_asset_token_contract(
+                web3=web3
+            )
+
+            # If the asset token is Depositable Wrapper ERC-20, we can deposit it, in case we don't have enough.
+            if (
+                collateral_token_contract.get_asset_token_balance(for_address, web3)
+                < amount_wei
+            ):
+                if isinstance(
+                    asset_token_contract, ContractDepositableWrapperERC20BaseClass
+                ):
+                    asset_token_contract.deposit(api_keys, amount_wei, web3=web3)
+                else:
+                    raise ValueError(
+                        f"Not enough of the asset token, but it's not a depositable wrapper token that we can deposit automatically."
+                    )
+
+            collateral_token_contract.deposit_asset_token(amount_wei, api_keys, web3)
+
+    elif isinstance(
+        collateral_token_contract, ContractDepositableWrapperERC20BaseClass
+    ):
+        # If the collateral token is Depositable Wrapper ERC-20, it's a simple case where we can just deposit it, if needed.
+        if collateral_token_balance < amount_wei:
+            collateral_token_contract.deposit(api_keys, amount_wei, web3=web3)
+
+    elif isinstance(collateral_token_contract, ContractERC20BaseClass):
+        if collateral_token_balance < amount_wei:
+            raise ValueError(
+                f"Not enough of the collateral token, but it's not a wrapper token that we can deposit automatically."
+            )
+
+    else:
+        raise RuntimeError("Bug in our logic! :(")
+
+
+def asset_or_shares(
+    collateral_token_contract: (
+        ContractERC20BaseClass
+        | ContractERC4626BaseClass
+        | ContractDepositableWrapperERC20BaseClass
+    ),
+    amount_wei: Wei,
+) -> Wei:
+    return (
+        collateral_token_contract.convertToShares(amount_wei)
+        if isinstance(collateral_token_contract, ContractERC4626BaseClass)
+        else amount_wei
+    )
+
+
+def to_gnosis_chain_contract(
+    contract: (
+        ContractDepositableWrapperERC20BaseClass
+        | ContractERC4626BaseClass
+        | ContractERC20BaseClass
+    ),
+) -> (
+    ContractDepositableWrapperERC20OnGnosisChain
+    | ContractERC4626OnGnosisChain
+    | ContractERC20OnGnosisChain
+):
+    if isinstance(contract, ContractERC4626BaseClass):
+        return ContractERC4626OnGnosisChain(address=contract.address)
+    elif isinstance(contract, ContractDepositableWrapperERC20BaseClass):
+        return ContractDepositableWrapperERC20OnGnosisChain(address=contract.address)
+    elif isinstance(contract, ContractERC20BaseClass):
+        return ContractERC20OnGnosisChain(address=contract.address)
+    else:
+        raise ValueError("Unsupported contract type")

prediction_market_agent_tooling/tools/is_predictable.py

@@ -76,6 +76,7 @@ def is_predictable_binary(
     question: str,
     engine: str = "gpt-4-1106-preview",
     prompt_template: str = QUESTION_IS_PREDICTABLE_BINARY_PROMPT,
+    max_tokens: int = 1024,
 ) -> bool:
     """
     Evaluate if the question is actually answerable.
@@ -95,7 +96,7 @@ def is_predictable_binary(
 
     prompt = ChatPromptTemplate.from_template(template=prompt_template)
     messages = prompt.format_messages(question=question)
-    completion = str(llm(messages, max_tokens=512).content)
+    completion = str(llm(messages, max_tokens=max_tokens).content)
 
     return parse_decision_yes_no_completion(question, completion)
 
@@ -106,6 +107,7 @@ def is_predictable_without_description(
     description: str,
     engine: str = "gpt-4-1106-preview",
     prompt_template: str = QUESTION_IS_PREDICTABLE_WITHOUT_DESCRIPTION_PROMPT,
+    max_tokens: int = 1024,
 ) -> bool:
     """
     Evaluate if the question is fully self-contained.
@@ -130,7 +132,7 @@ def is_predictable_without_description(
         question=question,
         description=description,
     )
-    completion = str(llm(messages, max_tokens=512).content)
+    completion = str(llm(messages, max_tokens=max_tokens).content)
 
     return parse_decision_yes_no_completion(question, completion)
 

{prediction_market_agent_tooling-0.43.1.dist-info → prediction_market_agent_tooling-0.43.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prediction-market-agent-tooling
-Version: 0.43.1
+Version: 0.43.4
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.12