Polymarket Market API

from prediction_market_agent_tooling.markets.markets import MarketType

market_type = MarketType.POLYMARKET

from prediction_market_agent_tooling.markets.polymarket.polymarket import PolymarketAgentMarket

from prediction_market_agent_tooling.markets.agent_market import FilterBy, SortBy

markets = PolymarketAgentMarket.get_markets(
    limit=500,
    filter_by=FilterBy.OPEN,
    sort_by=SortBy.HIGHEST_LIQUIDITY
)

market = PolymarketAgentMarket.get_binary_market(
    id="polymarket-market-id"
)

market.buy_tokens(
    outcome="Yes",
    amount=USD(100)  # In USDC
)

balance = PolymarketAgentMarket.get_trade_balance(api_keys)

# All amounts are in USDC
market.buy_tokens(outcome="Yes", amount=USD(50))  # 50 USDC

# Fetch by highest liquidity
markets = PolymarketAgentMarket.get_markets(
    limit=500,
    filter_by=FilterBy.OPEN,
    sort_by=SortBy.HIGHEST_LIQUIDITY
)

# Query historical market data
url = f"https://gateway.thegraph.com/api/{api_key}/subgraphs/id/81Dm16JjuFSrqz813HysXoUPvzTwE7fsfPk2RTf66nyC"

import httpx
from prediction_market_agent.agents.berlin1_agent.polysent_agent import (
    get_polymarket_history,
)

# Get historical data for a market question
history_data = get_polymarket_history(market.question)

# Returns market history with outcomes and prices
for market_data in history_data:
    print(f"Question: {market_data['question']}")
    print(f"Volume: {market_data['volume']}")
    for outcome in market_data['outcomes']:
        print(f"  {outcome['name']}: {outcome['price']}")

from prediction_market_agent.agents.replicate_to_omen_agent.omen_replicate import (
    omen_replicate_from_tx,
)

# Fetch top 500 Polymarket markets by liquidity
markets = get_binary_markets(
    500,
    MarketType.POLYMARKET,
    filter_by=FilterBy.OPEN,
    sort_by=SortBy.HIGHEST_LIQUIDITY
)

# Replicate to Omen
created_addresses = omen_replicate_from_tx(
    api_keys=api_keys,
    market_type=MarketType.POLYMARKET,
    n_to_replicate=5,
    initial_funds=USD(10),
    collateral_token_address=collateral_token,
    replicated_market_table_handler=handler
)

from prediction_market_agent_tooling.deploy.agent import DeployableTraderAgent

class PolymarketTradingAgent(DeployableTraderAgent):
    bet_on_n_markets_per_run = 2

    def answer_binary_market(self, market: AgentMarket) -> ProbabilisticAnswer | None:
        # Analyze Polymarket-specific factors
        if market.volume and market.volume > USD(10000):
            # High liquidity market - more reliable price discovery
            prediction = self.predict_with_high_confidence(market)
        else:
            # Lower liquidity - be more cautious
            prediction = self.predict_with_low_confidence(market)
        
        return prediction

# Run agent
agent = PolymarketTradingAgent()
agent.run(market_type=MarketType.POLYMARKET)

from prediction_market_agent.agents.microchain_agent.utils import (
    get_binary_markets,
)

# Note: Polymarket uses NONE sort by default in microchain
markets = get_binary_markets(
    market_type=MarketType.POLYMARKET
)  # Uses SortBy.NONE internally

# Use NONE sort in microchain agents
if market_type == MarketType.POLYMARKET:
    sort_by = SortBy.NONE
else:
    sort_by = SortBy.CLOSING_SOONEST

markets_sorted = sorted(
    markets,
    key=lambda m: m.volume or 0,
    reverse=True,
)

{
  binaryMarkets(first: 5, where: {question_contains: "Bitcoin"}) {
    id
    question
    outcomes {
      name
      price
    }
    volume
    startTime
    endTime
  }
}

try:
    market = PolymarketAgentMarket.get_binary_market(id=market_id)
    market.buy_tokens(outcome="Yes", amount=USD(100))
except Exception as e:
    logger.error(f"Polymarket trade failed: {e}")
    # Handle insufficient balance, market closed, etc.