prediction-market-agent-tooling 0.65.9__py3-none-any.whl → 0.65.10__py3-none-any.whl

prediction_market_agent_tooling/abis/swapr_router.abi.json

@@ -0,0 +1,634 @@
+[
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "_factory",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "_WNativeToken",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "_poolDeployer",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "constructor"
+  },
+  {
+    "inputs": [],
+    "name": "WNativeToken",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "int256",
+        "name": "amount0Delta",
+        "type": "int256"
+      },
+      {
+        "internalType": "int256",
+        "name": "amount1Delta",
+        "type": "int256"
+      },
+      {
+        "internalType": "bytes",
+        "name": "_data",
+        "type": "bytes"
+      }
+    ],
+    "name": "algebraSwapCallback",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "components": [
+          {
+            "internalType": "bytes",
+            "name": "path",
+            "type": "bytes"
+          },
+          {
+            "internalType": "address",
+            "name": "recipient",
+            "type": "address"
+          },
+          {
+            "internalType": "uint256",
+            "name": "deadline",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint256",
+            "name": "amountIn",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint256",
+            "name": "amountOutMinimum",
+            "type": "uint256"
+          }
+        ],
+        "internalType": "struct ISwapRouter.ExactInputParams",
+        "name": "params",
+        "type": "tuple"
+      }
+    ],
+    "name": "exactInput",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountOut",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "components": [
+          {
+            "internalType": "address",
+            "name": "tokenIn",
+            "type": "address"
+          },
+          {
+            "internalType": "address",
+            "name": "tokenOut",
+            "type": "address"
+          },
+          {
+            "internalType": "address",
+            "name": "recipient",
+            "type": "address"
+          },
+          {
+            "internalType": "uint256",
+            "name": "deadline",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint256",
+            "name": "amountIn",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint256",
+            "name": "amountOutMinimum",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint160",
+            "name": "limitSqrtPrice",
+            "type": "uint160"
+          }
+        ],
+        "internalType": "struct ISwapRouter.ExactInputSingleParams",
+        "name": "params",
+        "type": "tuple"
+      }
+    ],
+    "name": "exactInputSingle",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountOut",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "components": [
+          {
+            "internalType": "address",
+            "name": "tokenIn",
+            "type": "address"
+          },
+          {
+            "internalType": "address",
+            "name": "tokenOut",
+            "type": "address"
+          },
+          {
+            "internalType": "address",
+            "name": "recipient",
+            "type": "address"
+          },
+          {
+            "internalType": "uint256",
+            "name": "deadline",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint256",
+            "name": "amountIn",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint256",
+            "name": "amountOutMinimum",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint160",
+            "name": "limitSqrtPrice",
+            "type": "uint160"
+          }
+        ],
+        "internalType": "struct ISwapRouter.ExactInputSingleParams",
+        "name": "params",
+        "type": "tuple"
+      }
+    ],
+    "name": "exactInputSingleSupportingFeeOnTransferTokens",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountOut",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "components": [
+          {
+            "internalType": "bytes",
+            "name": "path",
+            "type": "bytes"
+          },
+          {
+            "internalType": "address",
+            "name": "recipient",
+            "type": "address"
+          },
+          {
+            "internalType": "uint256",
+            "name": "deadline",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint256",
+            "name": "amountOut",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint256",
+            "name": "amountInMaximum",
+            "type": "uint256"
+          }
+        ],
+        "internalType": "struct ISwapRouter.ExactOutputParams",
+        "name": "params",
+        "type": "tuple"
+      }
+    ],
+    "name": "exactOutput",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountIn",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "components": [
+          {
+            "internalType": "address",
+            "name": "tokenIn",
+            "type": "address"
+          },
+          {
+            "internalType": "address",
+            "name": "tokenOut",
+            "type": "address"
+          },
+          {
+            "internalType": "uint24",
+            "name": "fee",
+            "type": "uint24"
+          },
+          {
+            "internalType": "address",
+            "name": "recipient",
+            "type": "address"
+          },
+          {
+            "internalType": "uint256",
+            "name": "deadline",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint256",
+            "name": "amountOut",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint256",
+            "name": "amountInMaximum",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint160",
+            "name": "limitSqrtPrice",
+            "type": "uint160"
+          }
+        ],
+        "internalType": "struct ISwapRouter.ExactOutputSingleParams",
+        "name": "params",
+        "type": "tuple"
+      }
+    ],
+    "name": "exactOutputSingle",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountIn",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "factory",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes[]",
+        "name": "data",
+        "type": "bytes[]"
+      }
+    ],
+    "name": "multicall",
+    "outputs": [
+      {
+        "internalType": "bytes[]",
+        "name": "results",
+        "type": "bytes[]"
+      }
+    ],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "poolDeployer",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "refundNativeToken",
+    "outputs": [],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "token",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "value",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "deadline",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint8",
+        "name": "v",
+        "type": "uint8"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "r",
+        "type": "bytes32"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "s",
+        "type": "bytes32"
+      }
+    ],
+    "name": "selfPermit",
+    "outputs": [],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "token",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "nonce",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "expiry",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint8",
+        "name": "v",
+        "type": "uint8"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "r",
+        "type": "bytes32"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "s",
+        "type": "bytes32"
+      }
+    ],
+    "name": "selfPermitAllowed",
+    "outputs": [],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "token",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "nonce",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "expiry",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint8",
+        "name": "v",
+        "type": "uint8"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "r",
+        "type": "bytes32"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "s",
+        "type": "bytes32"
+      }
+    ],
+    "name": "selfPermitAllowedIfNecessary",
+    "outputs": [],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "token",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "value",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "deadline",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint8",
+        "name": "v",
+        "type": "uint8"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "r",
+        "type": "bytes32"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "s",
+        "type": "bytes32"
+      }
+    ],
+    "name": "selfPermitIfNecessary",
+    "outputs": [],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "token",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountMinimum",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address",
+        "name": "recipient",
+        "type": "address"
+      }
+    ],
+    "name": "sweepToken",
+    "outputs": [],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "token",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "amountMinimum",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address",
+        "name": "recipient",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "feeBips",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address",
+        "name": "feeRecipient",
+        "type": "address"
+      }
+    ],
+    "name": "sweepTokenWithFee",
+    "outputs": [],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountMinimum",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address",
+        "name": "recipient",
+        "type": "address"
+      }
+    ],
+    "name": "unwrapWNativeToken",
+    "outputs": [],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "amountMinimum",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address",
+        "name": "recipient",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "feeBips",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address",
+        "name": "feeRecipient",
+        "type": "address"
+      }
+    ],
+    "name": "unwrapWNativeTokenWithFee",
+    "outputs": [],
+    "stateMutability": "payable",
+    "type": "function"
+  },
+  {
+    "stateMutability": "payable",
+    "type": "receive"
+  }
+]

