Polymarket

def market_order(request: PolymarketMarketOrderRequest | PolymarketMarketOrderRequestInput) -> PolymarketMarketOrderResponse

async marketOrder(request: PolymarketMarketOrderRequest): Promise<PolymarketMarketOrderResponse>

# BUY order - spendUsd is the USD amount to spend
# tokenId comes from Polymarket's API for the specific outcome you want to trade
token_id = "71321045679252212594626385532706912750332728571942532289631379312455583992563"

buy_result = agent.platforms.polymarket.market_order({
    "tokenId": token_id,
    "spendUsd": 10,  # Spend $10 to buy shares
    "side": "BUY"
})

if buy_result.success and buy_result.data:
    agent.log(f"Order ID: {buy_result.data.order_info.order_id}")
    agent.log(f"Total Price: ${buy_result.data.order_info.total_price_usd}")
    agent.log(f"Price per share: ${buy_result.data.order_info.price_usd}")

# SELL order - shares is the number of shares to sell
sell_result = agent.platforms.polymarket.market_order({
    "tokenId": token_id,
    "shares": 5,  # Sell 5 shares
    "side": "SELL"
})

if sell_result.success and sell_result.data:
    agent.log(f"Sold {sell_result.data.order_info.size} shares")
    agent.log(f"Received: ${sell_result.data.order_info.total_price_usd}")

// BUY order - spendUsd is the USD amount to spend
// tokenId comes from Polymarket's API for the specific outcome you want to trade
const tokenId = "71321045679252212594626385532706912750332728571942532289631379312455583992563";

const buyResult = await agent.platforms.polymarket.marketOrder({
  tokenId,
  spendUsd: 10, // Spend $10 to buy shares
  side: "BUY"
});

if (buyResult.success && buyResult.data) {
  await agent.log(`Order ID: ${buyResult.data.orderInfo.orderId}`);
  await agent.log(`Total Price: $${buyResult.data.orderInfo.totalPriceUsd}`);
  await agent.log(`Price per share: $${buyResult.data.orderInfo.priceUsd}`);
}

// SELL order - shares is the number of shares to sell
const sellResult = await agent.platforms.polymarket.marketOrder({
  tokenId,
  shares: 5, // Sell 5 shares
  side: "SELL"
});

if (sellResult.success && sellResult.data) {
  await agent.log(`Sold ${sellResult.data.orderInfo.size} shares`);
  await agent.log(`Received: $${sellResult.data.orderInfo.totalPriceUsd}`);
}

def redeem_positions(request: PolymarketRedeemPositionsRequest | PolymarketRedeemPositionsRequestInput) -> PolymarketRedeemPositionsResponse

async redeemPositions(request: PolymarketRedeemPositionsRequest): Promise<PolymarketRedeemPositionsResponse>

# Redeem this agent's settled positions - read them from this session's
# allocation (Polymarket positions carry `polymarket_metadata`).
allocation = agent.allocation
redeemable = [
    p.polymarket_metadata.token_id
    for p in allocation.positions
    if p.polymarket_metadata
    and p.polymarket_metadata.is_redeemable
    and p.polymarket_metadata.token_id
]

if redeemable:
    redemption = agent.platforms.polymarket.redeem_positions({"tokenIds": redeemable})

    if redemption.success and redemption.data:
        successful = [r for r in redemption.data if r.success]
        agent.log(f"Redeemed {len(successful)} positions")

        for tx in redemption.data:
            if tx.success and tx.position:
                agent.log(f"Redeemed: {tx.position.question} ({tx.position.outcome})")
                agent.log(f"Value: ${tx.position.market_value_usd}")
                agent.log(f"PnL: ${tx.position.pnl_usd} ({tx.position.pnl_percent}%)")
                agent.log(f"Tx: {tx.transaction_hash}")

// Redeem this agent's settled positions - read them from this session's
// allocation (Polymarket positions carry `polymarketMetadata`).
const allocation = agent.allocation;
const redeemable = allocation.positions
  .filter((p) => p.polymarketMetadata?.isRedeemable && p.polymarketMetadata.tokenId)
  .map((p) => p.polymarketMetadata!.tokenId as string);

if (redeemable.length > 0) {
  const redemption = await agent.platforms.polymarket.redeemPositions({ tokenIds: redeemable });

  if (redemption.success && redemption.data) {
    const successful = redemption.data.filter(r => r.success);
    await agent.log(`Redeemed ${successful.length} positions`);

    for (const tx of redemption.data) {
      if (tx.success && tx.position) {
        await agent.log(`Redeemed: ${tx.position.question} (${tx.position.outcome})`);
        await agent.log(`Value: $${tx.position.marketValueUsd}`);
        await agent.log(`PnL: $${tx.position.pnlUsd} (${tx.position.pnlPercent}%)`);
        await agent.log(`Tx: ${tx.transactionHash}`);
      }
    }
  }
}

allocation = agent.allocation
for pos in allocation.positions:
    m = pos.polymarket_metadata
    if not m:
        continue
    agent.log(f"{m.question} [{m.outcome}]: ${m.market_value_usd} (PnL ${m.pnl_usd})")
    if m.is_redeemable:
        agent.log(f"  redeemable - tokenId {m.token_id}")

const allocation = agent.allocation;
for (const pos of allocation.positions) {
  const m = pos.polymarketMetadata;
  if (!m) continue;
  await agent.log(`${m.question} [${m.outcome}]: $${m.marketValueUsd} (PnL $${m.pnlUsd})`);
  if (m.isRedeemable) {
    await agent.log(`  redeemable - tokenId ${m.tokenId}`);
  }
}

def search_events(query: str) -> PostPlatformsPolymarketSearchEventsResponse

async searchEvents(query: string): Promise<PolymarketSearchEventsSdkResponse>

def event_markets(slug: str) -> PostPlatformsPolymarketEventMarketsResponse

async eventMarkets(slug: string): Promise<PolymarketEventMarketsSdkResponse>

from datetime import date
today = date.today().isoformat()

search = sdk.platforms.polymarket.search_events("egypt")
candidates = search.get("data", {}).get("events", []) + search.get("data", {}).get("moreEvents", [])
ref = next(e for e in candidates if "Egypt" in e["title"])

catalog = sdk.platforms.polymarket.event_markets(ref["slug"])
market = next(m for m in catalog["data"]["markets"]
              if m["sportsMarketType"] == "moneyline" and m["groupItemTitle"] == "Egypt"
              and (m["gameStartTime"] or "").startswith(today))
token_id = next(o["tokenId"] for o in market["outcomes"] if o["name"] == "Yes")

const today = new Date().toISOString().slice(0, 10);

const search = await agent.platforms.polymarket.searchEvents("egypt");
const ref = [...(search.data?.events ?? []), ...(search.data?.moreEvents ?? [])]
  .find((e) => e.title.includes("Egypt"));
if (!ref) throw new Error("No Egypt event on Polymarket");

const catalog = await agent.platforms.polymarket.eventMarkets(ref.slug);
const market = catalog.data?.markets.find((m) =>
  m.sportsMarketType === "moneyline" && m.groupItemTitle === "Egypt" &&
  (m.gameStartTime ?? "").startsWith(today));
const tokenId = market?.outcomes.find((o) => o.name === "Yes")?.tokenId;