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

prediction_market_agent_tooling/markets/omen/omen.py

@@ -44,7 +44,6 @@ from prediction_market_agent_tooling.markets.omen.data_models import (
 from prediction_market_agent_tooling.markets.omen.omen_contracts import (
     OMEN_DEFAULT_MARKET_FEE,
     Arbitrator,
-    ContractDepositableWrapperERC20OnGnosisChain,
     OmenConditionalTokenContract,
     OmenFixedProductMarketMakerContract,
     OmenFixedProductMarketMakerFactoryContract,
@@ -57,9 +56,10 @@ from prediction_market_agent_tooling.markets.omen.omen_subgraph_handler import (
 )
 from prediction_market_agent_tooling.tools.balances import get_balances
 from prediction_market_agent_tooling.tools.contract import (
-    asset_or_shares,
+    ContractDepositableWrapperERC20BaseClass,
+    ContractERC4626BaseClass,
     auto_deposit_collateral_token,
-    init_erc4626_or_wrappererc20_or_erc20_contract,
+    init_collateral_token_contract,
     to_gnosis_chain_contract,
 )
 from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
@@ -549,13 +549,9 @@ def omen_buy_outcome_tx(
     Bets the given amount of xDai for the given outcome in the given market.
     """
     amount_wei = xdai_to_wei(amount)
-    from_address_checksummed = api_keys.bet_from_address
 
     market_contract: OmenFixedProductMarketMakerContract = market.get_contract()
     collateral_token_contract = market_contract.get_collateral_token_contract()
-    assert isinstance(
-        collateral_token_contract, ContractDepositableWrapperERC20OnGnosisChain
-    ), "TODO: Implement for the ERC-20 and ERC-4626 case."
 
     # Get the index of the outcome we want to buy.
     outcome_index: int = market.get_outcome_index(outcome)
@@ -573,16 +569,12 @@ def omen_buy_outcome_tx(
         amount_wei=amount_wei,
         web3=web3,
     )
-    # Deposit xDai to the collateral token,
-    # this can be skipped, if we know we already have enough collateral tokens.
-    collateral_token_balance = collateral_token_contract.balanceOf(
-        for_address=from_address_checksummed, web3=web3
-    )
-    if auto_deposit and collateral_token_balance < amount_wei:
-        deposit_amount_wei = Wei(amount_wei - collateral_token_balance)
-        collateral_token_contract.deposit(
-            api_keys=api_keys, amount_wei=deposit_amount_wei, web3=web3
+
+    if auto_deposit:
+        auto_deposit_collateral_token(
+            collateral_token_contract, amount_wei, api_keys, web3
         )
+
     # Buy shares using the deposited xDai in the collateral token.
     market_contract.buy(
         api_keys=api_keys,
@@ -631,9 +623,6 @@ def omen_sell_outcome_tx(
     market_contract: OmenFixedProductMarketMakerContract = market.get_contract()
     conditional_token_contract = OmenConditionalTokenContract()
     collateral_token_contract = market_contract.get_collateral_token_contract()
-    assert isinstance(
-        collateral_token_contract, ContractDepositableWrapperERC20OnGnosisChain
-    ), "TODO: Implement for the ERC-20 and ERC-4626 case."
 
     # Verify, that markets uses conditional tokens that we expect.
     if (
@@ -669,10 +658,19 @@ def omen_sell_outcome_tx(
         max_outcome_tokens_to_sell,
         web3=web3,
     )
-    if auto_withdraw:
-        # Optionally, withdraw from the collateral token back to the `from_address` wallet.
+    if auto_withdraw and (
+        isinstance(collateral_token_contract, ContractERC4626BaseClass)
+        or isinstance(
+            collateral_token_contract, ContractDepositableWrapperERC20BaseClass
+        )
+    ):
         collateral_token_contract.withdraw(
-            api_keys=api_keys, amount_wei=amount_wei, web3=web3
+            api_keys,
+            remove_fraction(
+                amount_wei,
+                0.001,  # Allow 0.1% slippage.
+            ),
+            web3,
         )
 
 
@@ -718,7 +716,7 @@ def omen_create_market_tx(
     realitio_contract = OmenRealitioContract()
     conditional_token_contract = OmenConditionalTokenContract()
     collateral_token_contract = to_gnosis_chain_contract(
-        init_erc4626_or_wrappererc20_or_erc20_contract(collateral_token_address, web3)
+        init_collateral_token_contract(collateral_token_address, web3)
     )
     factory_contract = OmenFixedProductMarketMakerFactoryContract()
     oracle_contract = OmenOracleContract()
@@ -735,7 +733,6 @@ def omen_create_market_tx(
             "The oracle's conditional tokens address is not the same as we are using."
         )
 
-    # If auto deposit is enabled.
     if auto_deposit:
         auto_deposit_collateral_token(
             collateral_token_contract=collateral_token_contract,
@@ -772,19 +769,15 @@ def omen_create_market_tx(
             web3=web3,
         )
 
-    # Use shares as the initial funds, if the collateral is erc-4626.
-    # We need to do this, because for example for 1 xDai in erc-20 token, we could receive <1 shares in the vault,
-    # and then, providing liquidity would fail, because we would not have enough shares.
-    initial_funds_in_asset_or_shares = wei_type(
-        asset_or_shares(collateral_token_contract, initial_funds_wei)
-        * 0.999  # Allow some slippage.
+    initial_funds_in_shares = collateral_token_contract.get_in_shares(
+        amount=initial_funds_wei, web3=web3
     )
 
     # Approve the market maker to withdraw our collateral token.
     collateral_token_contract.approve(
         api_keys=api_keys,
         for_address=factory_contract.address,
-        amount_wei=initial_funds_in_asset_or_shares,
+        amount_wei=initial_funds_in_shares,
         web3=web3,
     )
 
@@ -793,7 +786,7 @@ def omen_create_market_tx(
         api_keys=api_keys,
         condition_id=condition_id,
         fee=fee,
-        initial_funds_wei=initial_funds_in_asset_or_shares,
+        initial_funds_wei=initial_funds_in_shares,
         collateral_token_address=collateral_token_contract.address,
         web3=web3,
     )
@@ -816,21 +809,11 @@ def omen_fund_market_tx(
     auto_deposit: bool,
     web3: Web3 | None = None,
 ) -> None:
-    from_address = api_keys.bet_from_address
     market_contract = market.get_contract()
     collateral_token_contract = market_contract.get_collateral_token_contract()
-    assert isinstance(
-        collateral_token_contract, ContractDepositableWrapperERC20OnGnosisChain
-    ), "TODO: Implement for the ERC-20 and ERC-4626 case."
 
-    # Deposit xDai to the collateral token,
-    # this can be skipped, if we know we already have enough collateral tokens.
-    if (
-        auto_deposit
-        and collateral_token_contract.balanceOf(for_address=from_address, web3=web3)
-        < funds
-    ):
-        collateral_token_contract.deposit(api_keys, funds, web3=web3)
+    if auto_deposit:
+        auto_deposit_collateral_token(collateral_token_contract, funds, api_keys, web3)
 
     collateral_token_contract.approve(
         api_keys=api_keys,
@@ -942,7 +925,8 @@ def omen_remove_fund_market_tx(
     """
     from_address = api_keys.bet_from_address
     market_contract = market.get_contract()
-    original_balances = get_balances(from_address, web3=web3)
+    market_collateral_token_contract = market_contract.get_collateral_token_contract()
+    original_balance = market_collateral_token_contract.balanceOf(from_address)
 
     total_shares = market_contract.balanceOf(from_address, web3=web3)
     if total_shares == 0:
@@ -977,11 +961,11 @@ def omen_remove_fund_market_tx(
         web3=web3,
     )
 
-    new_balances = get_balances(from_address, web3)
+    new_balance = market_collateral_token_contract.balanceOf(from_address)
 
     logger.debug(f"Result from merge positions {result}")
     logger.info(
-        f"Withdrawn {new_balances.wxdai - original_balances.wxdai} wxDai from liquidity at {market.url=}."
+        f"Withdrawn {new_balance - original_balance} {market_collateral_token_contract.symbol_cached()} from liquidity at {market.url=}."
     )
 
 

prediction_market_agent_tooling/markets/omen/omen_contracts.py

@@ -28,7 +28,7 @@ from prediction_market_agent_tooling.tools.contract import (
     ContractERC4626OnGnosisChain,
     ContractOnGnosisChain,
     abi_field_validator,
-    init_erc4626_or_wrappererc20_or_erc20_contract,
+    init_collateral_token_contract,
     to_gnosis_chain_contract,
 )
 from prediction_market_agent_tooling.tools.web3_utils import (
@@ -390,16 +390,10 @@ class OmenFixedProductMarketMakerContract(ContractOnGnosisChain):
 
     def get_collateral_token_contract(
         self, web3: Web3 | None = None
-    ) -> (
-        ContractERC20OnGnosisChain
-        | ContractERC4626OnGnosisChain
-        | ContractDepositableWrapperERC20OnGnosisChain
-    ):
+    ) -> ContractERC20OnGnosisChain:
         web3 = web3 or self.get_web3()
         return to_gnosis_chain_contract(
-            init_erc4626_or_wrappererc20_or_erc20_contract(
-                self.collateralToken(web3=web3), web3
-            )
+            init_collateral_token_contract(self.collateralToken(web3=web3), web3)
         )
 
 

prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py

@@ -26,6 +26,7 @@ from prediction_market_agent_tooling.markets.omen.data_models import (
 from prediction_market_agent_tooling.markets.omen.omen_contracts import (
     OmenThumbnailMapping,
     WrappedxDaiContract,
+    sDaiContract,
 )
 from prediction_market_agent_tooling.tools.singleton import SingletonMeta
 from prediction_market_agent_tooling.tools.utils import to_int_timestamp, utcnow
@@ -185,7 +186,7 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
         condition_id_in: list[HexBytes] | None = None,
         id_in: list[str] | None = None,
         excluded_questions: set[str] | None = None,
-        collateral_token_address: ChecksumAddress | None = None,
+        collateral_token_address_in: tuple[ChecksumAddress, ...] | None = None,
     ) -> dict[str, t.Any]:
         where_stms: dict[str, t.Any] = {
             "isPendingArbitration": False,
@@ -195,8 +196,10 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
             "condition_": {},
         }
 
-        if collateral_token_address:
-            where_stms["collateralToken"] = collateral_token_address.lower()
+        if collateral_token_address_in:
+            where_stms["collateralToken_in"] = [
+                x.lower() for x in collateral_token_address_in
+            ]
 
         if creator:
             where_stms["creator"] = creator
@@ -338,9 +341,12 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
         sort_by_field: FieldPath | None = None,
         sort_direction: str | None = None,
         outcomes: list[str] = [OMEN_TRUE_OUTCOME, OMEN_FALSE_OUTCOME],
-        collateral_token_address: (
-            ChecksumAddress | None
-        ) = WrappedxDaiContract().address,  # TODO: Remove this default limitation once we fully support other than wxDai markets.
+        # TODO: Agents don't know how to convert value between other tokens, we assume 1 unit = 1xDai = $1 (for example if market would be in wETH, betting 1 unit of wETH would be crazy :D)
+        collateral_token_address_in: tuple[ChecksumAddress, ...]
+        | None = (
+            WrappedxDaiContract().address,
+            sDaiContract().address,
+        ),
     ) -> t.List[OmenMarket]:
         """
         Complete method to fetch Omen binary markets with various filters, use `get_omen_binary_markets_simple` for simplified version that uses FilterBy and SortBy enums.
@@ -358,7 +364,7 @@ class OmenSubgraphHandler(metaclass=SingletonMeta):
             id_in=id_in,
             excluded_questions=excluded_questions,
             liquidity_bigger_than=liquidity_bigger_than,
-            collateral_token_address=collateral_token_address,
+            collateral_token_address_in=collateral_token_address_in,
         )
 
         # These values can not be set to `None`, but they can be omitted.

prediction_market_agent_tooling/tools/betting_strategies/kelly_criterion.py

@@ -1,110 +1,67 @@
-import typing as t
+from enum import Enum
 
-from prediction_market_agent_tooling.gtypes import Probability, wei_type, xDai
-from prediction_market_agent_tooling.markets.omen.data_models import OmenMarket
-from prediction_market_agent_tooling.tools.utils import check_not_none
-from prediction_market_agent_tooling.tools.web3_utils import (
-    ONE_XDAI,
-    wei_to_xdai,
-    xdai_to_wei,
-)
+from pydantic import BaseModel
 
-OutcomeIndex = t.Literal[0, 1]
 
+class BetDirection(str, Enum):
+    YES = "Yes"
+    NO = "No"
 
-def _get_kelly_criterion_bet(
-    x: int, y: int, p: float, c: float, b: int, f: float
-) -> int:
+
+class KellyBet(BaseModel):
+    direction: BetDirection
+    size: float
+
+
+def check_is_valid_probability(probability: float) -> None:
+    if not 0 <= probability <= 1:
+        raise ValueError("Probability must be between 0 and 1")
+
+
+def get_kelly_bet(
+    max_bet: float,
+    market_p_yes: float,
+    estimated_p_yes: float,
+    confidence: float,
+) -> KellyBet:
     """
-    Implments https://en.wikipedia.org/wiki/Kelly_criterion
-
-    Taken from https://github.com/valory-xyz/trader/blob/main/strategies/kelly_criterion/kelly_criterion.py
-
-    ```
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-
-        http://www.apache.org/licenses/LICENSE-2.0
-
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
-    ```
-
-    x: Number of tokens in the selected outcome pool
-    y: Number of tokens in the other outcome pool
-    p: Probability of winning
-    c: Confidence
-    b: Bankroll
-    f: Fee fraction
+    Calculate the optimal bet amount using the Kelly Criterion for a binary outcome market.
+
+    From https://en.wikipedia.org/wiki/Kelly_criterion:
+
+    f* = p - q / b
+
+    where:
+    - f* is the fraction of the current bankroll to wager
+    - p is the probability of a win
+    - q = 1-p is the probability of a loss
+    - b is the proportion of the bet gained with a win
+
+    Note: this calculation does not factor in that the bet changes the market
+    odds. This means the calculation is only accurate if the bet size is small
+    compared to the market volume. See discussion here for more detail:
+    https://github.com/gnosis/prediction-market-agent-tooling/pull/330#discussion_r1698269328
     """
-    if b == 0:
-        return 0
-    numerator = (
-        -4 * x**2 * y
-        + b * y**2 * p * c * f
-        + 2 * b * x * y * p * c * f
-        + b * x**2 * p * c * f
-        - 2 * b * y**2 * f
-        - 2 * b * x * y * f
-        + (
-            (
-                4 * x**2 * y
-                - b * y**2 * p * c * f
-                - 2 * b * x * y * p * c * f
-                - b * x**2 * p * c * f
-                + 2 * b * y**2 * f
-                + 2 * b * x * y * f
-            )
-            ** 2
-            - (
-                4
-                * (x**2 * f - y**2 * f)
-                * (
-                    -4 * b * x * y**2 * p * c
-                    - 4 * b * x**2 * y * p * c
-                    + 4 * b * x * y**2
-                )
-            )
-        )
-        ** (1 / 2)
-    )
-    denominator = 2 * (x**2 * f - y**2 * f)
-    if denominator == 0:
-        return 0
-    kelly_bet_amount = numerator / denominator
-    return int(kelly_bet_amount)
-
-
-def get_kelly_criterion_bet(
-    market: OmenMarket,
-    estimated_p_yes: Probability,
-    max_bet: xDai,
-) -> t.Tuple[xDai, OutcomeIndex]:
-    if len(market.outcomeTokenAmounts) != 2:
-        raise ValueError("Only binary markets are supported.")
-
-    current_p_yes = check_not_none(
-        market.outcomeTokenProbabilities, "No probabilities, is marked closed?"
-    )[0]
-    outcome_index: OutcomeIndex = 0 if estimated_p_yes > current_p_yes else 1
-    estimated_p_win = estimated_p_yes if outcome_index == 0 else 1 - estimated_p_yes
-
-    kelly_bet_wei = wei_type(
-        _get_kelly_criterion_bet(
-            x=market.outcomeTokenAmounts[outcome_index],
-            y=market.outcomeTokenAmounts[1 - outcome_index],
-            p=estimated_p_win,
-            c=1,  # confidence
-            b=xdai_to_wei(max_bet),  # bankroll, or max bet, in Wei
-            f=(
-                xdai_to_wei(ONE_XDAI)
-                - check_not_none(market.fee, "No fee for the market.")
-            )
-            / xdai_to_wei(ONE_XDAI),  # fee fraction
-        )
-    )
-    return wei_to_xdai(kelly_bet_wei), outcome_index
+    check_is_valid_probability(market_p_yes)
+    check_is_valid_probability(estimated_p_yes)
+    check_is_valid_probability(confidence)
+
+    if estimated_p_yes > market_p_yes:
+        bet_direction = BetDirection.YES
+        market_prob = market_p_yes
+    else:
+        bet_direction = BetDirection.NO
+        market_prob = 1 - market_p_yes
+
+    # Handle the case where market_prob is 0
+    if market_prob == 0:
+        market_prob = 1e-10
+
+    edge = abs(estimated_p_yes - market_p_yes) * confidence
+    odds = (1 / market_prob) - 1
+    kelly_fraction = edge / odds
+
+    # Ensure bet size is non-negative does not exceed the wallet balance
+    bet_size = min(kelly_fraction * max_bet, max_bet)
+
+    return KellyBet(direction=bet_direction, size=bet_size)

prediction_market_agent_tooling/tools/contract.py

@@ -21,6 +21,7 @@ from prediction_market_agent_tooling.tools.gnosis_rpc import (
     GNOSIS_NETWORK_ID,
     GNOSIS_RPC_URL,
 )
+from prediction_market_agent_tooling.tools.utils import should_not_happen
 from prediction_market_agent_tooling.tools.web3_utils import (
     call_function_on_contract,
     send_function_on_contract_tx,
@@ -66,6 +67,11 @@ class ContractBaseClass(BaseModel):
     address: ChecksumAddress
 
     _abi_field_validator = field_validator("abi", mode="before")(abi_field_validator)
+    _cache: dict[
+        str, t.Any
+    ] = (
+        {}
+    )  # Can be used to hold values that aren't going to change after getting them for the first time, as for example `symbol` of an ERC-20 token.
 
     def call(
         self,
@@ -179,6 +185,18 @@ class ContractERC20BaseClass(ContractBaseClass):
         )
     )
 
+    def symbol(self, web3: Web3 | None = None) -> str:
+        symbol: str = self.call("symbol", web3=web3)
+        return symbol
+
+    def symbol_cached(self, web3: Web3 | None = None) -> str:
+        web3 = web3 or self.get_web3()
+        cache_key = create_contract_method_cache_key(self.symbol, web3)
+        if cache_key not in self._cache:
+            self._cache[cache_key] = self.symbol(web3=web3)
+        value: str = self._cache[cache_key]
+        return value
+
     def approve(
         self,
         api_keys: APIKeys,
@@ -219,6 +237,10 @@ class ContractERC20BaseClass(ContractBaseClass):
         balance: Wei = self.call("balanceOf", [for_address], web3=web3)
         return balance
 
+    def get_in_shares(self, amount: Wei, web3: Web3 | None = None) -> Wei:
+        # ERC-20 just holds the token, so the exact amount we send there, is the amount of shares we have there.
+        return amount
+
 
 class ContractDepositableWrapperERC20BaseClass(ContractERC20BaseClass):
     """
@@ -283,10 +305,11 @@ class ContractERC4626BaseClass(ContractERC20BaseClass):
         self,
         api_keys: APIKeys,
         amount_wei: Wei,
-        receiver: ChecksumAddress,
+        receiver: ChecksumAddress | None = None,
         tx_params: t.Optional[TxParams] = None,
         web3: Web3 | None = None,
     ) -> TxReceipt:
+        receiver = receiver or api_keys.bet_from_address
         return self.send(
             api_keys=api_keys,
             function_name="deposit",
@@ -295,6 +318,25 @@ class ContractERC4626BaseClass(ContractERC20BaseClass):
             web3=web3,
         )
 
+    def withdraw(
+        self,
+        api_keys: APIKeys,
+        assets_wei: Wei,
+        receiver: ChecksumAddress | None = None,
+        owner: ChecksumAddress | None = None,
+        tx_params: t.Optional[TxParams] = None,
+        web3: Web3 | None = None,
+    ) -> TxReceipt:
+        receiver = receiver or api_keys.bet_from_address
+        owner = owner or api_keys.bet_from_address
+        return self.send(
+            api_keys=api_keys,
+            function_name="withdraw",
+            function_params=[assets_wei, receiver, owner],
+            tx_params=tx_params,
+            web3=web3,
+        )
+
     def convertToShares(self, assets: Wei, web3: Web3 | None = None) -> Wei:
         shares: Wei = self.call("convertToShares", [assets], web3=web3)
         return shares
@@ -307,9 +349,7 @@ class ContractERC4626BaseClass(ContractERC20BaseClass):
         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
-        )
+        contract = init_collateral_token_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.
@@ -336,6 +376,10 @@ class ContractERC4626BaseClass(ContractERC20BaseClass):
 
         return receipt
 
