prediction-market-agent-tooling 0.61.1.dev463__py3-none-any.whl → 0.61.1.dev482__py3-none-any.whl

prediction_market_agent_tooling/tools/contract.py

@@ -15,7 +15,6 @@ from prediction_market_agent_tooling.gtypes import (
     ChainID,
     ChecksumAddress,
     Nonce,
-    Token,
     TxParams,
     TxReceipt,
     Wei,
@@ -154,7 +153,7 @@ class ContractBaseClass(BaseModel):
             api_keys=api_keys,
             function_name=function_name,
             function_params=function_params,
-            tx_params={"value": amount_wei.value, **(tx_params or {})},
+            tx_params={"value": amount_wei, **(tx_params or {})},
             timeout=timeout,
             web3=web3,
         )
@@ -244,13 +243,12 @@ class ContractERC20BaseClass(ContractBaseClass):
         )
 
     def balanceOf(self, for_address: ChecksumAddress, web3: Web3 | None = None) -> Wei:
-        balance = Wei(self.call("balanceOf", [for_address], web3=web3))
+        balance: Wei = self.call("balanceOf", [for_address], web3=web3)
         return balance
 
-    def balance_of_in_tokens(
-        self, for_address: ChecksumAddress, web3: Web3 | None = None
-    ) -> Token:
-        return self.balanceOf(for_address, web3=web3).as_token
+    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):
@@ -357,11 +355,11 @@ class ContractERC4626BaseClass(ContractERC20BaseClass):
         return self.withdraw(api_keys=api_keys, assets_wei=assets, web3=web3)
 
     def convertToShares(self, assets: Wei, web3: Web3 | None = None) -> Wei:
-        shares = Wei(self.call("convertToShares", [assets], web3=web3))
+        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))
+        assets: Wei = self.call("convertToAssets", [shares], web3=web3)
         return assets
 
     def get_asset_token_contract(
@@ -436,8 +434,8 @@ class ContractERC721BaseClass(ContractBaseClass):
             web3=web3,
         )
 
-    def balanceOf(self, owner: ChecksumAddress, web3: Web3 | None = None) -> Wei:
-        balance = Wei(self.call("balanceOf", [owner], web3=web3))
+    def balanceOf(self, owner: ChecksumAddress, web3: Web3 | None = None) -> int:
+        balance: int = self.call("balanceOf", [owner], web3=web3)
         return balance
 
     def owner_of(self, token_id: int, web3: Web3 | None = None) -> ChecksumAddress:
@@ -606,14 +604,12 @@ def contract_implements_function(
 
 
 def init_collateral_token_contract(
-    address: ChecksumAddress, web3: Web3 | None
+    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.
     """
-    web3 = web3 or RPCConfig().get_web3()
-
     if contract_implements_function(address, "asset", web3=web3):
         return ContractERC4626BaseClass(address=address)
 

prediction_market_agent_tooling/tools/cow/cow_manager.py

@@ -19,9 +19,10 @@ from web3 import Web3
 from web3.constants import ADDRESS_ZERO
 
 from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.gtypes import ChecksumAddress, Token, Wei
+from prediction_market_agent_tooling.gtypes import ChecksumAddress, Wei, xDai
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.tools.cow.cow_order import swap_tokens_waiting
+from prediction_market_agent_tooling.tools.web3_utils import xdai_to_wei
 
 COW_ENV: Envs = "prod"
 
@@ -93,14 +94,14 @@ class CowManager:
 
     @staticmethod
     def swap(
-        amount: Token,
+        amount: xDai,
         sell_token: ChecksumAddress,
         buy_token: ChecksumAddress,
         api_keys: APIKeys,
         web3: Web3 | None = None,
     ) -> OrderMetaData:
         order_metadata = swap_tokens_waiting(
-            amount_wei=amount.as_wei,
+            amount_wei=xdai_to_wei(amount),
             sell_token=sell_token,
             buy_token=buy_token,
             api_keys=api_keys,

prediction_market_agent_tooling/tools/cow/cow_order.py

@@ -21,9 +21,10 @@ from cowdao_cowpy.order_book.generated.model import (
 from eth_account.signers.local import LocalAccount
 from eth_typing.evm import ChecksumAddress
 from web3 import Web3
+from web3.types import Wei
 
 from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.gtypes import ChecksumAddress, Wei
+from prediction_market_agent_tooling.gtypes import ChecksumAddress, Wei, wei_type
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.tools.contract import ContractERC20OnGnosisChain
 from prediction_market_agent_tooling.tools.utils import utcnow
@@ -61,7 +62,7 @@ def get_buy_token_amount(
     order_quote = asyncio.run(
         order_book_api.post_quote(order_quote_request, order_side)
     )
-    return Wei(order_quote.quote.buyAmount.root)
+    return wei_type(order_quote.quote.buyAmount.root)
 
 
 def swap_tokens_waiting(
@@ -101,7 +102,7 @@ async def swap_tokens_waiting_async(
     timeout: timedelta = timedelta(seconds=60),
 ) -> OrderMetaData:
     order = await swap_tokens(
-        amount=amount_wei.value,
+        amount=amount_wei,
         sell_token=sell_token,
         buy_token=buy_token,
         account=account,

prediction_market_agent_tooling/tools/langfuse_client_utils.py

@@ -13,9 +13,6 @@ from prediction_market_agent_tooling.markets.data_models import (
     TradeType,
 )
 from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
-from prediction_market_agent_tooling.markets.omen.omen_constants import (
-    WRAPPED_XDAI_CONTRACT_ADDRESS,
-)
 from prediction_market_agent_tooling.tools.utils import DatetimeUTC
 
 
@@ -150,20 +147,11 @@ def get_trace_for_bet(
     # Filter for traces with the same bet outcome and amount
     traces_for_bet: list[ProcessMarketTrace] = []
     for t in traces:
-        if (
-            t.market.collateral_token_contract_address_checksummed
-            not in WRAPPED_XDAI_CONTRACT_ADDRESS
-        ):
-            # TODO: We need to compute bet amount token in USD here, but at the time of bet placement!
-            logger.warning(
-                "This currently works only for WXDAI markets, because we need to compare against USD value."
-            )
-            continue
         # Cannot use exact comparison due to gas fees
         if (
             t.buy_trade
             and t.buy_trade.outcome == bet.outcome
-            and np.isclose(t.buy_trade.amount.value, bet.amount.value)
+            and np.isclose(t.buy_trade.amount.amount, bet.amount.amount)
         ):
             traces_for_bet.append(t)
 

prediction_market_agent_tooling/tools/omen/sell_positions.py

@@ -1,7 +1,6 @@
 from datetime import timedelta
 
 from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.gtypes import USD
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
 from prediction_market_agent_tooling.markets.omen.omen_subgraph_handler import (
@@ -24,9 +23,7 @@ def sell_all(
         better_address=better_address,
         market_opening_after=utcnow() + timedelta(days=closing_later_than_days),
     )
-    bets_total_usd = sum(
-        (b.get_collateral_amount_usd() for b in bets), start=USD.zero()
-    )
+    bets_total_usd = sum(b.collateral_amount_usd for b in bets)
     unique_market_urls = set(b.fpmm.url for b in bets)
     starting_balance = get_balances(better_address)
     new_balance = starting_balance
@@ -40,9 +37,9 @@ def sell_all(
         outcome = agent_market.outcomes[bet.outcomeIndex]
         current_token_balance = agent_market.get_token_balance(better_address, outcome)
 
-        if current_token_balance.as_token <= agent_market.get_tiny_bet_amount():
+        if current_token_balance.amount <= OmenAgentMarket.get_tiny_bet_amount().amount:
             logger.info(
-                f"Skipping bet on {bet.fpmm.url} because the actual balance is unreasonably low {current_token_balance}."
+                f"Skipping bet on {bet.fpmm.url} because the actual balance is unreasonably low {current_token_balance.amount}."
             )
             continue
 

prediction_market_agent_tooling/tools/safe.py

@@ -11,10 +11,11 @@ from safe_eth.eth.constants import NULL_ADDRESS
 from safe_eth.eth.contracts import get_safe_V1_4_1_contract
 from safe_eth.safe.proxy_factory import ProxyFactoryV141
 from safe_eth.safe.safe import SafeV141
+from web3.types import Wei
 
-from prediction_market_agent_tooling.gtypes import Wei
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.tools.hexbytes_custom import HexBytes
+from prediction_market_agent_tooling.tools.web3_utils import wei_to_xdai
 
 
 def create_safe(
@@ -62,10 +63,10 @@ def create_safe(
             f"does not exist on network {ethereum_network.name}"
         )
 
-    account_balance = Wei(ethereum_client.get_balance(account.address))
-    account_balance_xdai = account_balance.as_token
+    account_balance = ethereum_client.get_balance(account.address)
+    account_balance_xdai = wei_to_xdai(account_balance)
     # We set a reasonable expected balance below for Safe deployment not to fail.
-    if account_balance_xdai.value < 0.01:
+    if account_balance_xdai < 0.01:
         raise ValueError(
             f"Client's balance is {account_balance_xdai} xDAI, too low for deploying a Safe."
         )
@@ -107,7 +108,7 @@ def create_safe(
             payment_token,
             payment,
             payment_receiver,
-        ).build_transaction({"gas": 1, "gasPrice": Wei(1).value})["data"]
+        ).build_transaction({"gas": 1, "gasPrice": Wei(1)})["data"]
     )
 
     proxy_factory = ProxyFactoryV141(proxy_factory_address, ethereum_client)

prediction_market_agent_tooling/tools/tokens/auto_deposit.py

@@ -1,7 +1,7 @@
 from web3 import Web3
 
 from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.gtypes import USD, Wei
+from prediction_market_agent_tooling.gtypes import Wei, wei_type
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.tools.contract import (
     ContractDepositableWrapperERC20BaseClass,
@@ -9,44 +9,32 @@ from prediction_market_agent_tooling.tools.contract import (
     ContractERC20OnGnosisChain,
     ContractERC4626BaseClass,
 )
-from prediction_market_agent_tooling.tools.cow.cow_order import swap_tokens_waiting
+from prediction_market_agent_tooling.tools.cow.cow_order import (
+    get_buy_token_amount,
+    swap_tokens_waiting,
+)
 from prediction_market_agent_tooling.tools.tokens.main_token import KEEPING_ERC20_TOKEN
-from prediction_market_agent_tooling.tools.tokens.usd import get_usd_in_token
 from prediction_market_agent_tooling.tools.utils import should_not_happen
+from prediction_market_agent_tooling.tools.web3_utils import wei_to_xdai
 
 
 def auto_deposit_collateral_token(
     collateral_token_contract: ContractERC20BaseClass,
-    collateral_amount_wei_or_usd: Wei | USD,
+    amount_wei: Wei,
     api_keys: APIKeys,
     web3: Web3 | None = None,
-    slippage: float = 0.01,
 ) -> None:
-    collateral_amount_wei = (
-        collateral_amount_wei_or_usd
-        if isinstance(collateral_amount_wei_or_usd, Wei)
-        else get_usd_in_token(
-            collateral_amount_wei_or_usd, collateral_token_contract.address
-        ).as_wei
-    )
-    # Deposit a bit more, to cover any later changes in the price.
-    collateral_amount_wei = collateral_amount_wei.with_fraction(slippage)
-
     if isinstance(collateral_token_contract, ContractDepositableWrapperERC20BaseClass):
         # In this case, we can use deposit function directly, no need to go through DEX.
         auto_deposit_depositable_wrapper_erc20(
-            collateral_token_contract, collateral_amount_wei, api_keys, web3
+            collateral_token_contract, amount_wei, api_keys, web3
         )
 
     elif isinstance(collateral_token_contract, ContractERC4626BaseClass):
-        auto_deposit_erc4626(
-            collateral_token_contract, collateral_amount_wei, api_keys, web3
-        )
+        auto_deposit_erc4626(collateral_token_contract, amount_wei, api_keys, web3)
 
     elif isinstance(collateral_token_contract, ContractERC20BaseClass):
-        auto_deposit_erc20(
-            collateral_token_contract, collateral_amount_wei, api_keys, web3
-        )
+        auto_deposit_erc20(collateral_token_contract, amount_wei, api_keys, web3)
 
     else:
         should_not_happen("Unsupported ERC20 contract type.")
@@ -67,16 +55,16 @@ def auto_deposit_depositable_wrapper_erc20(
         return
 
     # If we don't have enough, we need to deposit the difference.
-    left_to_deposit = amount_wei - collateral_token_balance
+    left_to_deposit = Wei(amount_wei - collateral_token_balance)
     logger.info(
-        f"Depositing {left_to_deposit.as_token} {collateral_token_contract.symbol()}."
+        f"Depositing {wei_to_xdai(left_to_deposit)} {collateral_token_contract.symbol()}."
     )
     collateral_token_contract.deposit(api_keys, left_to_deposit, web3=web3)
 
 
 def auto_deposit_erc4626(
     collateral_token_contract: ContractERC4626BaseClass,
-    collateral_amount_wei: Wei,
+    asset_amount_wei: Wei,
     api_keys: APIKeys,
     web3: Web3 | None,
 ) -> None:
@@ -84,12 +72,12 @@ def auto_deposit_erc4626(
     collateral_token_balance_in_shares = collateral_token_contract.balanceOf(
         for_address=for_address, web3=web3
     )
-    asset_amount_wei = collateral_token_contract.convertToAssets(
-        collateral_amount_wei, 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 >= collateral_amount_wei:
+    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.
@@ -101,7 +89,7 @@ def auto_deposit_erc4626(
         collateral_token_balance_in_assets = collateral_token_contract.convertToAssets(
             collateral_token_balance_in_shares, web3
         )
-        left_to_deposit = asset_amount_wei - collateral_token_balance_in_assets
+        left_to_deposit = Wei(asset_amount_wei - collateral_token_balance_in_assets)
         if (
             collateral_token_contract.get_asset_token_balance(for_address, web3)
             < left_to_deposit
@@ -120,22 +108,32 @@ def auto_deposit_erc4626(
 
 def auto_deposit_erc20(
     collateral_token_contract: ContractERC20BaseClass,
-    collateral_amount_wei: Wei,
+    amount_xdai_wei: Wei,
     api_keys: APIKeys,
     web3: Web3 | None,
 ) -> None:
+    # How much it is in the other token (collateral token).
+    collateral_amount_wei = get_buy_token_amount(
+        amount_xdai_wei,
+        KEEPING_ERC20_TOKEN.address,
+        collateral_token_contract.address,
+    )
     # How much do we have already in the other token (collateral token).
     collateral_balance_wei = collateral_token_contract.balanceOf(
         api_keys.bet_from_address
     )
     # Amount of collateral token remaining to get.
     remaining_to_get_in_collateral_wei = max(
-        Wei(0), collateral_amount_wei - collateral_balance_wei
+        0, collateral_amount_wei - collateral_balance_wei
     )
     if not remaining_to_get_in_collateral_wei:
         return
     # Estimate of how much of the source token we need to sell in order to fill the remaining collateral amount, with 1% slippage to be sure.
-    amount_to_sell_wei = remaining_to_get_in_collateral_wei * 1.01
+    amount_to_sell_wei = wei_type(
+        (remaining_to_get_in_collateral_wei * amount_xdai_wei)
+        / collateral_amount_wei
+        * 1.01
+    )
     # If we don't have enough of the source token.
     if amount_to_sell_wei > ContractERC20OnGnosisChain(
         address=KEEPING_ERC20_TOKEN.address

prediction_market_agent_tooling/tools/tokens/auto_withdraw.py

@@ -7,9 +7,16 @@ from prediction_market_agent_tooling.tools.contract import (
     ContractERC20BaseClass,
     ContractERC4626BaseClass,
 )
-from prediction_market_agent_tooling.tools.cow.cow_order import swap_tokens_waiting
+from prediction_market_agent_tooling.tools.cow.cow_order import (
+    get_buy_token_amount,
+    swap_tokens_waiting,
+)
 from prediction_market_agent_tooling.tools.tokens.main_token import KEEPING_ERC20_TOKEN
 from prediction_market_agent_tooling.tools.utils import should_not_happen
+from prediction_market_agent_tooling.tools.web3_utils import (
+    remove_fraction,
+    wei_to_xdai,
+)
 
 
 def auto_withdraw_collateral_token(
@@ -20,7 +27,10 @@ def auto_withdraw_collateral_token(
     slippage: float = 0.001,
 ) -> None:
     # Small slippage as exact exchange rate constantly changes and we don't care about small differences.
-    amount_wei = amount_wei.without_fraction(slippage)
+    amount_wei = remove_fraction(
+        amount_wei,
+        slippage,
+    )
 
     if not amount_wei:
         logger.warning(
@@ -41,7 +51,7 @@ def auto_withdraw_collateral_token(
     ):
         # If the ERC4626 is backed by KEEPING_ERC20_TOKEN, we can withdraw it directly, no need to go through DEX.
         logger.info(
-            f"Withdrawing {amount_wei.as_token} from {collateral_token_contract.symbol_cached(web3)} into {KEEPING_ERC20_TOKEN.symbol_cached(web3)}"
+            f"Withdrawing {wei_to_xdai(amount_wei)} from {collateral_token_contract.symbol_cached(web3)} into {KEEPING_ERC20_TOKEN.symbol_cached(web3)}"
         )
         collateral_token_contract.withdraw_in_shares(
             api_keys,
@@ -50,11 +60,18 @@ def auto_withdraw_collateral_token(
         )
     elif isinstance(collateral_token_contract, ContractERC20BaseClass):
         logger.info(
-            f"Swapping {amount_wei.as_token} from {collateral_token_contract.symbol_cached(web3)} into {KEEPING_ERC20_TOKEN.symbol_cached(web3)}"
+            f"Swapping {wei_to_xdai(amount_wei)} {collateral_token_contract.symbol_cached(web3)} into {KEEPING_ERC20_TOKEN.symbol_cached(web3)}"
         )
         # Otherwise, DEX will handle the rest of token swaps.
+        # First, convert `amount_wei` from xDai-based value into the collateral token-based value.
+        collateral_amount_wei = get_buy_token_amount(
+            amount_wei,
+            KEEPING_ERC20_TOKEN.address,
+            collateral_token_contract.address,
+        )
+        # And then sell it.
         swap_tokens_waiting(
-            amount_wei=amount_wei,
+            amount_wei=collateral_amount_wei,
             sell_token=collateral_token_contract.address,
             buy_token=KEEPING_ERC20_TOKEN.address,
             api_keys=api_keys,

prediction_market_agent_tooling/tools/tokens/main_token.py

@@ -1,4 +1,4 @@
-from prediction_market_agent_tooling.gtypes import xDai
+from prediction_market_agent_tooling.gtypes import xdai_type
 from prediction_market_agent_tooling.markets.omen.omen_constants import (
     WRAPPED_XDAI_CONTRACT_ADDRESS,
 )
@@ -15,4 +15,4 @@ KEEPING_ERC20_TOKEN = ContractDepositableWrapperERC20OnGnosisChain(
     address=WRAPPED_XDAI_CONTRACT_ADDRESS
 )
 
-MINIMUM_NATIVE_TOKEN_IN_EOA_FOR_FEES = xDai(0.1)
+MINIMUM_NATIVE_TOKEN_IN_EOA_FOR_FEES = xdai_type(0.1)

prediction_market_agent_tooling/tools/utils.py

@@ -9,13 +9,7 @@ from pydantic import BaseModel, ValidationError
 from scipy.optimize import newton
 from scipy.stats import entropy
 
-from prediction_market_agent_tooling.gtypes import (
-    DatetimeUTC,
-    OutcomeToken,
-    Probability,
-    SecretStr,
-    Token,
-)
+from prediction_market_agent_tooling.gtypes import DatetimeUTC, Probability, SecretStr
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.market_fees import MarketFees
 
@@ -188,11 +182,11 @@ def prob_uncertainty(prob: Probability) -> float:
 
 
 def calculate_sell_amount_in_collateral(
-    shares_to_sell: OutcomeToken,
-    holdings: OutcomeToken,
-    other_holdings: OutcomeToken,
+    shares_to_sell: float,
+    holdings: float,
+    other_holdings: float,
     fees: MarketFees,
-) -> Token:
+) -> float:
     """
     Computes the amount of collateral that needs to be sold to get `shares`
     amount of shares. Returns None if the amount can't be computed.
@@ -205,11 +199,11 @@ def calculate_sell_amount_in_collateral(
             raise ValueError("All share args must be greater than 0")
 
     def f(r: float) -> float:
-        R = OutcomeToken((r + fees.absolute) / (1 - fees.bet_proportion))
+        R = (r + fees.absolute) / (1 - fees.bet_proportion)
         first_term = other_holdings - R
         second_term = holdings + shares_to_sell - R
         third_term = holdings * other_holdings
-        return ((first_term * second_term) - third_term).value
+        return (first_term * second_term) - third_term
 
     amount_to_sell = newton(f, 0)
-    return Token(float(amount_to_sell) * 0.999999)  # Avoid rounding errors
+    return float(amount_to_sell) * 0.999999  # Avoid rounding errors

prediction_market_agent_tooling/tools/web3_utils.py

@@ -1,6 +1,6 @@
 import binascii
 import secrets
-from typing import Any, Optional
+from typing import Any, Optional, TypeVar
 
 import base58
 import tenacity
@@ -11,7 +11,7 @@ from safe_eth.eth import EthereumClient
 from safe_eth.safe.safe import SafeV141
 from web3 import Web3
 from web3.constants import HASH_ZERO
-from web3.types import AccessList, AccessListEntry, Nonce, TxParams, TxReceipt
+from web3.types import AccessList, AccessListEntry, Nonce, TxParams, TxReceipt, Wei
 
 from prediction_market_agent_tooling.gtypes import (
     ABI,
@@ -23,13 +23,12 @@ from prediction_market_agent_tooling.gtypes import (
     PrivateKey,
     private_key_type,
     xDai,
-    xDaiWei,
+    xdai_type,
 )
 from prediction_market_agent_tooling.loggers import logger
-from prediction_market_agent_tooling.tools._generic_value import _GenericValue
 
 ONE_NONCE = Nonce(1)
-ONE_XDAI = xDai(1)
+ONE_XDAI = xdai_type(1)
 ZERO_BYTES = HexBytes(HASH_ZERO)
 NOT_REVERTED_ICASE_REGEX_PATTERN = "(?i)(?!.*reverted.*)"
 
@@ -43,6 +42,17 @@ def private_key_to_public_key(private_key: SecretStr) -> ChecksumAddress:
     return verify_address(account.address)
 
 
+def wei_to_xdai(wei: Wei) -> xDai:
+    return xDai(float(Web3.from_wei(wei, "ether")))
+
+
+def xdai_to_wei(native: xDai) -> Wei:
+    return Web3.to_wei(native, "ether")
+
+
+RemoveOrAddFractionAmountType = TypeVar("RemoveOrAddFractionAmountType", bound=int)
+
+
 def verify_address(address: str) -> ChecksumAddress:
     if not Web3.is_checksum_address(address):
         raise ValueError(
@@ -51,6 +61,26 @@ def verify_address(address: str) -> ChecksumAddress:
     return ChecksumAddress(HexAddress(HexStr(address)))
 
 
+def remove_fraction(
+    amount: RemoveOrAddFractionAmountType, fraction: float
+) -> RemoveOrAddFractionAmountType:
+    """Removes the given fraction from the given integer-bounded amount and returns the value as an original type."""
+    if 0 <= fraction <= 1:
+        keep_percentage = 1 - fraction
+        return type(amount)(int(amount * keep_percentage))
+    raise ValueError(f"The given fraction {fraction!r} is not in the range [0, 1].")
+
+
+def add_fraction(
+    amount: RemoveOrAddFractionAmountType, fraction: float
+) -> RemoveOrAddFractionAmountType:
+    """Adds the given fraction to the given integer-bounded amount and returns the value as an original type."""
+    if 0 <= fraction <= 1:
+        keep_percentage = 1 + fraction
+        return type(amount)(int(amount * keep_percentage))
+    raise ValueError(f"The given fraction {fraction!r} is not in the range [0, 1].")
+
+
 def check_tx_receipt(receipt: TxReceipt) -> None:
     if receipt["status"] != 1:
         raise ValueError(
@@ -58,20 +88,7 @@ def check_tx_receipt(receipt: TxReceipt) -> None:
         )
 
 
-def unwrap_generic_value(value: Any) -> Any:
-    if value is None:
-        return None
-    if isinstance(value, _GenericValue):
-        return value.value
-    elif isinstance(value, list):
-        return [unwrap_generic_value(v) for v in value]
-    elif isinstance(value, dict):
-        return {k: unwrap_generic_value(v) for k, v in value.items()}
-    return value
-
-
 def parse_function_params(params: Optional[list[Any] | dict[str, Any]]) -> list[Any]:
-    params = unwrap_generic_value(params)
     if params is None:
         return []
     if isinstance(params, list):
@@ -155,8 +172,8 @@ def _prepare_tx_params(
     # Don't retry on `reverted` messages, as they would always fail again.
     # TODO: Check this, see https://github.com/gnosis/prediction-market-agent-tooling/issues/625.
     # retry=tenacity.retry_if_exception_message(match=NOT_REVERTED_ICASE_REGEX_PATTERN),
-    wait=tenacity.wait_chain(*[tenacity.wait_fixed(n) for n in range(1, 6)]),
-    stop=tenacity.stop_after_attempt(5),
+    wait=tenacity.wait_chain(*[tenacity.wait_fixed(n) for n in range(1, 10)]),
+    stop=tenacity.stop_after_attempt(9),
     after=lambda x: logger.debug(
         f"send_function_on_contract_tx failed, {x.attempt_number=}."
     ),
@@ -193,7 +210,7 @@ def send_function_on_contract_tx(
     # Don't retry on `reverted` messages, as they would always fail again.
     # TODO: Check this, see https://github.com/gnosis/prediction-market-agent-tooling/issues/625.
     # retry=tenacity.retry_if_exception_message(match=NOT_REVERTED_ICASE_REGEX_PATTERN),
-    wait=tenacity.wait_chain(*[tenacity.wait_fixed(n) for n in range(1, 6)]),
+    wait=tenacity.wait_chain(*[tenacity.wait_fixed(n) for n in range(1, 10)]),
     stop=tenacity.stop_after_attempt(5),
     after=lambda x: logger.debug(
         f"send_function_on_contract_tx_using_safe failed, {x.attempt_number=}."
@@ -290,14 +307,14 @@ def send_xdai_to(
     web3: Web3,
     from_private_key: PrivateKey,
     to_address: ChecksumAddress,
-    value: xDaiWei,
+    value: Wei,
     data_text: Optional[str | bytes] = None,
     tx_params: Optional[TxParams] = None,
     timeout: int = 180,
 ) -> TxReceipt:
     from_address = private_key_to_public_key(from_private_key)
 
-    tx_params_new: TxParams = {"value": value.value, "to": to_address}
+    tx_params_new: TxParams = {"value": value, "to": to_address}
     if data_text is not None:
         tx_params_new["data"] = (
             Web3.to_bytes(text=data_text)
@@ -343,7 +360,7 @@ def byte32_to_ipfscidv0(hex: HexBytes) -> IPFSCIDVersion0:
 
 
 @tenacity.retry(
-    wait=tenacity.wait_chain(*[tenacity.wait_fixed(n) for n in range(1, 6)]),
+    wait=tenacity.wait_chain(*[tenacity.wait_fixed(n) for n in range(1, 10)]),
     stop=tenacity.stop_after_attempt(5),
     after=lambda x: logger.debug(
         f"get_receipt_block_timestamp failed, {x.attempt_number=}."

{prediction_market_agent_tooling-0.61.1.dev463.dist-info → prediction_market_agent_tooling-0.61.1.dev482.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: prediction-market-agent-tooling
-Version: 0.61.1.dev463
+Version: 0.61.1.dev482
 Summary: Tools to benchmark, deploy and monitor prediction market agents.
 Author: Gnosis
 Requires-Python: >=3.10,<3.13
@@ -56,7 +56,6 @@ Requires-Dist: tabulate (>=0.9.0,<0.10.0)
 Requires-Dist: tavily-python (>=0.5.0,<0.6.0)
 Requires-Dist: tqdm (>=4.66.2,<5.0.0)
 Requires-Dist: typer (>=0.9.0,<1.0.0)
-Requires-Dist: types-cachetools (>=5.5.0.20240820,<6.0.0.0)
 Requires-Dist: types-python-dateutil (>=2.9.0.20240906,<3.0.0.0)
 Requires-Dist: types-pytz (>=2024.1.0.20240203,<2025.0.0.0)
 Requires-Dist: types-requests (>=2.31.0.0,<3.0.0.0)