prediction_market_agent_tooling/benchmark/benchmark.py

@@ -456,4 +456,4 @@ class Benchmarker:
         md += "\n\n"
         md += "### Markets\n\n"
         md += pd.DataFrame(self.get_markets_summary()).to_markdown(index=False)
-        return md
+        return str(md)

prediction_market_agent_tooling/markets/seer/data_models.py

@@ -1,4 +1,5 @@
 import typing as t
+from datetime import timedelta
 from urllib.parse import urljoin
 
 from pydantic import BaseModel, ConfigDict, Field
@@ -13,12 +14,14 @@ from prediction_market_agent_tooling.gtypes import (
     OutcomeStr,
     OutcomeWei,
     Web3Wei,
+    Wei,
 )
 from prediction_market_agent_tooling.markets.seer.subgraph_data_models import (
     SeerParentMarket,
 )
 from prediction_market_agent_tooling.tools.contract import ContractERC20OnGnosisChain
 from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
+from prediction_market_agent_tooling.tools.utils import utcnow
 
 
 class CreateCategoricalMarketsParams(BaseModel):
@@ -133,3 +136,19 @@ class RedeemParams(BaseModel):
     market: ChecksumAddress
     outcome_indices: list[int] = Field(alias="outcomeIndexes")
     amounts: list[OutcomeWei]
+
+
+class ExactInputSingleParams(BaseModel):
+    # from https://gnosisscan.io/address/0xffb643e73f280b97809a8b41f7232ab401a04ee1#code
+    model_config = ConfigDict(populate_by_name=True)
+    token_in: ChecksumAddress = Field(alias="tokenIn")
+    token_out: ChecksumAddress = Field(alias="tokenOut")
+    recipient: ChecksumAddress
+    deadline: int = Field(
+        default_factory=lambda: int((utcnow() + timedelta(minutes=10)).timestamp())
+    )
+    amount_in: Wei = Field(alias="amountIn")
+    amount_out_minimum: Wei = Field(alias="amountOutMinimum")
+    limit_sqrt_price: Wei = Field(
+        alias="limitSqrtPrice", default_factory=lambda: Wei(0)
+    )  # 0 for convenience, we also don't expect major price shifts

prediction_market_agent_tooling/markets/seer/seer.py

@@ -1,3 +1,4 @@
+import asyncio
 import typing as t
 from datetime import timedelta
 
@@ -15,6 +16,7 @@ from prediction_market_agent_tooling.gtypes import (
     OutcomeStr,
     OutcomeToken,
     OutcomeWei,
+    Wei,
     xDai,
 )
 from prediction_market_agent_tooling.loggers import logger
