137 arbitrage agent

prediction_market_agent/agents/arbitrage_agent/data_models.py

@@ -0,0 +1,71 @@
+import typing as t
+
+from prediction_market_agent_tooling.markets.agent_market import AgentMarket
+from pydantic import BaseModel, computed_field
+
+
+class Correlation(BaseModel):
+    near_perfect_correlation: bool
+    reasoning: str
+
+
+class CorrelatedMarketPair(BaseModel):
+    main_market: AgentMarket
+    related_market: AgentMarket
+    correlation: float
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def potential_profit_per_bet_unit(self) -> float:
+        """
+        Calculate potential profit per bet unit based on high positive market correlation.
+        For positively correlated markets: Bet YES/NO or NO/YES.
+        """
+        # Smaller correlations will be handled in a future ticket
+        # https://github.com/gnosis/prediction-market-agent/issues/508
+        # Negative correlations are not yet supported by the current LLM prompt, hence not handling those for now.
+        p_yes = min(self.main_market.current_p_yes, self.related_market.current_p_yes)
+        p_no = min(self.main_market.current_p_no, self.related_market.current_p_no)
+        total_probability = p_yes + p_no
+
+        # Ensure total_probability is non-zero to avoid division errors
+        if total_probability > 0:
+            return (1.0 / total_probability) - 1.0
+        else:
+            return 0  # No arbitrage possible if the sum of probabilities is zero
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def market_to_bet_yes(self) -> AgentMarket:
+        return (
+            self.main_market
+            if self.main_market.current_p_yes <= self.related_market.current_p_yes
+            else self.related_market
+        )
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def market_to_bet_no(self) -> AgentMarket:
+        return (
+            self.main_market
+            if self.main_market.current_p_yes > self.related_market.current_p_yes
+            else self.related_market
+        )
+
+    def split_bet_amount_between_yes_and_no(
+        self, total_bet_amount: float
+    ) -> t.Tuple[float, float]:
+        """Splits total bet amount following equations below:
+        A1/p1 = A2/p2 (same profit regardless of outcome resolution)
+        A1 + A2 = total bet amount
+        """
+        amount_to_bet_yes = (
+            total_bet_amount
+            * self.market_to_bet_yes.current_p_yes
+            / (
+                self.market_to_bet_yes.current_p_yes
+                + self.market_to_bet_no.current_p_no
+            )
+        )
+        amount_to_bet_no = total_bet_amount - amount_to_bet_yes
+        return amount_to_bet_yes, amount_to_bet_no

prediction_market_agent/agents/arbitrage_agent/deploy.py

