TypeScript SDK

import { ParityClient } from '@/sdk';

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

const player = parity.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 parity.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. Record the order. `clientOrderId` is your idempotency key. Derive it
//    from your own reservation, never from a clock: it has to survive the
//    crash that loses you our response.
//
//    The order comes back `reserve_pending`, which has no transition to
//    `submitted` in the state machine. Nothing can send an order whose
//    customer funds nobody has confirmed are held.
const order = await player.submitOrder({
  quoteId: quote.quoteId,
  clientOrderId: reservationId,
  executionIntent: 'record_intent',
});

// 4. Reserve the AUTHORITATIVE amount in YOUR OWN ledger, then say so.
try {
  await wallet.reserve(order.operatorMoney!.authorizationAmount, reservationId);
} catch (err) {
  // 5a. Could not hold it. Withdraw the order and release exactly what the
  //     instruction says, keyed on `cancellationId`, so a lost response
  //     cannot become a second credit.
  const { cancellation } = await player.cancelOrder(order.orderId, { reason: 'insufficient funds' });
  await wallet.release(cancellation.releaseAmount, cancellation.cancellationId);
  throw err;
}

// 5b. Held. This is idempotent: a timeout here is resent, not investigated.
await player.confirmReserve(order.orderId, { reserveReference: reservationId });
// → status `pending_venue_execution`. The order is cleared to execute, under
//   these same state names.

// 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-${reservationId}`,
});

// 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 parity.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;
}

// 1. Find it 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 found = await player.findOrderByClientOrderId(clientOrderId);
if (!found) return schedulePoll();          // not visible yet: keep holding

// 2. Read THAT order back. settlementState lives only on this route, and a
//    branch comparing undefined to 'settled' would release a hold it must keep.
const order = await player.getOrder(found.orderId);

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