@@ -46,16 +48,21 @@ from prediction_market_agent_tooling.markets.seer.seer_subgraph_handler import (
 from prediction_market_agent_tooling.markets.seer.subgraph_data_models import (
     NewMarketEvent,
 )
+from prediction_market_agent_tooling.markets.seer.swap_pool_handler import (
+    SwapPoolHandler,
+)
 from prediction_market_agent_tooling.tools.contract import (
     ContractERC20OnGnosisChain,
     init_collateral_token_contract,
     to_gnosis_chain_contract,
 )
 from prediction_market_agent_tooling.tools.cow.cow_order import (
+    cancel_order,
     get_buy_token_amount_else_raise,
     get_orders_by_owner,
     get_trades_by_owner,
     swap_tokens_waiting,
+    wait_for_order_completion,
 )
 from prediction_market_agent_tooling.tools.datetime_utc import DatetimeUTC
 from prediction_market_agent_tooling.tools.tokens.auto_deposit import (
@@ -441,6 +448,60 @@ class SeerAgentMarket(AgentMarket):
         outcome_idx = self.outcomes.index(outcome)
         return self.wrapped_tokens[outcome_idx]
 
+    def _swap_tokens_with_fallback(
+        self,
+        sell_token: ChecksumAddress,
+        buy_token: ChecksumAddress,
+        amount_wei: Wei,
+        api_keys: APIKeys,
+        web3: Web3 | None,
+    ) -> str:
+        """
+        Helper method to swap tokens with a fallback to direct pool swapping if the order times out.
+
+        Args:
+            sell_token: Address of the token to sell
+            buy_token: Address of the token to buy
+            amount_wei: Amount to swap in wei
+            api_keys: API keys for the transaction
+            web3: Web3 instance
+
+        Returns:
+            Transaction hash of the successful swap
+        """
+        _, order = swap_tokens_waiting(
+            amount_wei=amount_wei,
+            sell_token=sell_token,
+            buy_token=buy_token,
+            api_keys=api_keys,
+            web3=web3,
+            wait_order_complete=False,
+        )
+
+        try:
+            order_metadata = asyncio.run(wait_for_order_completion(order=order))
+            logger.debug(
+                f"Swapped {sell_token} for {buy_token}. Order details {order_metadata}"
+            )
+            return order_metadata.uid.root
+
+        except TimeoutError:
+            # Since timeout occurred, we need to cancel the order before trying to swap again.
+            asyncio.run(cancel_order(order_uids=[order.uid.root], api_keys=api_keys))
+            logger.info("TimeoutError. Trying to swap directly on Swapr pools.")
+
+            tx_receipt = SwapPoolHandler(
+                api_keys=api_keys,
+                market_id=self.id,
+                collateral_token_address=self.collateral_token_contract_address_checksummed,
+            ).buy_or_sell_outcome_token(
+                token_in=sell_token,
+                token_out=buy_token,
+                amount_wei=amount_wei,
+                web3=web3,
+            )
+            return tx_receipt["transactionHash"].hex()
+
     def place_bet(
         self,
         outcome: OutcomeStr,
@@ -449,6 +510,7 @@ class SeerAgentMarket(AgentMarket):
         web3: Web3 | None = None,
         api_keys: APIKeys | None = None,
     ) -> str:
+        outcome_token = self.get_wrapped_token_for_outcome(outcome)
         api_keys = api_keys if api_keys is not None else APIKeys()
         if not self.can_be_traded():
             raise ValueError(
@@ -464,27 +526,21 @@ class SeerAgentMarket(AgentMarket):
                 collateral_contract, amount_wei, api_keys, web3
             )
 
-        collateral_balance = collateral_contract.balanceOf(api_keys.bet_from_address)
+        collateral_balance = collateral_contract.balanceOf(
+            api_keys.bet_from_address, web3=web3
+        )
         if collateral_balance < amount_wei:
             raise ValueError(
                 f"Balance {collateral_balance} not enough for bet size {amount}"
             )
 
-        outcome_token = self.get_wrapped_token_for_outcome(outcome)
-
-        #  Sell sDAI using token address
-        order_metadata = swap_tokens_waiting(
-            amount_wei=amount_wei,
+        return self._swap_tokens_with_fallback(
             sell_token=collateral_contract.address,
             buy_token=outcome_token,
+            amount_wei=amount_wei,
             api_keys=api_keys,
             web3=web3,
         )
-        logger.debug(
-            f"Purchased {outcome_token} in exchange for {collateral_contract.address}. Order details {order_metadata}"
-        )
-
-        return order_metadata.uid.root
 
     def sell_tokens(
         self,
@@ -506,21 +562,27 @@ class SeerAgentMarket(AgentMarket):
             else self.get_in_token(amount).as_wei
         )
 
-        order_metadata = swap_tokens_waiting(
-            amount_wei=token_amount,
+        return self._swap_tokens_with_fallback(
             sell_token=outcome_token,
             buy_token=Web3.to_checksum_address(
                 self.collateral_token_contract_address_checksummed
             ),
+            amount_wei=token_amount,
             api_keys=api_keys,
             web3=web3,
         )
 
-        logger.debug(
-            f"Sold {outcome_token} in exchange for {self.collateral_token_contract_address_checksummed}. Order details {order_metadata}"
+    def get_token_balance(
+        self, user_id: str, outcome: OutcomeStr, web3: Web3 | None = None
+    ) -> OutcomeToken:
+        erc20_token = ContractERC20OnGnosisChain(
+            address=self.get_wrapped_token_for_outcome(outcome)
+        )
+        return OutcomeToken.from_token(
+            erc20_token.balance_of_in_tokens(
+                for_address=Web3.to_checksum_address(user_id), web3=web3
+            )
         )
-
-        return order_metadata.uid.root
 
 
 def seer_create_market_tx(

prediction_market_agent_tooling/markets/seer/seer_contracts.py

@@ -11,11 +11,15 @@ from prediction_market_agent_tooling.gtypes import (
     TxReceipt,
     xDai,
 )
-from prediction_market_agent_tooling.markets.seer.data_models import RedeemParams
+from prediction_market_agent_tooling.markets.seer.data_models import (
+    ExactInputSingleParams,
+    RedeemParams,
+)
 from prediction_market_agent_tooling.markets.seer.subgraph_data_models import (
     CreateCategoricalMarketsParams,
 )
 from prediction_market_agent_tooling.tools.contract import (
+    ContractERC20OnGnosisChain,
     ContractOnGnosisChain,
     abi_field_validator,
 )
@@ -110,3 +114,38 @@ class GnosisRouter(ContractOnGnosisChain):
             web3=web3,
         )
         return receipt_tx
+
+
+class SwaprRouterContract(ContractOnGnosisChain):
+    # File content taken from https://github.com/protofire/omen-exchange/blob/master/app/src/abi/marketMaker.json.
+    abi: ABI = abi_field_validator(
+        os.path.join(
+            os.path.dirname(os.path.realpath(__file__)),
+            "../../abis/swapr_router.abi.json",
+        )
+    )
+
+    address: ChecksumAddress = Web3.to_checksum_address(
+        "0xffb643e73f280b97809a8b41f7232ab401a04ee1"
+    )
+
+    def exact_input_single(
+        self,
+        api_keys: APIKeys,
+        params: ExactInputSingleParams,
+        web3: Web3 | None = None,
+    ) -> TxReceipt:
+        erc20_token = ContractERC20OnGnosisChain(address=params.token_in)
+
+        if (
+            erc20_token.allowance(api_keys.bet_from_address, self.address, web3=web3)
+            < params.amount_in
+        ):
+            erc20_token.approve(api_keys, self.address, params.amount_in, web3=web3)
+
+        return self.send(
+            api_keys=api_keys,
+            function_name="exactInputSingle",
+            function_params=[tuple(dict(params).values())],
+            web3=web3,
+        )

prediction_market_agent_tooling/markets/seer/swap_pool_handler.py

@@ -0,0 +1,96 @@
+from web3 import Web3
+
+from prediction_market_agent_tooling.config import APIKeys
+from prediction_market_agent_tooling.gtypes import (
+    ChecksumAddress,
+    CollateralToken,
+    HexBytes,
+    HexStr,
+    TxReceipt,
+    Wei,
+)
+from prediction_market_agent_tooling.markets.seer.data_models import (
+    ExactInputSingleParams,
+)
+from prediction_market_agent_tooling.markets.seer.price_manager import PriceManager
+from prediction_market_agent_tooling.markets.seer.seer_contracts import (
+    SwaprRouterContract,
+)
+from prediction_market_agent_tooling.markets.seer.seer_subgraph_handler import (
+    SeerSubgraphHandler,
+)
+
+
+class SwapPoolHandler:
+    def __init__(
+        self,
+        api_keys: APIKeys,
+        market_id: str,
+        collateral_token_address: ChecksumAddress,
+        seer_subgraph: SeerSubgraphHandler | None = None,
+    ):
+        self.api_keys = api_keys
+        self.market_id = market_id
+        self.collateral_token_address = collateral_token_address
+        self.seer_subgraph = seer_subgraph or SeerSubgraphHandler()
+
+    def _calculate_amount_out_minimum(
+        self,
+        amount_wei: Wei,
+        token_in: ChecksumAddress,
+        price_outcome_token: CollateralToken,
+        buffer_pct: float = 0.05,
+    ) -> Wei:
+        is_buying_outcome = token_in == self.collateral_token_address
+
+        if is_buying_outcome:
+            value = amount_wei.value * (1.0 - buffer_pct) / price_outcome_token.value
+        else:
+            value = amount_wei.value * price_outcome_token.value * (1.0 - buffer_pct)
+        return Wei(int(value))
+
+    def buy_or_sell_outcome_token(
+        self,
+        amount_wei: Wei,
+        token_in: ChecksumAddress,
+        token_out: ChecksumAddress,
+        web3: Web3 | None = None,
+    ) -> TxReceipt:
+        """Buys/sells outcome_tokens in exchange for collateral tokens"""
+        if self.collateral_token_address not in [token_in, token_out]:
+            raise ValueError(
+                f"trading outcome_token for a token different than collateral_token {self.collateral_token_address} is not supported. {token_in=} {token_out=}"
+            )
+
+        outcome_token = (
+            token_in if token_in != self.collateral_token_address else token_out
+        )
+
+        # We could use a quoter contract (https://github.com/SwaprHQ/swapr-sdk/blob/develop/src/entities/trades/swapr-v3/constants.ts#L7), but since there is normally 1 pool per outcome token/collateral pair, it's not necessary.
+
+        price_outcome_token = PriceManager.build(
+            HexBytes(HexStr(self.market_id))
+        ).get_token_price_from_pools(token=outcome_token)
+        if not price_outcome_token:
+            raise ValueError(
+                f"Could not find price for {outcome_token=} and {self.collateral_token_address}"
+            )
+
+        amount_out_minimum = self._calculate_amount_out_minimum(
+            amount_wei=amount_wei,
+            token_in=token_in,
+            price_outcome_token=price_outcome_token,
+        )
+
+        p = ExactInputSingleParams(
+            token_in=token_in,
+            token_out=token_out,
+            recipient=self.api_keys.bet_from_address,
+            amount_in=amount_wei,
+            amount_out_minimum=amount_out_minimum,
+        )
+
+        tx_receipt = SwaprRouterContract().exact_input_single(
+            api_keys=self.api_keys, params=p, web3=web3
+        )
+        return tx_receipt

prediction_market_agent_tooling/tools/cow/cow_order.py

@@ -9,11 +9,17 @@ from cowdao_cowpy.common.api.errors import UnexpectedResponseError
 from cowdao_cowpy.common.chains import Chain
 from cowdao_cowpy.common.config import SupportedChainId
 from cowdao_cowpy.common.constants import CowContractAddress
+from cowdao_cowpy.contracts.domain import domain
+from cowdao_cowpy.contracts.sign import SigningScheme, sign_order_cancellations
 from cowdao_cowpy.cow.swap import CompletedOrder, get_order_quote, swap_tokens
 from cowdao_cowpy.order_book.api import OrderBookApi
 from cowdao_cowpy.order_book.config import Envs, OrderBookAPIConfigFactory
 from cowdao_cowpy.order_book.generated.model import (
+    UID,
     Address,
+    EcdsaSignature,
+    EcdsaSigningScheme,
+    OrderCancellations,
     OrderMetaData,
     OrderQuoteRequest,
     OrderQuoteResponse,
@@ -24,6 +30,9 @@ from cowdao_cowpy.order_book.generated.model import (
     OrderStatus,
     TokenAmount,
 )
+from eth_account import Account
+from eth_account.signers.local import LocalAccount
+from eth_keys.datatypes import PrivateKey as eth_keys_PrivateKey
 from tenacity import (
     retry_if_not_exception_type,
     stop_after_attempt,
@@ -33,7 +42,13 @@ from tenacity import (
 from web3 import Web3
 
 from prediction_market_agent_tooling.config import APIKeys
-from prediction_market_agent_tooling.gtypes import ChecksumAddress, HexBytes, Wei
+from prediction_market_agent_tooling.gtypes import (
+    ChecksumAddress,
+    HexBytes,
+    HexStr,
+    PrivateKey,
+    Wei,
+)
 from prediction_market_agent_tooling.loggers import logger
 from prediction_market_agent_tooling.markets.omen.cow_contracts import (
     CowGPv2SettlementContract,
@@ -153,21 +168,12 @@ def get_buy_token_amount_else_raise(
     return Wei(order_quote.quote.buyAmount.root)
 
 
-@tenacity.retry(
-    stop=stop_after_attempt(3),
-    wait=wait_fixed(1),
-    retry=tenacity.retry_if_not_exception_type((TimeoutError, OrderStatusError)),
-    after=lambda x: logger.debug(f"swap_tokens_waiting failed, {x.attempt_number=}."),
-)
-def swap_tokens_waiting(
-    amount_wei: Wei,
-    sell_token: ChecksumAddress,
-    buy_token: ChecksumAddress,
+def handle_allowance(
     api_keys: APIKeys,
-    chain: Chain = Chain.GNOSIS,
-    env: Envs = "prod",
+    sell_token: ChecksumAddress,
+    amount_wei: Wei,
     web3: Web3 | None = None,
-) -> OrderMetaData:
+) -> None:
     # Approve the CoW Swap Vault Relayer to get the sell token only if allowance not sufficient.
     for_address = Web3.to_checksum_address(CowContractAddress.VAULT_RELAYER.value)
     current_allowance = ContractERC20OnGnosisChain(address=sell_token).allowance(
@@ -183,24 +189,47 @@ def swap_tokens_waiting(
             web3=web3,
         )
 
+
+@tenacity.retry(
+    stop=stop_after_attempt(3),
+    wait=wait_fixed(1),
+    retry=tenacity.retry_if_not_exception_type((TimeoutError, OrderStatusError)),
+    after=lambda x: logger.debug(f"swap_tokens_waiting failed, {x.attempt_number=}."),
+)
+def swap_tokens_waiting(
+    amount_wei: Wei,
+    sell_token: ChecksumAddress,
+    buy_token: ChecksumAddress,
+    api_keys: APIKeys,
+    chain: Chain = Chain.GNOSIS,
+    env: Envs = "prod",
+    web3: Web3 | None = None,
+    wait_order_complete: bool = True,
+) -> tuple[OrderMetaData | None, CompletedOrder]:
     # CoW library uses async, so we need to wrap the call in asyncio.run for us to use it.
     return asyncio.run(
         swap_tokens_waiting_async(
-            amount_wei, sell_token, buy_token, api_keys, chain, env
+            amount_wei,
+            sell_token,
+            buy_token,
+            api_keys,
+            chain,
+            env,
+            web3=web3,
+            wait_order_complete=wait_order_complete,
         )
     )
 
 
-async def swap_tokens_waiting_async(
+async def place_swap_order(
+    api_keys: APIKeys,
     amount_wei: Wei,
     sell_token: ChecksumAddress,
     buy_token: ChecksumAddress,
-    api_keys: APIKeys,
     chain: Chain,
     env: Envs,
-    timeout: timedelta = timedelta(seconds=120),
     slippage_tolerance: float = 0.01,
-) -> OrderMetaData:
+) -> CompletedOrder:
     account = api_keys.get_account()
     safe_address = api_keys.safe_address_checksum
 
@@ -220,6 +249,12 @@ async def swap_tokens_waiting_async(
         logger.info(f"Safe is used. Signing the order after its creation.")
         await sign_safe_cow_swap(api_keys, order, chain, env)
 
+    return order
+
+
+async def wait_for_order_completion(
+    order: CompletedOrder, timeout: timedelta = timedelta(seconds=120)
+) -> OrderMetaData:
     start_time = utcnow()
 
     while True:
@@ -249,6 +284,36 @@ async def swap_tokens_waiting_async(
         await asyncio.sleep(3.14)
 
 
+async def swap_tokens_waiting_async(
+    amount_wei: Wei,
+    sell_token: ChecksumAddress,
+    buy_token: ChecksumAddress,
+    api_keys: APIKeys,
+    chain: Chain,
+    env: Envs,
+    timeout: timedelta = timedelta(seconds=120),
+    slippage_tolerance: float = 0.01,
+    web3: Web3 | None = None,
+    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
+    )
+    order = await place_swap_order(
+        api_keys=api_keys,
+        amount_wei=amount_wei,
+        sell_token=sell_token,
+        buy_token=buy_token,
+        chain=chain,
+        env=env,
+        slippage_tolerance=slippage_tolerance,
+    )
+    if wait_order_complete:
+        order_metadata = await wait_for_order_completion(order=order, timeout=timeout)
+        return order_metadata, order
+    return None, order
+
+
 @tenacity.retry(
     stop=tenacity.stop_after_attempt(3),
     wait=tenacity.wait_fixed(1),
@@ -323,3 +388,33 @@ def paginate_endpoint(url: str, limit: int = 1000) -> t.Any:
         offset += limit
 
     return results
+
+
+async def cancel_order(
+    order_uids: t.Sequence[str],
+    api_keys: APIKeys,
+    chain: Chain = Chain.GNOSIS,
+    env: Envs = "prod",
+) -> None:
+    """Cancels orders that were created by the user corresponding to the api_keys.."""
+    order_domain = domain(
+        chain=chain, verifying_contract=CowContractAddress.SETTLEMENT_CONTRACT.value
+    )
+    owner = build_account(api_keys.bet_from_private_key)
+    order_signature = sign_order_cancellations(
+        order_domain, list(order_uids), owner, SigningScheme.EIP712
+    )
+    oc = OrderCancellations(
+        signature=EcdsaSignature(root=order_signature.data),
+        orderUids=[UID(root=order_uid) for order_uid in order_uids],
+        signingScheme=EcdsaSigningScheme.eip712,
+    )
+    order_book_api = get_order_book_api(env, chain)
+    await order_book_api.delete_order(orders_cancelation=oc)
+
+
+def build_account(private_key: PrivateKey) -> LocalAccount:
+    return LocalAccount(
+        key=eth_keys_PrivateKey(HexBytes(HexStr(private_key.get_secret_value()))),
+        account=Account.from_key(private_key.get_secret_value()),
+    )

prediction_market_agent_tooling/tools/web3_utils.py

@@ -67,17 +67,23 @@ def unwrap_generic_value(value: Any) -> Any:
         return value.value
     elif isinstance(value, list):
         return [unwrap_generic_value(v) for v in value]
+    elif isinstance(value, tuple):
+        return tuple(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]:
+def parse_function_params(
+    params: Optional[list[Any] | tuple[Any] | dict[str, Any]]
+) -> list[Any] | tuple[Any]:
     params = unwrap_generic_value(params)
     if params is None:
         return []
     if isinstance(params, list):
-        return params
+        return [unwrap_generic_value(i) for i in params]
+    if isinstance(params, tuple):
+        return tuple(unwrap_generic_value(i) for i in params)
     if isinstance(params, dict):
         return list(params.values())
     raise ValueError(f"Invalid type for function parameters: {type(params)}")
@@ -117,8 +123,8 @@ def prepare_tx(
 
     # Build the transaction.
     function_call = contract.functions[function_name](*parse_function_params(function_params))  # type: ignore # TODO: Fix Mypy, as this works just OK.
-    tx_params_new = function_call.build_transaction(tx_params_new)
-    return tx_params_new
+    built_tx_params: TxParams = function_call.build_transaction(tx_params_new)
+    return built_tx_params
 
 
 def _prepare_tx_params(

{prediction_market_agent_tooling-0.65.9.dist-info → prediction_market_agent_tooling-0.65.10.dist-info}/METADATA

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

{prediction_market_agent_tooling-0.65.9.dist-info → prediction_market_agent_tooling-0.65.10.dist-info}/RECORD

@@ -18,9 +18,10 @@ prediction_market_agent_tooling/abis/ownable_erc721.abi.json,sha256=9sxm588MAQmq
 prediction_market_agent_tooling/abis/proxy.abi.json,sha256=h24GXZ6Q0bSZlwh7zOv0EiDvbqUz_PHtWfKHTyPJ1w4,644
 prediction_market_agent_tooling/abis/seer_gnosis_router.abi.json,sha256=DyADzOXhy9MDS31ReVrG7ibpWbw1jVy19nExZ80xfRY,6839
 prediction_market_agent_tooling/abis/seer_market_factory.abi.json,sha256=g7RVxZVUWlTXIgTV2W6kO4twQM909Qv58zAr7Dk4XIc,13553
+prediction_market_agent_tooling/abis/swapr_router.abi.json,sha256=Y1wK20D1-zdbdlzkzV0BHY-HXMJrog6dgSHEzKzrQOU,13346
 prediction_market_agent_tooling/benchmark/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/benchmark/agents.py,sha256=zC5tUM6pPTWtqSddOOSYV_fxHYmZb5uGAb4Ru87Tah8,4221
-prediction_market_agent_tooling/benchmark/benchmark.py,sha256=KwMZzwise3sgmhdjw7xCgHMmjKHdHqQC-zc9untOLWg,17832
+prediction_market_agent_tooling/benchmark/benchmark.py,sha256=hpIpjjePDFTLhK841sGftFbhu8bDDZr28KO4VTneewM,17837
 prediction_market_agent_tooling/benchmark/utils.py,sha256=xQd7p9H08-OtN3iC4QT2i9bkUTmrXa6rxGXeg9yMhgU,2986
 prediction_market_agent_tooling/chains.py,sha256=1qQstoqXMwqwM7k-KH7MjMz8Ei-D83KZByvDbCZpAxs,116
 prediction_market_agent_tooling/config.py,sha256=-kJfdDr-m0R-tGZ1KRI-hJJk0mXDt142CAlvwaJ2N2I,11778
@@ -66,13 +67,14 @@ prediction_market_agent_tooling/markets/polymarket/data_models.py,sha256=U1SXTz9
 prediction_market_agent_tooling/markets/polymarket/data_models_web.py,sha256=wCwpZ8Kppy8JG_1HZDfEK_Gg1g1sL7NCbGoPeTeMSko,12756
 prediction_market_agent_tooling/markets/polymarket/polymarket.py,sha256=meAhQ5_gwVDvlSxhGGVAvRB7B47zKLnRvZ-_13tKtwY,3433
 prediction_market_agent_tooling/markets/polymarket/utils.py,sha256=8kTeVjXPcXC6DkDvWYsZQLY7x8DS6CEp_yznSEazsNU,2037
-prediction_market_agent_tooling/markets/seer/data_models.py,sha256=G0i-fnVaK16KWDYVI6w3lvyte6Op7ca_iIC8IfrXmlM,4702
+prediction_market_agent_tooling/markets/seer/data_models.py,sha256=osM9WaLsxQf-pfVGq0O-IkM93ehP9a7fVUf-hi2VlMs,5523
 prediction_market_agent_tooling/markets/seer/exceptions.py,sha256=cEObdjluivD94tgOLzmimR7wgQEOt6SRakrYdhsRQtk,112
 prediction_market_agent_tooling/markets/seer/price_manager.py,sha256=MClY2NGwOV70nZYIcmzXFy6Ogd8NBIq7telQcQ3VcU4,6243
-prediction_market_agent_tooling/markets/seer/seer.py,sha256=IsFK8XXjHq8UBvIkueiWpm_b3ddMslr84DqF_qNFQw0,21745
-prediction_market_agent_tooling/markets/seer/seer_contracts.py,sha256=kH9nPXsx6UM5er42g2f3fLvy36sY5JM2f_beXeuNgUc,3790
+prediction_market_agent_tooling/markets/seer/seer.py,sha256=_2Ld3EepmZuzpgAmW6f7eAS5-geXE25XgUKPUrFCWoI,23864
+prediction_market_agent_tooling/markets/seer/seer_contracts.py,sha256=uMzpHpI6_tgfhWxPzupLdUJlZ1P2wr0rRiYjAGClKgU,4984
 prediction_market_agent_tooling/markets/seer/seer_subgraph_handler.py,sha256=pJxch9_u0EdiIatQP1-UFClt8UEfMZAXBlk5wDO_ovk,9940
 prediction_market_agent_tooling/markets/seer/subgraph_data_models.py,sha256=0izxS8Mtzonfdl9UqvFVXrdj0hVzieroekXhogfZKCw,1817
+prediction_market_agent_tooling/markets/seer/swap_pool_handler.py,sha256=y0pDL2BoxayROy3warEN3r8Fs3rPCPPZ191bgrgZikg,3403
 prediction_market_agent_tooling/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 prediction_market_agent_tooling/tools/_generic_value.py,sha256=pD_PI13lpPp1gFoljHwa_Lzlp-u2pu0m-Z7LcxwDM2U,10618
 prediction_market_agent_tooling/tools/balances.py,sha256=Osab21btfJDw2Y-jT_TV-KHGrseCRxcsYeW6WcOMB8E,1050
@@ -84,7 +86,7 @@ prediction_market_agent_tooling/tools/caches/inmemory_cache.py,sha256=ZW5iI5rmjq
 prediction_market_agent_tooling/tools/caches/serializers.py,sha256=vFDx4fsPxclXp2q0sv27j4al_M_Tj9aR2JJP-xNHQXA,2151
 prediction_market_agent_tooling/tools/contract.py,sha256=pdr9ZYmj4QVUfgVKdvOU6ucYdBpJGdha_FMR_LgtcEs,22912
 prediction_market_agent_tooling/tools/costs.py,sha256=EaAJ7v9laD4VEV3d8B44M4u3_oEO_H16jRVCdoZ93Uw,954
-prediction_market_agent_tooling/tools/cow/cow_order.py,sha256=KpklYy5DY3j-aIlf6dB_o0mEX4MD3fqMiZK3tJs5Gro,10129
+prediction_market_agent_tooling/tools/cow/cow_order.py,sha256=yTUG6VPVe292R_5IG8F90kfZfAeun8G1TL6mHsnaXM0,12984
 prediction_market_agent_tooling/tools/cow/models.py,sha256=ZWGW0og5vXjgZVXxkx4uV2m61Q8AmL-L-D_D4f7ApR0,379
 prediction_market_agent_tooling/tools/custom_exceptions.py,sha256=Fh8z1fbwONvP4-j7AmV_PuEcoqb6-QXa9PJ9m7guMcM,93
 prediction_market_agent_tooling/tools/datetime_utc.py,sha256=8_WackjtjC8zHXrhQFTGQ6e6Fz_6llWoKR4CSFvIv9I,2766
@@ -120,9 +122,9 @@ prediction_market_agent_tooling/tools/tokens/token_utils.py,sha256=fhs-FH9m9IbzG
 prediction_market_agent_tooling/tools/tokens/usd.py,sha256=yuW8iPPtcpP4eLH2nORMDAfztcq0Nv2ascSrCquF1f8,3115
 prediction_market_agent_tooling/tools/transaction_cache.py,sha256=K5YKNL2_tR10Iw2TD9fuP-CTGpBbZtNdgbd0B_R7pjg,1814
 prediction_market_agent_tooling/tools/utils.py,sha256=RlWSlzS2LavMIWrpwn1fevbzgPZruD4VcXTa-XxjWnE,7343
-prediction_market_agent_tooling/tools/web3_utils.py,sha256=zRq-eeBGWt8uUGN9G_WfjmJ0eVvO8aWE9S0Pz_Y6AOA,12342
-prediction_market_agent_tooling-0.65.9.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
-prediction_market_agent_tooling-0.65.9.dist-info/METADATA,sha256=fwrbaHBiT91jMhqYkTWJ-vPB2dav-bxrgqfV7oDjGHY,8734
-prediction_market_agent_tooling-0.65.9.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-prediction_market_agent_tooling-0.65.9.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
-prediction_market_agent_tooling-0.65.9.dist-info/RECORD,,
+prediction_market_agent_tooling/tools/web3_utils.py,sha256=0r26snqCXGdLKCWA8jpe7DV8x2NPYWZwOy4oyKyDCYk,12615
+prediction_market_agent_tooling-0.65.10.dist-info/LICENSE,sha256=6or154nLLU6bELzjh0mCreFjt0m2v72zLi3yHE0QbeE,7650
+prediction_market_agent_tooling-0.65.10.dist-info/METADATA,sha256=vlhpH2uSRf9E9HKpHsW3ovlHqMl-rFt_GqyJqxjH5ao,8735
+prediction_market_agent_tooling-0.65.10.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+prediction_market_agent_tooling-0.65.10.dist-info/entry_points.txt,sha256=m8PukHbeH5g0IAAmOf_1Ahm-sGAMdhSSRQmwtpmi2s8,81
+prediction_market_agent_tooling-0.65.10.dist-info/RECORD,,