@@ -0,0 +1,179 @@
+import typing as t
+
+from langchain_core.output_parsers import PydanticOutputParser
+from langchain_core.prompts import PromptTemplate
+from langchain_core.runnables import RunnableSerializable
+from langchain_openai import ChatOpenAI
+from prediction_market_agent_tooling.deploy.agent import (
+    MAX_AVAILABLE_MARKETS,
+    DeployableTraderAgent,
+)
+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,
+    FilterBy,
+    SortBy,
+)
+from prediction_market_agent_tooling.markets.data_models import (
+    BetAmount,
+    Position,
+    ProbabilisticAnswer,
+    TokenAmount,
+    Trade,
+    TradeType,
+)
+from prediction_market_agent_tooling.markets.markets import MarketType
+from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
+from prediction_market_agent_tooling.markets.omen.omen_subgraph_handler import (
+    OmenSubgraphHandler,
+)
+from prediction_market_agent_tooling.tools.langfuse_ import (
+    get_langfuse_langchain_config,
+    observe,
+)
+
+from prediction_market_agent.agents.arbitrage_agent.data_models import (
+    CorrelatedMarketPair,
+    Correlation,
+)
+from prediction_market_agent.agents.arbitrage_agent.prompt import prompt_template
+from prediction_market_agent.db.pinecone_handler import PineconeHandler
+from prediction_market_agent.utils import APIKeys
+
+
+class DeployableOmenArbitrageAgent(DeployableTraderAgent):
+    """Agent that places mirror bets on Omen for (quasi) risk-neutral profit."""
+
+    model = "gpt-4o-mini"
+
+    def load(self) -> None:
+        self.subgraph_handler = OmenSubgraphHandler()
+        self.pinecone_handler = PineconeHandler()
+        self.chain = self._build_chain()
+
+    def get_markets(
+        self,
+        market_type: MarketType,
+        limit: int = MAX_AVAILABLE_MARKETS,
+        sort_by: SortBy = SortBy.CLOSING_SOONEST,
+        filter_by: FilterBy = FilterBy.OPEN,
+    ) -> t.Sequence[AgentMarket]:
+        return super().get_markets(
+            market_type=market_type,
+            limit=100,
+            sort_by=SortBy.HIGHEST_LIQUIDITY,
+            # Fetching most liquid markets since more likely they will have related markets
+            filter_by=FilterBy.OPEN,
+        )
+
+    def answer_binary_market(self, market: AgentMarket) -> ProbabilisticAnswer | None:
+        return ProbabilisticAnswer(p_yes=Probability(0.5), confidence=1.0)
+
+    def _build_chain(self) -> RunnableSerializable[t.Any, t.Any]:
+        llm = ChatOpenAI(
+            temperature=0,
+            model=self.model,
+            api_key=APIKeys().openai_api_key_secretstr_v1,
+        )
+
+        parser = PydanticOutputParser(pydantic_object=Correlation)
+        prompt = PromptTemplate(
+            template=prompt_template,
+            input_variables=["main_market_question", "related_market_question"],
+            partial_variables={"format_instructions": parser.get_format_instructions()},
+        )
+
+        chain = prompt | llm | parser
+        return chain
+
+    @observe()
+    def calculate_correlation_between_markets(
+        self, market: AgentMarket, related_market: AgentMarket
+    ) -> Correlation:
+        correlation: Correlation = self.chain.invoke(
+            {
+                "main_market_question": market.question,
+                "related_market_question": related_market.question,
+            }
+        )
+        return correlation
+
+    @observe()
+    def get_correlated_markets(self, market: AgentMarket) -> list[CorrelatedMarketPair]:
+        # We try to find similar, open markets which point to the same outcome.
+        correlated_markets = []
+        related = self.pinecone_handler.find_nearest_questions_with_threshold(
+            limit=10, text=market.question
+        )
+
+        omen_markets = self.subgraph_handler.get_omen_binary_markets(
+            limit=len(related),
+            id_in=[i.market_address.lower() for i in related],
+            resolved=False,
+        )
+
+        # Note that negative correlation is hard - e.g. for the US presidential election, markets on each candidate are not seen as -100% correlated.
+        for related_market in omen_markets:
+            result: Correlation = self.chain.invoke(
+                {
+                    "main_market_question": market,
+                    "related_market_question": related_market,
+                },
+                config=get_langfuse_langchain_config(),
+            )
+            if related_market.id != market.id and result.near_perfect_correlation:
+                related_agent_market = OmenAgentMarket.from_data_model(related_market)
+                correlated_markets.append(
+                    CorrelatedMarketPair(
+                        main_market=market,
+                        related_market=related_agent_market,
+                        correlation=result.correlation,
+                    )
+                )
+        return correlated_markets
+
+    @observe()
+    def build_trades_for_correlated_markets(
+        self, pair: CorrelatedMarketPair
+    ) -> list[Trade]:
+        market_to_bet_yes, market_to_bet_no = pair.main_market, pair.related_market
+        total_amount: BetAmount = pair.main_market.get_tiny_bet_amount()
+        # Split between main_market and related_market
+        amount_yes, amount_no = pair.split_bet_amount_between_yes_and_no(
+            total_amount.amount
+        )
+        trades = [
+            Trade(
+                trade_type=TradeType.BUY,
+                outcome=True,
+                amount=TokenAmount(
+                    amount=amount_yes, currency=market_to_bet_yes.currency
+                ),
+            ),
+            Trade(
+                trade_type=TradeType.BUY,
+                outcome=False,
+                amount=TokenAmount(
+                    amount=amount_no, currency=market_to_bet_no.currency
+                ),
+            ),
+        ]
+        logger.info(f"Placing arbitrage trades {trades}")
+        return trades
+
+    @observe()
+    def build_trades(
+        self,
+        market: AgentMarket,
+        answer: ProbabilisticAnswer,
+        existing_position: Position | None,
+    ) -> list[Trade]:
+        trades = []
+        correlated_markets = self.get_correlated_markets(market=market)
+        for pair in correlated_markets:
+            if pair.potential_profit_per_bet_unit > 0:
+                trades_for_pair = self.build_trades_for_correlated_markets(pair)
+                trades.extend(trades_for_pair)
+
+        return trades

