streamAccountUpdates

const client = await OstiumClient.createSelfAndSelf({
  traderPrivateKey: process.env.TRADER_PRIVATE_KEY as `0x${string}`,
  rpcUrl: process.env.ARB_RPC_URL!,
  rpcWsUrl: process.env.ARB_WS_URL!,   // or alchemyApiKey — see RPC configuration
});

const stream = client.streamAccountUpdates();

stream.onUpdate(snapshot => {
  const account = snapshot[client.getTraderAddress().toLowerCase()];
  console.log(account.positions);
  console.log(account.orders);
  console.log(account.limits);
});

stream.onError(error => console.error(error));

const stream = client.streamAccountUpdates({
  user: ['0xTraderAddress'],
  rpcWsUrl: process.env.ARB_WS_URL!,
  pollIntervalMs: 3000,
});

const stream = client.streamAccountUpdates({
  user: ['0xTraderA', '0xTraderB', '0xTraderC'],
  rpcWsUrl: process.env.ARB_WS_URL!,
});

stream.onUpdate(snapshot => {
  console.log(snapshot['0xtradera'].positions);
  console.log(snapshot['0xtraderb'].orders);
});

import { extractOrderIdFromReceipt } from '@ostium/builder-sdk';

const result = await client.openTrade(params);
const localId = stream.addOptimisticOpen(params, result);

const receipt = await publicClient.waitForTransactionReceipt({
  hash: result.txHash,
});
const orderId = extractOrderIdFromReceipt(receipt);

if (orderId) {
  stream.attachOrderId(localId, orderId, {
    initiatedTx: result.txHash,
  });
}

interface StreamAccountUpdatesParams {
  /** One or more addresses to stream on one connection. */
  user?: `0x${string}`[];
  /** WebSocket RPC endpoint for the contract-log subscription. Preferred. */
  rpcWsUrl?: string;
  /** HTTP RPC endpoint for the missed-event sweep and block reads. */
  rpcHttpUrl?: string;
  /** Alchemy API key. Still supported — it just builds the URLs for you. */
  alchemyApiKey?: string;
  /** Reconciliation poll cadence. Defaults to 3000ms. */
  pollIntervalMs?: number;
}

const stream = client.streamAccountUpdates({
  user: ['0xTraderAddress'],
  rpcWsUrl: process.env.ARB_WS_URL!,      // wss://…
  rpcHttpUrl: process.env.ARB_HTTP_URL,   // optional; see the fallback order below
});

const stream = client.streamAccountUpdates({
  user: ['0xTraderAddress'],
  alchemyApiKey: process.env.ALCHEMY_API_KEY!,
});

interface OstiumAccountUpdatesStream {
  /** Trader addresses this stream is subscribed to, in the order supplied. */
  readonly users: `0x${string}`[];
  onUpdate(handler: (snapshot: AccountUpdatesSnapshot) => void): () => void;
  onError(handler: (error: Error) => void): this;
  getCurrent(): AccountUpdatesSnapshot;
  addOptimisticOpen(
    params: OpenTradeParams,
    submission?: SubmissionResult,
    user?: `0x${string}`,
  ): string;
  attachOrderId(
    localId: string,
    orderId: string,
    metadata?: { initiatedTx?: string; initiatedBlock?: string },
  ): void;
  close(): void;
}

interface AccountUpdatesForTrader {
  /** Open positions, formatted like getOpenPositions().pairPositions. */
  positions: PairPosition[];
  /** Pending market orders only. */
  orders: Order[];
  /** Active limit and stop orders. */
  limits: OpenOrder[];
}

type AccountUpdatesSnapshot = Record<string, AccountUpdatesForTrader>;