Market Making Parlays

import { Centrifuge } from "centrifuge";

const API_KEY = process.env.SX_API_KEY;
const RELAYER_URL = "https://api.sx.bet"; // Mainnet — use https://api.toronto.sx.bet for testnet
const WS_URL = "wss://realtime.sx.bet/connection/websocket"; // Mainnet — use wss://realtime.toronto.sx.bet/connection/websocket for testnet

async function fetchToken() {
  const res = await fetch(`${RELAYER_URL}/user/realtime-token/api-key`, {
    headers: { "x-api-key": API_KEY },
  });
  if (!res.ok) throw new Error(`Token endpoint returned ${res.status}`);
  const { token } = await res.json();
  return token;
}

const client = new Centrifuge(WS_URL, {
  getToken: fetchToken,
});

const sub = client.newSubscription("parlay_markets:global");

sub.on("publication", (ctx) => {
  const parlayRequest = ctx.data;
  handleParlayRequest(parlayRequest);
});

sub.subscribe();
client.connect();

async function handleParlayRequest(parlayRequest) {
  const { marketHash: parlayMarketHash, baseToken, requestSize, legs } = parlayRequest;

  // Fetch market data for each leg
  const legData = await Promise.all(
    legs.map(async (leg) => {
      const response = await fetch(
        `${BASE_URL}/markets/find?${new URLSearchParams({ marketHash: leg.marketHash })}`
      ).then((r) => r.json());
      const market = response.data;

      // Fetch best odds for this leg's market
      const ordersResponse = await fetch(
        `${BASE_URL}/orders/odds/best?${new URLSearchParams({ marketHashes: leg.marketHash })}`
      ).then((r) => r.json());
      const bestOdds = ordersResponse.data.bestOdds;

      return {
        ...leg,
        market,
        bestOdds,
      };
    })
  );

  console.log("Parlay request received:");
  legData.forEach((leg, i) => {
    const m = leg.market;
    const side = leg.bettingOutcomeOne ? m.outcomeOneName : m.outcomeTwoName;
    console.log(`  Leg ${i + 1}: ${m.teamOneName} vs ${m.teamTwoName} — ${side}`);
  });

  // Calculate your price and post an order
  const odds = calculateParlayOdds(legData);
  if (odds) {
    await postParlayOrder(parlayMarketHash, baseToken, odds);
  }
}

const ODDS_PRECISION = 10n ** 20n;

function calculateParlayOdds(legData) {
  // Simple approach: multiply implied probabilities of each leg
  // In practice, you may want to account for correlation between legs
  let combinedProbability = 1.0;

  for (const leg of legData) {
    // Use your own fair odds estimate per leg
    // This example uses a fixed estimate — replace with your model
    const legProbability = estimateLegProbability(leg);
    combinedProbability *= legProbability;
  }

  // Add your margin
  const margin = 0.03; // 3% edge
  const makerProbability = combinedProbability + margin;

  // Convert to SX protocol format (maker's percentageOdds)
  // percentageOdds = maker's implied probability * 10^20
  const percentageOdds = BigInt(Math.round(makerProbability * 1e20));

  return percentageOdds.toString();
}

function estimateLegProbability(leg) {
  // Replace with your actual pricing model
  // This is just a placeholder
  return 0.5;
}

import { Wallet, solidityPackedKeccak256, getBytes, randomBytes, hexlify } from "ethers";

async function postParlayOrder(parlayMarketHash, baseToken, percentageOdds) {
  const wallet = new Wallet(process.env.SX_PRIVATE_KEY);

  const order = {
    marketHash: parlayMarketHash,
    maker: wallet.address,
    baseToken: baseToken,
    totalBetSize: "1000000000", // your offered size in base token units
    percentageOdds: percentageOdds,
    expiry: 2209006800,
    apiExpiry: Math.floor(Date.now() / 1000) + 60, // 1 minute from now
    executor: "0x...", // from GET /metadata → executorAddress
    salt: BigInt(hexlify(randomBytes(32))).toString(),
    isMakerBettingOutcomeOne: false, // maker takes the opposite side
  };

  const orderHash = getBytes(
    solidityPackedKeccak256(
      ["bytes32", "address", "uint256", "uint256", "uint256", "uint256", "address", "address", "bool"],
      [order.marketHash, order.baseToken, order.totalBetSize, order.percentageOdds, order.expiry, order.salt, order.maker, order.executor, order.isMakerBettingOutcomeOne]
    )
  );
  const signature = await wallet.signMessage(orderHash);

  const response = await fetch(`${BASE_URL}/orders/new`, {
    method: "POST",
    headers: { "Content-Type": "application/json", "X-Api-Key": API_KEY },
    body: JSON.stringify({ orders: [{ ...order, signature }] }),
  }).then((r) => r.json());

  console.log("Order posted:", response);
}

import { hexlify, randomBytes } from "ethers";

// Cancel a specific parlay order
const salt = hexlify(randomBytes(32));
const timestamp = Math.floor(Date.now() / 1000);
const chainId = 4162; // Mainnet — use 79479957 for testnet

const cancelSig = await wallet.signTypedData(
  { name: "CancelOrderV2SportX", version: "1.0", chainId, salt },
  { Details: [{ name: "orderHashes", type: "string[]" }, { name: "timestamp", type: "uint256" }] },
  { orderHashes: [orderHash], timestamp },
);

const response = await fetch(`${BASE_URL}/orders/cancel/v2`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ orderHashes: [orderHash], signature: cancelSig, salt, maker: wallet.address, timestamp }),
}).then((r) => r.json());