prediction_market_agent/agents/arbitrage_agent/prompt.py

@@ -0,0 +1,12 @@
+prompt_template = """Given two markets, MARKET 1 and MARKET 2, provide a boolean value that represents the correlation between these two markets' outcomes. Return True if the outcomes are perfectly or nearly perfectly correlated, meaning there is a high probability that both markets resolve to the same outcome. Return False if the correlation is weak or non-existent.
+Correlation can also be understood as the conditional probability that market 2 resolves to YES, given that market 1 resolved to YES.
+In addition to the boolean value, explain the reasoning behind your decision. 
+
+[MARKET 1]
+{main_market_question}
+
+[MARKET 2]
+{related_market_question}
+
+Follow the formatting instructions below for producing an output in the correct format.
+{format_instructions}"""

tests/agents/arbitrage_agent/test_arbitrage_agent.py

@@ -0,0 +1,63 @@
+import typing as t
+from unittest.mock import Mock, patch
+
+import pytest
+from prediction_market_agent_tooling.markets.agent_market import AgentMarket
+from prediction_market_agent_tooling.markets.omen.omen import OmenAgentMarket
+
+from prediction_market_agent.agents.arbitrage_agent.deploy import (
+    DeployableOmenArbitrageAgent,
+)
+
+
+@pytest.fixture(scope="module")
+def arbitrage_agent() -> t.Generator[DeployableOmenArbitrageAgent, None, None]:
+    with patch(
+        "prediction_market_agent.agents.arbitrage_agent.deploy.DeployableOmenArbitrageAgent.load",
+        new=lambda x: None,
+    ), patch(
+        "prediction_market_agent_tooling.tools.langfuse_.get_langfuse_langchain_config"
+    ):
+        agent = DeployableOmenArbitrageAgent()
+        # needed since load was mocked
+        agent.chain = agent._build_chain()
+        yield agent
+
+
+@pytest.fixture(scope="module")
+def main_market() -> t.Generator[AgentMarket, None, None]:
+    m1 = Mock(OmenAgentMarket, wraps=OmenAgentMarket)
+    m1.question = "Will Kamala Harris win the US presidential election in 2024?"
+    yield m1
+
+
+@pytest.fixture(scope="module")
+def related_market() -> t.Generator[AgentMarket, None, None]:
+    m1 = Mock(OmenAgentMarket, wraps=OmenAgentMarket)
+    m1.question = "Will Kamala Harris become the US president in 2025?"
+    yield m1
+
+
+@pytest.fixture(scope="module")
+def unrelated_market() -> t.Generator[AgentMarket, None, None]:
+    m1 = Mock(OmenAgentMarket, wraps=OmenAgentMarket)
+    m1.question = "Will Donald Duck ever retire from his adventures in Duckburg?"
+    yield m1
+
+
+@pytest.mark.parametrize(
+    "related_market_fixture_name, is_correlated",
+    [("related_market", True), ("unrelated_market", False)],
+)
+def test_correlation_for_similar_markets(
+    arbitrage_agent: DeployableOmenArbitrageAgent,
+    main_market: AgentMarket,
+    related_market_fixture_name: str,
+    is_correlated: bool,
+    request: pytest.FixtureRequest,
+) -> None:
+    other_market = request.getfixturevalue(related_market_fixture_name)
+    correlation = arbitrage_agent.calculate_correlation_between_markets(
+        market=main_market, related_market=other_market
+    )
+    assert correlation.near_perfect_correlation == is_correlated