prediction-market-agent-tooling 0.68.0.dev999__py3-none-any.whl → 0.69.0__py3-none-any.whl

prediction_market_agent_tooling/tools/betting_strategies/kelly_criterion.py

@@ -1,4 +1,6 @@
+from enum import Enum
 from itertools import chain
+from typing import Callable
 
 import numpy as np
 from scipy.optimize import minimize
@@ -9,11 +11,7 @@ from prediction_market_agent_tooling.gtypes import (
     Probability,
 )
 from prediction_market_agent_tooling.loggers import logger
-from prediction_market_agent_tooling.markets.agent_market import AgentMarket
 from prediction_market_agent_tooling.markets.market_fees import MarketFees
-from prediction_market_agent_tooling.markets.omen.omen import (
-    calculate_buy_outcome_token,
-)
 from prediction_market_agent_tooling.tools.betting_strategies.utils import (
     BinaryKellyBet,
     CategoricalKellyBet,
@@ -21,6 +19,11 @@ from prediction_market_agent_tooling.tools.betting_strategies.utils import (
 from prediction_market_agent_tooling.tools.utils import check_not_none
 
 
+class KellyType(str, Enum):
+    SIMPLE = "simple"
+    FULL = "full"
+
+
 def check_is_valid_probability(probability: float) -> None:
     if not 0 <= probability <= 1:
         raise ValueError("Probability must be between 0 and 1")
@@ -237,7 +240,7 @@ def get_kelly_bets_categorical_simplified(
 
 
 def get_kelly_bets_categorical_full(
-    outcome_pool_sizes: list[OutcomeToken],
+    market_probabilities: list[Probability],
     estimated_probabilities: list[Probability],
     confidence: float,
     max_bet: CollateralToken,
@@ -245,6 +248,8 @@ def get_kelly_bets_categorical_full(
     allow_multiple_bets: bool,
     allow_shorting: bool,
     multicategorical: bool,
+    # investment amount, outcome index --> received outcome tokens
+    get_buy_token_amount: Callable[[CollateralToken, int], OutcomeToken],
     bet_precision: int = 6,
 ) -> list[CategoricalKellyBet]:
     """
@@ -255,18 +260,13 @@ def get_kelly_bets_categorical_full(
     If the agent's probabilities are very close to the market's, returns all-zero bets.
     multicategorical means that multiple outcomes could be selected as correct ones.
     """
-    assert len(outcome_pool_sizes) == len(
+    assert len(market_probabilities) == len(
         estimated_probabilities
     ), "Mismatch in number of outcomes"
-
-    market_probabilities = AgentMarket.compute_fpmm_probabilities(
-        [x.as_outcome_wei for x in outcome_pool_sizes]
-    )
-
     for p in chain(market_probabilities, estimated_probabilities, [confidence]):
         check_is_valid_probability(p)
 
-    n = len(outcome_pool_sizes)
+    n = len(market_probabilities)
     max_bet_value = max_bet.value
 
     if all(
@@ -283,22 +283,17 @@ def get_kelly_bets_categorical_full(
             payout = 0.0
             if bets[i] >= 0:
                 # If bet on i is positive, we buy outcome i
-                buy_result = calculate_buy_outcome_token(
-                    CollateralToken(bets[i]), i, outcome_pool_sizes, fees
-                )
-                payout += buy_result.outcome_tokens_received.value
+                buy_result = get_buy_token_amount(CollateralToken(bets[i]), i)
+                payout += buy_result.value
             else:
                 # If bet is negative, we "short" outcome i by buying all other outcomes
                 for j in range(n):
                     if j == i:
                         continue
-                    buy_result = calculate_buy_outcome_token(
-                        CollateralToken(abs(bets[i]) / (n - 1)),
-                        j,
-                        outcome_pool_sizes,
-                        fees,
+                    buy_result = get_buy_token_amount(
+                        CollateralToken(abs(bets[i]) / (n - 1)), j
                     )
-                    payout += buy_result.outcome_tokens_received.value
+                    payout += buy_result.value
             payouts.append(payout)
         return payouts
 

prediction_market_agent_tooling/tools/contract.py

@@ -8,16 +8,21 @@ 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
+from web3.constants import CHECKSUM_ADDRESSS_ZERO, HASH_ZERO
 from web3.contract.contract import Contract as Web3Contract
 
+from prediction_market_agent_tooling.chains import POLYGON_CHAIN_ID
 from prediction_market_agent_tooling.config import APIKeys, RPCConfig
 from prediction_market_agent_tooling.gtypes import (
     ABI,
     ChainID,
     ChecksumAddress,
     CollateralToken,
+    HexAddress,
+    HexBytes,
+    HexStr,
     Nonce,
+    OutcomeWei,
     TxParams,
     TxReceipt,
     Wei,
@@ -516,9 +521,19 @@ class ContractOnGnosisChain(ContractBaseClass):
     Contract base class with Gnosis Chain configuration.
     """
 
+    # This is defined like so because other chains (like Ethereum) rely on contracts that inherit
+    # from ContractOnGnosisChain. To be re-evaluated on https://github.com/gnosis/prediction-market-agent-tooling/issues/845
     CHAIN_ID = RPCConfig().chain_id
 
 
+class ContractOnPolygonChain(ContractBaseClass):
+    """
+    Contract base class with Gnosis Chain configuration.
+    """
+
+    CHAIN_ID = POLYGON_CHAIN_ID
+
+
 class ContractProxyOnGnosisChain(ContractProxyBaseClass, ContractOnGnosisChain):
     """
     Proxy contract base class with Gnosis Chain configuration.
@@ -566,6 +581,223 @@ class ContractERC4626OnGnosisChain(
         return to_gnosis_chain_contract(super().get_asset_token_contract(web3=web3))
 
 
+class PayoutRedemptionEvent(BaseModel):
+    redeemer: HexAddress
+    collateralToken: HexAddress
+    parentCollectionId: HexBytes
+    conditionId: HexBytes
+    indexSets: list[int]
+    payout: Wei
+
+
+class ConditionPreparationEvent(BaseModel):
+    conditionId: HexBytes
+    oracle: HexAddress
+    questionId: HexBytes
+    outcomeSlotCount: int
+
+
+class ConditionalTokenContract(ContractBaseClass):
+    # Contract ABI taken from https://gnosisscan.io/address/0xCeAfDD6bc0bEF976fdCd1112955828E00543c0Ce#code.
+    abi: ABI = abi_field_validator(
+        os.path.join(
+            os.path.dirname(os.path.realpath(__file__)),
+            "../abis/omen_fpmm_conditionaltokens.abi.json",
+        )
+    )
+
+    def getConditionId(
+        self,
+        question_id: HexBytes,
+        oracle_address: ChecksumAddress,
+        outcomes_slot_count: int,
+        web3: Web3 | None = None,
+    ) -> HexBytes:
+        id_ = HexBytes(
+            self.call(
+                "getConditionId",
+                [oracle_address, question_id, outcomes_slot_count],
+                web3=web3,
+            )
+        )
+        return id_
+
+    def balanceOf(
+        self, from_address: ChecksumAddress, position_id: int, web3: Web3 | None = None
+    ) -> OutcomeWei:
+        balance = OutcomeWei(
+            self.call("balanceOf", [from_address, position_id], web3=web3)
+        )
+        return balance
+
+    def isApprovedForAll(
+        self,
+        owner: ChecksumAddress,
+        for_address: ChecksumAddress,
+        web3: Web3 | None = None,
+    ) -> bool:
+        is_approved: bool = self.call(
+            "isApprovedForAll", [owner, for_address], web3=web3
+        )
+        return is_approved
+
+    def getCollectionId(
+        self,
+        parent_collection_id: HexStr,
+        condition_id: HexBytes,
+        index_set: int,
+        web3: Web3 | None = None,
+    ) -> HexBytes:
+        collection_id = HexBytes(
+            self.call(
+                "getCollectionId",
+                [parent_collection_id, condition_id, index_set],
+                web3=web3,
+            )
+        )
+        return collection_id
+
+    def getPositionId(
+        self,
+        collateral_token_address: ChecksumAddress,
+        collection_id: HexBytes,
+        web3: Web3 | None = None,
+    ) -> int:
+        position_id: int = self.call(
+            "getPositionId",
+            [collateral_token_address, collection_id],
+            web3=web3,
+        )
+        return position_id
+
+    def mergePositions(
+        self,
+        api_keys: APIKeys,
+        collateral_token_address: ChecksumAddress,
+        conditionId: HexBytes,
+        index_sets: t.List[int],
+        amount: OutcomeWei,
+        parent_collection_id: HexStr = HASH_ZERO,
+        web3: Web3 | None = None,
+    ) -> TxReceipt:
+        return self.send(
+            api_keys=api_keys,
+            function_name="mergePositions",
+            function_params=[
+                collateral_token_address,
+                parent_collection_id,
+                conditionId,
+                index_sets,
+                amount,
+            ],
+            web3=web3,
+        )
+
+    def redeemPositions(
+        self,
+        api_keys: APIKeys,
+        collateral_token_address: HexAddress,
+        condition_id: HexBytes,
+        index_sets: t.List[int],
+        parent_collection_id: HexStr = HASH_ZERO,
+        web3: Web3 | None = None,
+    ) -> PayoutRedemptionEvent:
+        receipt_tx = self.send(
+            api_keys=api_keys,
+            function_name="redeemPositions",
+            function_params=[
+                collateral_token_address,
+                parent_collection_id,
+                condition_id,
+                index_sets,
+            ],
+            web3=web3,
+        )
+        redeem_event_logs = (
+            self.get_web3_contract(web3=web3)
+            .events.PayoutRedemption()
+            .process_receipt(receipt_tx)
+        )
+        redeem_event = PayoutRedemptionEvent(**redeem_event_logs[0]["args"])
+        return redeem_event
+
+    def getOutcomeSlotCount(
+        self, condition_id: HexBytes, web3: Web3 | None = None
+    ) -> int:
+        count: int = self.call("getOutcomeSlotCount", [condition_id], web3=web3)
+        return count
+
+    def does_condition_exists(
+        self, condition_id: HexBytes, web3: Web3 | None = None
+    ) -> bool:
+        return self.getOutcomeSlotCount(condition_id, web3=web3) > 0
+
+    def is_condition_resolved(
+        self, condition_id: HexBytes, web3: Web3 | None = None
+    ) -> bool:
+        # from ConditionalTokens.redeemPositions:
+        # uint den = payoutDenominator[conditionId]; require(den > 0, "result for condition not received yet");
+        payout_for_condition = self.payoutDenominator(condition_id, web3=web3)
+        return payout_for_condition > 0
+
+    def payoutDenominator(
+        self, condition_id: HexBytes, web3: Web3 | None = None
+    ) -> int:
+        payoutForCondition: int = self.call(
+            "payoutDenominator", [condition_id], web3=web3
+        )
+        return payoutForCondition
+
+    def setApprovalForAll(
+        self,
+        api_keys: APIKeys,
+        for_address: ChecksumAddress,
+        approve: bool,
+        tx_params: t.Optional[TxParams] = None,
+        web3: Web3 | None = None,
+    ) -> TxReceipt:
+        return self.send(
+            api_keys=api_keys,
+            function_name="setApprovalForAll",
+            function_params=[
+                for_address,
+                approve,
+            ],
+            tx_params=tx_params,
+            web3=web3,
+        )
+
+    def prepareCondition(
+        self,
+        api_keys: APIKeys,
+        oracle_address: ChecksumAddress,
+        question_id: HexBytes,
+        outcomes_slot_count: int,
+        tx_params: t.Optional[TxParams] = None,
+        web3: Web3 | None = None,
+    ) -> ConditionPreparationEvent:
+        receipt_tx = self.send(
+            api_keys=api_keys,
+            function_name="prepareCondition",
+            function_params=[
+                oracle_address,
+                question_id,
+                outcomes_slot_count,
+            ],
+            tx_params=tx_params,
+            web3=web3,
+        )
+
+        event_logs = (
+            self.get_web3_contract(web3=web3)
+            .events.ConditionPreparation()
+            .process_receipt(receipt_tx)
+        )
+        cond_event = ConditionPreparationEvent(**event_logs[0]["args"])
+
+        return cond_event
+
+
 class DebuggingContract(ContractOnGnosisChain):
     # Contract ABI taken from https://gnosisscan.io/address/0x5Aa82E068aE6a6a1C26c42E5a59520a74Cdb8998#code.
     abi: ABI = abi_field_validator(
@@ -614,12 +846,12 @@ def contract_implements_function(
     look_for_proxy_contract: bool = True,
 ) -> bool:
     function_signature = f"{function_name}({','.join(function_arg_types or [])})"
-    function_selector = web3.keccak(text=function_signature)[0:4].hex()[2:]
+    function_selector = web3.keccak(text=function_signature)[0:4].to_0x_hex()[2:]
     # 1. Check directly in bytecode
-    bytecode = web3.eth.get_code(contract_address).hex()
+    bytecode = web3.eth.get_code(contract_address).to_0x_hex()
     if function_selector in bytecode:
         return True
-    contract_code = web3.eth.get_code(contract_address).hex()
+    contract_code = web3.eth.get_code(contract_address).to_0x_hex()
     implements = function_selector in contract_code
 
     # If not found directly and we should check proxies

prediction_market_agent_tooling/tools/cow/cow_order.py

@@ -48,7 +48,7 @@ from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.omen.cow_contracts import (
     CowGPv2SettlementContract,
 )
-from prediction_market_agent_tooling.tools.contract import ContractERC20OnGnosisChain
+from prediction_market_agent_tooling.tools.contract import ContractERC20BaseClass
 from prediction_market_agent_tooling.tools.cow.models import MinimalisticTrade, Order
 from prediction_market_agent_tooling.tools.cow.semaphore import postgres_rate_limited
 from prediction_market_agent_tooling.tools.utils import utcnow
@@ -166,7 +166,8 @@ def get_buy_token_amount_else_raise(
 def handle_allowance(
     api_keys: APIKeys,
     sell_token: ChecksumAddress,
-    amount_wei: Wei,
+    amount_to_check_wei: Wei,
+    amount_to_set_wei: Wei | None = None,
     for_address: ChecksumAddress | None = None,
     web3: Web3 | None = None,
 ) -> None:
@@ -174,16 +175,17 @@ def handle_allowance(
     for_address = for_address or Web3.to_checksum_address(
         CowContractAddress.VAULT_RELAYER.value
     )
-    current_allowance = ContractERC20OnGnosisChain(address=sell_token).allowance(
+    current_allowance = ContractERC20BaseClass(address=sell_token).allowance(
         owner=api_keys.bet_from_address,
         for_address=for_address,
         web3=web3,
     )
-    if current_allowance < amount_wei:
-        ContractERC20OnGnosisChain(address=sell_token).approve(
+    if current_allowance < amount_to_check_wei:
+        amount_to_set_wei = amount_to_set_wei or amount_to_check_wei
+        ContractERC20BaseClass(address=sell_token).approve(
             api_keys,
             for_address=for_address,
-            amount_wei=amount_wei,
+            amount_wei=amount_to_set_wei,
             web3=web3,
         )
 
@@ -305,7 +307,10 @@ async def swap_tokens_waiting_async(
     wait_order_complete: bool = True,
 ) -> tuple[OrderMetaData | None, CompletedOrder]:
     handle_allowance(
-        api_keys=api_keys, sell_token=sell_token, amount_wei=amount_wei, web3=web3
+        api_keys=api_keys,
+        sell_token=sell_token,
+        amount_to_check_wei=amount_wei,
+        web3=web3,
     )
     valid_to = (utcnow() + timeout).timestamp()
     order = await place_swap_order(
@@ -375,7 +380,7 @@ def get_trades_by_order_uid(
     # Using this until cowpy gets fixed (https://github.com/cowdao-grants/cow-py/issues/35)
     response = httpx.get(
         f"https://api.cow.fi/xdai/api/v1/trades",
-        params={"orderUid": order_uid.hex()},
+        params={"orderUid": order_uid.to_0x_hex()},
     )
     response.raise_for_status()
     return [MinimalisticTrade.model_validate(i) for i in response.json()]

prediction_market_agent_tooling/tools/datetime_utc.py

@@ -34,8 +34,20 @@ class DatetimeUTC(datetime):
     def __get_pydantic_core_schema__(
         cls, source_type: t.Any, handler: GetCoreSchemaHandler
     ) -> CoreSchema:
-        dt_schema = handler(datetime)
-        return core_schema.no_info_after_validator_function(cls._validate, dt_schema)
+        # Use union schema to handle int, str, and datetime inputs directly
+        return core_schema.union_schema(
+            [
+                core_schema.no_info_after_validator_function(
+                    cls._validate, core_schema.int_schema()
+                ),
+                core_schema.no_info_after_validator_function(
+                    cls._validate, core_schema.str_schema()
+                ),
+                core_schema.no_info_after_validator_function(
+                    cls._validate, handler(datetime)
+                ),
+            ]
+        )
 
     @staticmethod
     def from_datetime(dt: datetime) -> "DatetimeUTC":

prediction_market_agent_tooling/tools/hexbytes_custom.py

@@ -11,7 +11,7 @@ from pydantic_core.core_schema import (
     with_info_before_validator_function,
 )
 
-hex_serializer = plain_serializer_function_ser_schema(function=lambda x: x.hex())
+hex_serializer = plain_serializer_function_ser_schema(function=lambda x: x.to_0x_hex())
 
 
 class BaseHex:
@@ -60,14 +60,8 @@ class HexBytes(HexBytesBase, BaseHex):
         value = hex_str[2:] if hex_str.startswith("0x") else hex_str
         return super().fromhex(value)
 
-    def hex(
-        self,
-        sep: t.Union[str, bytes] | None = None,
-        bytes_per_sep: t.SupportsIndex = 1,
-    ) -> str:
-        """We enforce a 0x prefix."""
-        x = super().hex(sep, bytes_per_sep)  # type: ignore[arg-type]
-        return x if x.startswith("0x") else "0x" + x
+    def __repr__(self) -> str:
+        return f'HexBytes("{self.to_0x_hex()}")'
 
     @classmethod
     def __eth_pydantic_validate__(

prediction_market_agent_tooling/tools/langfuse_client_utils.py

@@ -5,7 +5,9 @@ from langfuse import Langfuse
 from langfuse.client import TraceWithDetails
 from pydantic import BaseModel
 
+from prediction_market_agent_tooling.deploy.agent import MarketType
 from prediction_market_agent_tooling.loggers import logger
+from prediction_market_agent_tooling.markets.agent_market import AgentMarket
 from prediction_market_agent_tooling.markets.data_models import (
     CategoricalProbabilisticAnswer,
     PlacedTrade,
@@ -16,12 +18,13 @@ 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.markets.seer.seer import SeerAgentMarket
 from prediction_market_agent_tooling.tools.utils import DatetimeUTC
 
 
 class ProcessMarketTrace(BaseModel):
     timestamp: int
-    market: OmenAgentMarket
+    market: SeerAgentMarket | OmenAgentMarket
     answer: CategoricalProbabilisticAnswer
     trades: list[PlacedTrade]
 
@@ -40,13 +43,18 @@ class ProcessMarketTrace(BaseModel):
     def from_langfuse_trace(
         trace: TraceWithDetails,
     ) -> t.Optional["ProcessMarketTrace"]:
-        market = trace_to_omen_agent_market(trace)
+        market = trace_to_agent_market(trace)
         answer = trace_to_answer(trace)
         trades = trace_to_trades(trace)
 
         if not market or not answer or not trades:
             return None
 
+        if not isinstance(market, (SeerAgentMarket, OmenAgentMarket)):
+            raise ValueError(
+                f"Market type {type(market)} is not supported for ProcessMarketTrace"
+            )
+
         return ProcessMarketTrace(
             market=market,
             answer=answer,
@@ -105,17 +113,21 @@ def get_traces_for_agent(
     return all_agent_traces
 
 
-def trace_to_omen_agent_market(trace: TraceWithDetails) -> OmenAgentMarket | None:
+def trace_to_agent_market(trace: TraceWithDetails) -> AgentMarket | None:
     if not trace.input:
         logger.warning(f"No input in the trace: {trace}")
         return None
     if not trace.input["args"]:
         logger.warning(f"No args in the trace: {trace}")
         return None
-    assert len(trace.input["args"]) == 2 and trace.input["args"][0] == "omen"
+    assert len(trace.input["args"]) == 2
+
+    market_type = MarketType(trace.input["args"][0])
+    market_class = market_type.market_class
+
     try:
         # If the market model is invalid (e.g. outdated), it will raise an exception
-        market = OmenAgentMarket.model_validate(trace.input["args"][1])
+        market = market_class.model_validate(trace.input["args"][1])
         return market
     except Exception as e:
         logger.warning(f"Market not parsed from langfuse because: {e}")

prediction_market_agent_tooling/tools/tokens/auto_deposit.py

@@ -194,7 +194,7 @@ def mint_full_set(
     # of the child market.
     seer_subgraph_handler = SeerSubgraphHandler()
     market = seer_subgraph_handler.get_market_by_wrapped_token(
-        token=collateral_token_contract.address
+        tokens=[collateral_token_contract.address]
     )
     market_collateral_token = Web3.to_checksum_address(market.collateral_token)
 
@@ -215,7 +215,7 @@ def mint_full_set(
     handle_allowance(
         api_keys=api_keys,
         sell_token=market_collateral_token,
-        amount_wei=collateral_amount_wei,
+        amount_to_check_wei=collateral_amount_wei,
         for_address=router.address,
         web3=web3,
     )

prediction_market_agent_tooling/tools/tokens/usd.py

@@ -10,6 +10,9 @@ from prediction_market_agent_tooling.markets.omen.omen_constants import (
     SDAI_CONTRACT_ADDRESS,
     WRAPPED_XDAI_CONTRACT_ADDRESS,
 )
+from prediction_market_agent_tooling.markets.polymarket.polymarket_contracts import (
+    USDCeContract,
+)
 from prediction_market_agent_tooling.tools.contract import ContractERC4626OnGnosisChain
 from prediction_market_agent_tooling.tools.cow.cow_order import (
     get_buy_token_amount_else_raise,
@@ -39,8 +42,8 @@ def get_token_in_usd(amount: CollateralToken, token_address: ChecksumAddress) ->
 # A short cache to not spam CoW and prevent timeouts, but still have relatively fresh data.
 @cached(TTLCache(maxsize=100, ttl=5 * 60))
 def get_single_token_to_usd_rate(token_address: ChecksumAddress) -> USD:
-    # (w)xDai is a stable coin against USD, so use it to estimate USD worth.
-    if WRAPPED_XDAI_CONTRACT_ADDRESS == token_address:
+    # (w)xDai and USDC are stablecoins pegged to USD, so use it to estimate USD worth.
+    if token_address in [WRAPPED_XDAI_CONTRACT_ADDRESS, USDCeContract().address]:
         return USD(1.0)
     # sDai is ERC4626 with wxDai as asset, we can take the rate directly from there instead of calling CoW.
     if SDAI_CONTRACT_ADDRESS == token_address:

prediction_market_agent_tooling/tools/web3_utils.py

@@ -9,6 +9,7 @@ from eth_typing import URI
 from eth_utils.currency import MAX_WEI, MIN_WEI
 from pydantic.types import SecretStr
 from safe_eth.eth import EthereumClient
+from safe_eth.eth.ethereum_client import TxSpeed
 from safe_eth.safe.safe import SafeV141
 from web3 import Web3
 from web3.constants import HASH_ZERO
@@ -104,7 +105,9 @@ def call_function_on_contract(
     function_params: Optional[list[Any] | dict[str, Any]] = None,
 ) -> Any:
     contract = web3.eth.contract(address=contract_address, abi=contract_abi)
-    output = contract.functions[function_name](*parse_function_params(function_params)).call()  # type: ignore # TODO: Fix Mypy, as this works just OK.
+    output = contract.functions[function_name](
+        *parse_function_params(function_params)
+    ).call()
     return output
 
 
@@ -120,9 +123,10 @@ def prepare_tx(
 ) -> TxParams:
     tx_params_new = _prepare_tx_params(web3, from_address, access_list, tx_params)
     contract = web3.eth.contract(address=contract_address, abi=contract_abi)
-
     # Build the transaction.
-    function_call = contract.functions[function_name](*parse_function_params(function_params))  # type: ignore # TODO: Fix Mypy, as this works just OK.
+    function_call = contract.functions[function_name](
+        *parse_function_params(function_params)
+    )
     built_tx_params: TxParams = function_call.build_transaction(tx_params_new)
     return built_tx_params
 
@@ -269,6 +273,7 @@ def send_function_on_contract_tx_using_safe(
     tx_hash, tx = safe_tx.execute(
         from_private_key.get_secret_value(),
         tx_nonce=eoa_nonce,
+        eip1559_speed=TxSpeed.FAST,
     )
     receipt_tx = web3.eth.wait_for_transaction_receipt(tx_hash, timeout=timeout)
     check_tx_receipt(receipt_tx)
@@ -286,7 +291,7 @@ def sign_send_and_get_receipt_tx(
         tx_params_new, private_key=from_private_key.get_secret_value()
     )
     # Send the signed transaction.
-    send_tx = web3.eth.send_raw_transaction(signed_tx.rawTransaction)
+    send_tx = web3.eth.send_raw_transaction(signed_tx.raw_transaction)
     # And wait for the receipt.
     receipt_tx = web3.eth.wait_for_transaction_receipt(send_tx, timeout=timeout)
     # Verify it didn't fail.