+    def get_in_shares(self, amount: Wei, web3: Web3 | None = None) -> Wei:
+        # We send erc20 to the vault and receive shares in return, which can have a different value.
+        return self.convertToShares(amount, web3=web3)
+
 
 class ContractOnGnosisChain(ContractBaseClass):
     """
@@ -359,14 +403,16 @@ class ContractERC20OnGnosisChain(ContractERC20BaseClass, ContractOnGnosisChain):
 
 
 class ContractDepositableWrapperERC20OnGnosisChain(
-    ContractDepositableWrapperERC20BaseClass, ContractOnGnosisChain
+    ContractDepositableWrapperERC20BaseClass, ContractERC20OnGnosisChain
 ):
     """
     Depositable Wrapper ERC-20 standard base class with Gnosis Chain configuration.
     """
 
 
-class ContractERC4626OnGnosisChain(ContractERC4626BaseClass, ContractOnGnosisChain):
+class ContractERC4626OnGnosisChain(
+    ContractERC4626BaseClass, ContractERC20OnGnosisChain
+):
     """
     ERC-4626 standard base class with Gnosis Chain configuration.
     """
@@ -403,14 +449,9 @@ def contract_implements_function(
     return implements
 
 
-def init_erc4626_or_wrappererc20_or_erc20_contract(
-    address: ChecksumAddress,
-    web3: Web3,
-) -> (
-    ContractERC20BaseClass
-    | ContractERC4626BaseClass
-    | ContractDepositableWrapperERC20BaseClass
-):
+def init_collateral_token_contract(
+    address: ChecksumAddress, web3: Web3
+) -> ContractERC20BaseClass:
     """
     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.
