TypeScript SDK

import { PredictaClient } from '@/sdk';

const predicta = new PredictaClient({
  baseUrl: process.env.PREDICTA_BASE!,   // the host issued to you
  apiKey:  process.env.PREDICTA_KEY!,    // pk_test_… sandbox, sk_live_… live
  timeoutMs: 15_000,                     // per-request deadline (default)
  maxRetries: 2,                         // GETs only (default)
});

const player = predicta.forUser('your-own-player-id');

import { toMinorUnits, addDecimal, formatDecimal } from '@/sdk';

const debit = order.operatorMoney!.actualDebit;   // Decimal — "12.30"

toMinorUnits(debit);           // 1230n — exact, bigint, the only way to do arithmetic
addDecimal(debit, release);    // "25.00"
formatDecimal(debit);          // "$12.30" — display only. Never book from a formatter.

const wrong: Decimal = 12.30;  // ✗ type error, which is the point

// 1. Find something tradable. `executableYesCents` is the PRICE;
//    `probability` is the market's reference and nobody trades at it.
const page = await predicta.listEvents({ tradable: true, limit: 5 });
const outcome = page.items
  .flatMap((e) => e.outcomes)
  .find((o) => o.executableYesCents !== null);

// 2. Price it. Show the player `executionPrice`, and let them confirm.
const quote = await player.quoteBuy({
  contractId: outcome.id,          // the opaque ctr_… id from the catalogue
  side: 'YES',
  stake: 25,
});

// 3. Reserve the exact amount in YOUR OWN ledger, before submitting.
const reservation = await wallet.reserve(quote.operatorMoney!.authorizationAmount);

// 4. Submit. `clientOrderId` is your idempotency key — derive it from the
//    reservation, never from a clock: it has to survive the crash that loses
//    you our response.
const order = await player.submitOrder({
  quoteId: quote.quoteId,
  clientOrderId: reservation.id,
});

// 5. Apply the exact amounts. On a PARTIAL FILL the release is non-zero, and
//    an operator that debits the whole stake instead is keeping money that is
//    not theirs to keep.
await wallet.debit(order.operatorMoney!.actualDebit);
await wallet.release(order.operatorMoney!.releaseAmount);

// A sell is sized in CONTRACTS. A cash-sized exit cannot express "close out",
// because inverting the fee rounding either oversells or strands a fraction.
const [held] = (await player.listPositions({ status: 'open' })).items;

const exitQuote = await player.quoteSell({
  contractId: held.contractId,
  side: held.side,
  contracts: held.quantity / 2,        // a partial exit
});

const exit = await player.submitOrder({
  quoteId: exitQuote.quoteId,
  clientOrderId: `exit-${reservation.id}`,
});

// An exit CREDITS. `sellProceeds` is already net of the fees reported beside
// it — subtracting them again is a double charge. `operatorMoney` is null.
await wallet.credit(exit.operatorExitMoney!.sellProceeds);

for await (const s of predicta.iterateSettlements({ settledFrom: lastRun })) {
  // Exactly one is non-zero; a loss zeroes both. They are different
  // instructions to book: winnings against a wager, versus a refund that
  // reverses one.
  if (s.outcome === 'won')  await wallet.credit(s.operatorMoney.settlementCredit, s.id);
  if (s.outcome === 'void') await wallet.refund(s.operatorMoney.voidCredit, s.id);
}

import { ConflictError, ReconciliationRequiredError } from '@/sdk';

try {
  const order = await player.submitOrder({ quoteId, clientOrderId });
  await wallet.settle(order.operatorMoney!);
} catch (err) {
  if (err instanceof ReconciliationRequiredError) {
    // The venue took it or it did not, and we do not yet know which.
    // Releasing here strands a live position with no cash behind it — the
    // most expensive mistake available on this API.
    await wallet.hold(clientOrderId);
    return;
  }
  if (err instanceof ConflictError) return requote();   // the price moved
  throw err;
}

// Poll with the id YOU chose. Ours only ever existed in a response you may
// not have received; yours was chosen before the request was sent.
const order = await player.findOrderByClientOrderId(clientOrderId);

if (order?.settlementState === 'settled') {
  await wallet.settle(order.operatorMoney ?? order.operatorExitMoney);
}
// 'pending' — including status 'submitted' — means keep holding.