@@ -435,95 +476,106 @@ def init_erc4626_or_wrappererc20_or_erc20_contract(
 
     else:
         raise ValueError(
-            f"Contract at {address} on Gnosis Chain is neither WrapperERC-20, ERC-20 nor ERC-4626."
+            f"Contract at {address} is neither Depositable ERC-20, ERC-20 nor ERC-4626."
         )
 
 
 def auto_deposit_collateral_token(
-    collateral_token_contract: (
-        ContractERC20BaseClass
-        | ContractERC4626BaseClass
-        | ContractDepositableWrapperERC20BaseClass
-    ),
+    collateral_token_contract: ContractERC20BaseClass,
     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)
+        auto_deposit_erc4626(collateral_token_contract, 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)
+        auto_deposit_depositable_wrapper_erc20(
+            collateral_token_contract, amount_wei, api_keys, web3
+        )
 
     elif isinstance(collateral_token_contract, ContractERC20BaseClass):
-        if collateral_token_balance < amount_wei:
+        if (
+            collateral_token_contract.balanceOf(
+                for_address=api_keys.bet_from_address, web3=web3
+            )
+            < 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! :(")
+        should_not_happen("Unsupported ERC20 contract type.")
 
 
-def asset_or_shares(
-    collateral_token_contract: (
-        ContractERC20BaseClass
-        | ContractERC4626BaseClass
-        | ContractDepositableWrapperERC20BaseClass
-    ),
+def auto_deposit_depositable_wrapper_erc20(
+    collateral_token_contract: ContractDepositableWrapperERC20BaseClass,
     amount_wei: Wei,
-) -> Wei:
-    return (
-        collateral_token_contract.convertToShares(amount_wei)
-        if isinstance(collateral_token_contract, ContractERC4626BaseClass)
-        else amount_wei
+    api_keys: APIKeys,
+    web3: Web3 | None,
+) -> None:
+    collateral_token_balance = collateral_token_contract.balanceOf(
+        for_address=api_keys.bet_from_address, web3=web3
+    )
+
+    # If we have enough of the collateral token, we don't need to deposit.
+    if collateral_token_balance >= amount_wei:
+        return
+
+    # If we don't have enough, we need to deposit the difference.
+    left_to_deposit = Wei(amount_wei - collateral_token_balance)
+    collateral_token_contract.deposit(api_keys, left_to_deposit, web3=web3)
+
+
+def auto_deposit_erc4626(
+    collateral_token_contract: ContractERC4626BaseClass,
+    asset_amount_wei: Wei,
+    api_keys: APIKeys,
+    web3: Web3 | None,
+) -> None:
+    for_address = api_keys.bet_from_address
+    collateral_token_balance_in_shares = collateral_token_contract.balanceOf(
+        for_address=for_address, web3=web3
+    )
+    asset_amount_wei_in_shares = collateral_token_contract.convertToShares(
+        asset_amount_wei, web3
     )
 
+    # If we have enough shares, we don't need to deposit.
+    if collateral_token_balance_in_shares >= asset_amount_wei_in_shares:
+        return
+
+    # If we need to deposit into erc4626, we first need to have enough of the asset token.
+    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)
+        < asset_amount_wei
+    ):
+        if isinstance(asset_token_contract, ContractDepositableWrapperERC20BaseClass):
+            auto_deposit_depositable_wrapper_erc20(
+                asset_token_contract, asset_amount_wei, api_keys, web3
+            )
+        else:
+            raise ValueError(
+                "Not enough of the asset token, but it's not a depositable wrapper token that we can deposit automatically."
+            )
+
+    # Finally, we can deposit the asset token into the erc4626 vault.
+    collateral_token_balance_in_assets = collateral_token_contract.convertToAssets(
+        collateral_token_balance_in_shares, web3
+    )
+    left_to_deposit = Wei(asset_amount_wei - collateral_token_balance_in_assets)
+    collateral_token_contract.deposit_asset_token(left_to_deposit, api_keys, web3)
+
 
 def to_gnosis_chain_contract(
-    contract: (
-        ContractDepositableWrapperERC20BaseClass
-        | ContractERC4626BaseClass
-        | ContractERC20BaseClass
-    ),
-) -> (
-    ContractDepositableWrapperERC20OnGnosisChain
-    | ContractERC4626OnGnosisChain
-    | ContractERC20OnGnosisChain
-):
+    contract: ContractERC20BaseClass,
+) -> ContractERC20OnGnosisChain:
     if isinstance(contract, ContractERC4626BaseClass):
         return ContractERC4626OnGnosisChain(address=contract.address)
     elif isinstance(contract, ContractDepositableWrapperERC20BaseClass):
@@ -532,3 +584,9 @@ def to_gnosis_chain_contract(
         return ContractERC20OnGnosisChain(address=contract.address)
     else:
         raise ValueError("Unsupported contract type")
+
+
+def create_contract_method_cache_key(
+    method: t.Callable[[t.Any], t.Any], web3: Web3
+) -> str:
+    return f"{method.__name__}-{str(web3.provider)}"

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

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

{prediction_market_agent_tooling-0.43.4.dist-info → prediction_market_agent_tooling-0.45.0.dist-info}/RECORD

@@ -37,10 +37,10 @@ prediction_market_agent_tooling/markets/metaculus/data_models.py,sha256=6TBy17xn
 prediction_market_agent_tooling/markets/metaculus/metaculus.py,sha256=uNF7LP4evvubk818g2zbX1VlnFxeUQOkNgx_e_LwaJA,3416
 prediction_market_agent_tooling/markets/omen/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/markets/omen/data_models.py,sha256=fpYxaslKq48lpNDsFUHcggY5geZIAKWDfC9FwUgIstE,14539
-prediction_market_agent_tooling/markets/omen/omen.py,sha256=_H_1huaCXTpmDUmHaHqIQoCbIrrMATHeXXdkw5BHu1s,40713
-prediction_market_agent_tooling/markets/omen/omen_contracts.py,sha256=BmIWFvQ-CM355eHmRrKipS_FcYc6TEISv2l2r45qHAU,22790
+prediction_market_agent_tooling/markets/omen/omen.py,sha256=7n-UwtXVKVqbZoJhRGDPlsYPyHcdMGuiJpJCaQMsG3A,39488
+prediction_market_agent_tooling/markets/omen/omen_contracts.py,sha256=FZCbzTuVUI-8NvbB2BDRP0xtkDY5pdCxpVuQ0nnQLdI,22618
 prediction_market_agent_tooling/markets/omen/omen_resolving.py,sha256=tXTJM_HNefODAJSGU_w1OklZ457ZMAjL6dC0EvkUYQ8,9450
-prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py,sha256=s-CHD1DuWyGv1_KfxNZv8fmBft60528b51nZ5XANzpU,25692
+prediction_market_agent_tooling/markets/omen/omen_subgraph_handler.py,sha256=4F4QR8MDwyEw52rolEJNxtbCcIipX6ccNHANfWyCBjg,25945
 prediction_market_agent_tooling/markets/polymarket/api.py,sha256=HXmA1akA0qDj0m3e-GEvWG8x75pm6BX4H7YJPQcST7I,4767
 prediction_market_agent_tooling/markets/polymarket/data_models.py,sha256=9CJzakyEcsn6DQBK2nOXjOMzTZBLAmK_KqevXvW17DI,4292
 prediction_market_agent_tooling/markets/polymarket/data_models_web.py,sha256=yK0uxLQrwImVAXbvwscdmxTjSxMpAjCcN760EWEK_8M,11914
@@ -56,12 +56,12 @@ prediction_market_agent_tooling/monitor/monitor_app.py,sha256=THyZ67baByakoOm3hI
 prediction_market_agent_tooling/monitor/monitor_settings.py,sha256=Xiozs3AsufuJ04JOe1vjUri-IAMWHjjmc2ugGGiHNH4,947
 prediction_market_agent_tooling/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/tools/balances.py,sha256=nR8_dSfbm3yTOOmMAwhGlurftEiNo1w1WIVzbskjdmM,837
-prediction_market_agent_tooling/tools/betting_strategies/kelly_criterion.py,sha256=IbhQPoKsQnjnag_n_wAL12n8QdCe7tAMRNV2QS8yYxY,3520
+prediction_market_agent_tooling/tools/betting_strategies/kelly_criterion.py,sha256=d3QEg1Bia8D7SPHGr-SgP0OHSLIzm_hf4sN4iz06qiM,1951
 prediction_market_agent_tooling/tools/betting_strategies/market_moving.py,sha256=wtrHVQRuA0uDx06z0OxQLYbswuOpHQ1UyCWwLCrD_oM,4400
 prediction_market_agent_tooling/tools/betting_strategies/minimum_bet_to_win.py,sha256=-FUSuQQgjcWSSnoFxnlAyTeilY6raJABJVM2QKkFqAY,438
 prediction_market_agent_tooling/tools/betting_strategies/stretch_bet_between.py,sha256=THMXwFlskvzbjnX_OiYtDSzI8XVFyULWfP2525_9UGc,429
 prediction_market_agent_tooling/tools/cache.py,sha256=tGHHd9HCiE_hCCtPtloHZQdDfBuiow9YsqJNYi2Tx_0,499
-prediction_market_agent_tooling/tools/contract.py,sha256=vjkPeZszvco_IAITp1GUfCZ3X8HrSol4GCDDa8TFFvw,17100
+prediction_market_agent_tooling/tools/contract.py,sha256=d6eR1CSSKRxyM-zgUtp5jmj3z8nAfwTdtiTGWjzlvYU,19388
 prediction_market_agent_tooling/tools/costs.py,sha256=EaAJ7v9laD4VEV3d8B44M4u3_oEO_H16jRVCdoZ93Uw,954
 prediction_market_agent_tooling/tools/gnosis_rpc.py,sha256=_MYSoyOR2MgAJkop1ERf8RhLum-M8S6OjaAsaqUW41w,203
 prediction_market_agent_tooling/tools/google.py,sha256=SfVDxb3oEOUK8mpd0l3mTX9ybrdrTPNM6HjfJ7kfNjA,1794
@@ -75,8 +75,8 @@ prediction_market_agent_tooling/tools/singleton.py,sha256=CiIELUiI-OeS7U7eeHEt0r
 prediction_market_agent_tooling/tools/streamlit_user_login.py,sha256=NXEqfjT9Lc9QtliwSGRASIz1opjQ7Btme43H4qJbzgE,3010
 prediction_market_agent_tooling/tools/utils.py,sha256=JE9YWtPPhnTgLiOyGAZDNG5K8nCwUY9IZEuAlm9UcxA,6611
 prediction_market_agent_tooling/tools/web3_utils.py,sha256=nKRHmdLnWSKd3wpo-cysXGvhhrJ2Yf69sN2FFQfSt6s,10578
-prediction_market_agent_tooling-0.43.4.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
-prediction_market_agent_tooling-0.43.4.dist-info/METADATA,sha256=3-3qr88s5tHIqW1_h8tK8HCP5ayx-GANQyPFGCNkS_k,7634
-prediction_market_agent_tooling-0.43.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-prediction_market_agent_tooling-0.43.4.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
-prediction_market_agent_tooling-0.43.4.dist-info/RECORD,,
+prediction_market_agent_tooling-0.45.0.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
+prediction_market_agent_tooling-0.45.0.dist-info/METADATA,sha256=3KvBa071FaBwX1gQtAtG5rg9LMVEhIfSkZC5VrzYRcc,7634
+prediction_market_agent_tooling-0.45.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+prediction_market_agent_tooling-0.45.0.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
+prediction_market_agent_tooling-0.45.0.dist-info/RECORD,,