@openmarketsai/order-sheet 0.1.0

package/dist/sheet.js

@@ -0,0 +1,648 @@
+/**
+ * One slip for one position. The user picks the venue; the sheet quotes,
+ * validates against the served constraints, refines through /preflight, places
+ * through /buy with a fresh idempotency key, and follows the order on the
+ * `orders` stream (or a poll) to fill and settlement.
+ *
+ * State is an immutable snapshot; `subscribe` gets the whole thing on every change.
+ */
+import { credentialSupportsStream } from './auth.js';
+import { OrderSheetError, isOrderSheetError } from './errors.js';
+import { localIssue } from './messages.js';
+import { formatMoney } from './odds.js';
+import { buildQuote, resolveMaxPrice } from './quote.js';
+import { validateSheet } from './validate.js';
+import { buildVenueOptions, fromServerIssue } from './venues.js';
+const TERMINAL_PHASES = new Set(['filled', 'failed', 'cancelled', 'settled']);
+/** The snapshot a sheet starts from, before anything has loaded. Pure — no I/O. */
+export function initialSheetState(o, ref, init = {}) {
+    const userMaxPrice = init.maxPrice ?? null;
+    return {
+        phase: 'loading',
+        position: 'position' in ref ? ref.position : null,
+        venues: [],
+        venue: null,
+        mode: init.mode ?? o.defaults.mode,
+        orderType: init.orderType ?? o.defaults.orderType,
+        stake: init.stake
+            ? ('amount' in init.stake ? { unit: 'amount', value: init.stake.amount } : { unit: 'shares', value: init.stake.shares })
+            : { unit: o.defaults.stakeUnit, value: null },
+        maxPrice: userMaxPrice,
+        maxPriceIsAuto: userMaxPrice == null,
+        slippage: init.slippage ?? o.defaults.slippage,
+        oddsFormat: init.oddsFormat ?? o.defaults.oddsFormat,
+        quote: null,
+        validation: { ok: false, blocking: [], warnings: [], info: [], all: [] },
+        preflight: null,
+        preflightStatus: 'idle',
+        result: null,
+        orders: [],
+        error: null,
+        account: null,
+        canPlace: false,
+        confirmLabel: '',
+        hint: null,
+        loading: true,
+        updatedAt: o.now(),
+    };
+}
+/**
+ * A sheet that does nothing: no fetch, no timer, no listener on the client.
+ * What `useOrderSheet` renders with on the server and before its effect has
+ * opened the real sheet. Every action is a no-op; placing answers `not_ready`.
+ */
+export function createInertSheet(o, ref, init = {}) {
+    const state = initialSheetState(o, ref, init);
+    const notReady = async () => ({ status: 'blocked', issues: [localIssue('not_ready')] });
+    const noop = () => { };
+    return {
+        getState: () => state,
+        subscribe: () => noop,
+        select: noop,
+        set: noop,
+        refresh: async () => { },
+        preflight: async () => null,
+        place: notReady,
+        confirm: notReady,
+        cancelConfirm: noop,
+        cancel: async () => ({ cancelled: [], skipped: [] }),
+        reset: noop,
+        destroy: noop,
+        ingestOrderUpdate: noop,
+        ingestOrderSettled: noop,
+    };
+}
+export function createSheet(client, ref, init = {}) {
+    const o = client.options;
+    const listeners = new Set();
+    let destroyed = false;
+    let userMaxPrice = init.maxPrice ?? null;
+    let selectedPartnerId = init.partnerId ?? refPartner(ref);
+    let preflightTimer = null;
+    let preflightSeq = 0;
+    let pendingIdempotencyKey = null;
+    /** The exact inputs the user saw on the confirm step. Only these may be placed by the confirm click. */
+    let confirmation = null;
+    /** The placement in flight, if any: a second call gets the same promise, never a second buy. */
+    let inFlight = null;
+    let constraintsStale = false;
+    let quoteAt = null;
+    let pollTimer = null;
+    const trackedIds = new Set();
+    const offs = [];
+    let state = initialSheetState(o, ref, init);
+    const emit = () => { for (const l of listeners) {
+        try {
+            l(state);
+        }
+        catch (e) {
+            console.error('[order-sheet] listener threw', e);
+        }
+    } };
+    const patchState = (p) => { state = { ...state, ...p, updatedAt: o.now() }; emit(); };
+    const inputKey = () => JSON.stringify([
+        selectedPartnerId, state.mode, state.orderType, state.stake.unit, state.stake.value, effectiveMaxPrice(),
+    ]);
+    function effectiveMaxPrice() {
+        const venue = currentVenue();
+        if (!venue)
+            return userMaxPrice;
+        return resolveMaxPrice(venue, state.orderType, userMaxPrice, state.slippage);
+    }
+    function currentVenue() {
+        if (!state.position || !selectedPartnerId)
+            return null;
+        const venues = buildVenueOptions({
+            position: state.position, constraints: client.getCachedConstraints(), account: state.account,
+            mode: state.mode, orderType: state.orderType, selectedPartnerId, oddsFormat: state.oddsFormat,
+        });
+        return venues.find((v) => v.partnerId === selectedPartnerId) ?? null;
+    }
+    // ── the one derivation: venues → quote → validation → phase ──
+    function recompute(extra = {}) {
+        if (destroyed)
+            return;
+        const next = { ...extra };
+        const position = extra.position ?? state.position;
+        const account = extra.account ?? state.account;
+        const constraints = client.getCachedConstraints();
+        const mode = extra.mode ?? state.mode;
+        const orderType = extra.orderType ?? state.orderType;
+        const stake = extra.stake ?? state.stake;
+        const oddsFormat = extra.oddsFormat ?? state.oddsFormat;
+        const slippage = extra.slippage ?? state.slippage;
+        let venues = [];
+        let venue = null;
+        if (position) {
+            venues = buildVenueOptions({ position, constraints, account, mode, orderType, selectedPartnerId, oddsFormat });
+            venue = venues.find((v) => v.partnerId === selectedPartnerId) ?? null;
+        }
+        const maxPrice = venue ? resolveMaxPrice(venue, orderType, userMaxPrice, slippage) : userMaxPrice;
+        const currency = mode === 'paper' ? (account?.practiceWallet.currency ?? 'ATLAS') : (venue?.account.currency ?? 'USD');
+        // A preflight answers for ONE set of inputs; drop it the moment they change.
+        const key = JSON.stringify([selectedPartnerId, mode, orderType, stake.unit, stake.value, maxPrice]);
+        const preflight = state.preflight && state.preflight.inputKey === key ? state.preflight : null;
+        const quoteAgeMs = quoteAt != null ? o.now() - quoteAt : null;
+        let validation = validateSheet({
+            account, venue, venues, mode, orderType, stake, maxPrice,
+            realMoneyEnabled: o.realMoney.enabled,
+            paperBettable: position ? position.paper_bettable : null,
+            quoteAgeMs, staleAfterMs: o.defaults.staleAfterMs, constraintsStale, currency,
+        });
+        if (preflight)
+            validation = mergeServerVerdict(validation, preflight);
+        const quote = venue ? buildQuote({
+            venue, mode, orderType, stake, maxPrice, oddsFormat, preflight, currency,
+            stale: quoteAgeMs != null && quoteAgeMs > o.defaults.staleAfterMs,
+        }) : null;
+        // A confirmation is for ONE set of inputs. The moment they differ (an edit,
+        // a re-read that moved the price), it is gone and the user confirms afresh.
+        if (confirmation && confirmation.key !== key)
+            clearConfirmation();
+        const loading = extra.loading ?? state.loading;
+        let phase = state.phase;
+        if (loading)
+            phase = 'loading';
+        else if (state.phase === 'placing' && !extra.phase)
+            phase = state.phase;
+        else if (state.phase === 'confirming' && !extra.phase && confirmation)
+            phase = state.phase;
+        else if (state.result && TERMINAL_PHASES.has(state.phase) && !extra.phase)
+            phase = state.phase;
+        else if (state.result && ['resting', 'pending', 'partial'].includes(state.phase) && !extra.phase)
+            phase = state.phase;
+        else if (extra.phase)
+            phase = extra.phase;
+        else if (!venue || stake.value == null)
+            phase = 'idle';
+        else
+            phase = validation.ok && quote ? 'ready' : 'blocked';
+        const hintIssue = validation.info.find((i) => i.code === 'better_price_available');
+        const best = hintIssue ? venues.find((v) => v.best) ?? null : null;
+        next.position = position;
+        next.account = account;
+        next.venues = venues;
+        next.venue = venue;
+        next.mode = mode;
+        next.orderType = orderType;
+        next.stake = stake;
+        next.oddsFormat = oddsFormat;
+        next.slippage = slippage;
+        next.maxPrice = maxPrice;
+        next.maxPriceIsAuto = userMaxPrice == null;
+        next.quote = quote;
+        next.validation = validation;
+        next.preflight = preflight;
+        next.preflightStatus = preflight ? state.preflightStatus : (state.preflightStatus === 'pending' ? 'pending' : 'idle');
+        next.phase = phase;
+        next.canPlace = (phase === 'ready' || phase === 'confirming') && validation.ok && !!quote;
+        next.confirmLabel = confirmLabel(phase, mode, venue, quote?.display.cost ?? null, o);
+        next.hint = best && hintIssue ? { code: 'better_price_available', venue: best, message: hintIssue.message } : null;
+        next.loading = loading;
+        patchState(next);
+    }
+    function mergeServerVerdict(v, pf) {
+        const leg = pf.leg;
+        const all = [];
+        if (!leg.accepted && leg.rejected_code) {
+            all.push({
+                code: leg.rejected_code,
+                severity: 'block',
+                message: leg.message_user ?? localIssue(leg.rejected_code, { detail: leg.rejected_reason ?? undefined }).message,
+                detail: leg.rejected_reason,
+                fix: leg.fix ?? localIssue(leg.rejected_code).fix,
+                scope: 'leg',
+                source: 'server',
+            });
+        }
+        for (const w of leg.warnings ?? [])
+            all.push(fromServerIssue(w));
+        // The server has answered for these inputs: its verdict replaces the local
+        // one for the codes it decided; local issues it did not mention stay.
+        const serverCodes = new Set(all.map((i) => i.code));
+        for (const i of v.all)
+            if (!serverCodes.has(i.code) || i.source === 'server')
+                all.push(i);
+        const blocking = all.filter((i) => i.severity === 'block');
+        return { ok: blocking.length === 0, blocking, warnings: all.filter((i) => i.severity === 'warn'), info: all.filter((i) => i.severity === 'info'), all };
+    }
+    // ── loading ──
+    async function load() {
+        patchState({ loading: true, error: null });
+        try {
+            const [loaded, constraints] = await Promise.all([client.loadPosition(ref), client.constraints().catch(() => null)]);
+            constraintsStale = client.constraintsStale();
+            if (!selectedPartnerId && loaded.partnerId)
+                selectedPartnerId = loaded.partnerId;
+            quoteAt = o.now();
+            const account = constraints ? client.accountFromConstraints(constraints) : await client.account().catch(() => null);
+            recompute({ position: loaded.position, account, loading: false });
+            scheduleAutoPreflight();
+        }
+        catch (e) {
+            const err = isOrderSheetError(e) ? e : new OrderSheetError({ code: 'network_error', message: e?.message ?? String(e), cause: e });
+            patchState({ loading: false, phase: 'blocked', error: err });
+        }
+    }
+    // ── preflight ──
+    function scheduleAutoPreflight() {
+        if (!o.preflight.auto)
+            return;
+        if (preflightTimer) {
+            o.timers.clear(preflightTimer);
+            preflightTimer = null;
+        }
+        if (!state.validation.ok || !state.quote)
+            return;
+        if (state.preflight && state.preflight.inputKey === inputKey())
+            return;
+        preflightTimer = o.timers.set(() => { preflightTimer = null; void runPreflight({}); }, o.preflight.debounceMs);
+    }
+    async function runPreflight(opts) {
+        const venue = state.venue;
+        const leg = buildLeg();
+        if (!venue || !leg)
+            return null;
+        const key = inputKey();
+        const seq = ++preflightSeq;
+        patchState({ preflightStatus: 'pending' });
+        try {
+            const res = await client.preflight([leg], { verifyLiquidity: opts.verifyLiquidity });
+            if (seq !== preflightSeq || destroyed)
+                return null;
+            const snapshot = { inputKey: key, at: o.now(), leg: res.results[0], haltedAtIndex: res.halted_at_index ?? null };
+            state = { ...state, preflight: snapshot, preflightStatus: 'done', error: null };
+            recompute();
+            return snapshot;
+        }
+        catch (e) {
+            if (seq !== preflightSeq || destroyed)
+                return null;
+            const err = isOrderSheetError(e) ? e : new OrderSheetError({ code: 'network_error', message: String(e?.message ?? e), cause: e });
+            patchState({ preflightStatus: 'error', error: err });
+            recompute();
+            return null;
+        }
+    }
+    function buildLeg() {
+        const venue = state.venue;
+        const maxPrice = state.maxPrice;
+        if (!venue || state.stake.value == null || maxPrice == null)
+            return null;
+        const leg = {
+            max_price: maxPrice,
+            // ALWAYS explicit. The API defaults an omitted mode to REAL.
+            mode: state.mode,
+            order_type: state.orderType,
+            ...(state.stake.unit === 'amount' ? { amount: state.stake.value } : { shares: state.stake.value }),
+        };
+        if (venue.liquidityHash)
+            leg.liquidity_hash = venue.liquidityHash;
+        else if (state.position) {
+            leg.position_hash = state.position.position_hash;
+            leg.partner_id = venue.partnerId;
+        }
+        else
+            return null;
+        return leg;
+    }
+    // ── placing ──
+    function clearConfirmation() {
+        confirmation = null;
+        pendingIdempotencyKey = null;
+    }
+    /** `place()` — or the confirm click on the same button. */
+    function place(opts = {}) {
+        if (inFlight)
+            return inFlight;
+        return track(placeOrConfirm(opts, false));
+    }
+    /** `confirm()` — only ever the second step of a real-money placement. */
+    function confirm() {
+        if (inFlight)
+            return inFlight;
+        return track(placeOrConfirm({}, true));
+    }
+    function track(p) {
+        inFlight = p;
+        const done = () => { if (inFlight === p)
+            inFlight = null; };
+        p.then(done, done);
+        return p;
+    }
+    async function placeOrConfirm(opts, viaConfirm) {
+        if (preflightTimer) {
+            o.timers.clear(preflightTimer);
+            preflightTimer = null;
+        }
+        recompute();
+        const venue = state.venue;
+        const leg = buildLeg();
+        const key = inputKey();
+        // The confirm step is valid only for the inputs it was shown with: recompute()
+        // has already dropped a confirmation whose inputs changed.
+        const confirmedNow = state.phase === 'confirming' && confirmation !== null && confirmation.key === key;
+        if (viaConfirm && !confirmedNow) {
+            if (state.phase === 'confirming') {
+                clearConfirmation();
+                recompute();
+            }
+            return { status: 'blocked', issues: [localIssue('confirm_expired')] };
+        }
+        if (!state.validation.ok || !state.quote || !venue || !leg) {
+            return { status: 'blocked', issues: state.validation.blocking.length ? state.validation.blocking : [localIssue('no_stake')] };
+        }
+        if (state.mode === 'real' && o.realMoney.confirm && !confirmedNow) {
+            confirmation = { key };
+            pendingIdempotencyKey = opts.idempotencyKey ?? newIdempotencyKey();
+            const issue = localIssue('confirm_required', { venue: venue.name, amount: state.quote.cost, currency: state.quote.currency });
+            recompute({ phase: 'confirming' });
+            return { status: 'confirm_required', issues: [issue] };
+        }
+        const idempotencyKey = opts.idempotencyKey ?? pendingIdempotencyKey ?? newIdempotencyKey();
+        confirmation = null;
+        pendingIdempotencyKey = idempotencyKey;
+        recompute({ phase: 'placing' });
+        let raw;
+        try {
+            raw = await client.buy([leg], { idempotencyKey, verifyLiquidity: opts.verifyLiquidity });
+        }
+        catch (e) {
+            const err = isOrderSheetError(e) ? e : new OrderSheetError({ code: 'network_error', message: String(e?.message ?? e), cause: e });
+            // A request the server refused (4xx) was never placed: back to the slip.
+            // A transport failure leaves the outcome unknown: keep the key so a
+            // retry replays instead of doubling, and say so.
+            if (err.retryable)
+                patchState({ error: err, phase: 'failed' });
+            else {
+                pendingIdempotencyKey = null;
+                state = { ...state, error: err };
+                recompute({ phase: 'blocked' });
+            }
+            throw err;
+        }
+        pendingIdempotencyKey = null;
+        const result = toPlaceResult(raw, venue, state.account, idempotencyKey, o.now());
+        for (const l of result.legs)
+            for (const id of l.routerOrderIds)
+                trackedIds.add(id);
+        const orders = result.legs.flatMap((l) => l.routerOrderIds.map((id) => ({
+            routerOrderId: id, partnerId: l.routedPartnerIds[0] ?? l.partnerId ?? '', status: l.status === 'completed' ? 'closed' : 'open',
+            fillStatus: l.status === 'completed' ? (l.fill.unfilled > 0.005 ? 'partially_filled' : 'filled') : 'unfilled',
+            filledAmt: l.fill.notional, unfilledAmt: l.fill.unfilled, avgPrice: l.fill.avgPrice, settled: null, updatedAt: new Date(o.now()).toISOString(),
+        })));
+        state = { ...state, result, orders, error: null };
+        recompute({ phase: phaseFromSummary(result.summary) });
+        if (result.summary === 'resting' || result.summary === 'pending')
+            followOrders().catch(() => { });
+        return { status: 'placed', result };
+    }
+    // ── following the order ──
+    async function followOrders() {
+        if (credentialSupportsStream(o.auth) && o.stream.enabled) {
+            await client.ensureStream();
+            return;
+        }
+        // JWT sessions have no stream: poll the order list for the tracked ids.
+        if (pollTimer || !o.stream.pollIntervalMs)
+            return;
+        const tick = async () => {
+            pollTimer = null;
+            if (destroyed || !state.position || trackedIds.size === 0 || TERMINAL_PHASES.has(state.phase))
+                return;
+            try {
+                const rows = await client.listOrders({ contestId: state.position.contest_id });
+                for (const r of rows)
+                    if (trackedIds.has(r.router_order_id))
+                        applyOrderRow(r);
+            }
+            catch { /* next tick */ }
+            if (!destroyed && !TERMINAL_PHASES.has(state.phase))
+                pollTimer = o.timers.set(tick, o.stream.pollIntervalMs);
+        };
+        pollTimer = o.timers.set(tick, o.stream.pollIntervalMs);
+    }
+    function applyOrderRow(r) {
+        ingestOrderUpdate({
+            type: 'order.update', router_order_id: r.router_order_id, partner_id: r.partner_id, router_contest_id: r.contest_id,
+            status: r.status, fill_status: r.fill_status ?? 'unfilled', filled_amt: r.filled_amt ?? 0, unfilled_amt: r.unfilled_amt ?? 0,
+            avg_price: null, timestamp: new Date(o.now()).toISOString(),
+        });
+        if (r.result)
+            ingestOrderSettled({
+                type: 'order.settled', router_order_id: r.router_order_id, partner_id: r.partner_id, router_contest_id: r.contest_id,
+                result: r.result, winnings: r.winnings ?? 0, net_winnings: r.net_winnings ?? 0, timestamp: new Date(o.now()).toISOString(),
+            });
+    }
+    function ingestOrderUpdate(frame) {
+        if (!trackedIds.has(frame.router_order_id))
+            return;
+        const orders = state.orders.map((t) => t.routerOrderId === frame.router_order_id
+            ? { ...t, status: frame.status, fillStatus: frame.fill_status, filledAmt: frame.filled_amt, unfilledAmt: frame.unfilled_amt, avgPrice: frame.avg_price ?? t.avgPrice, updatedAt: frame.timestamp }
+            : t);
+        state = { ...state, orders };
+        recompute({ phase: phaseFromOrders(orders, state.phase) });
+    }
+    function ingestOrderSettled(frame) {
+        if (!trackedIds.has(frame.router_order_id))
+            return;
+        const orders = state.orders.map((t) => t.routerOrderId === frame.router_order_id
+            ? { ...t, settled: { result: frame.result, winnings: frame.winnings, netWinnings: frame.net_winnings }, updatedAt: frame.timestamp }
+            : t);
+        state = { ...state, orders };
+        recompute({ phase: orders.every((t) => t.settled) ? 'settled' : state.phase });
+    }
+    offs.push(client.events.on('order.update', ingestOrderUpdate));
+    offs.push(client.events.on('order.settled', ingestOrderSettled));
+    offs.push(client.events.on('constraints', () => { constraintsStale = client.constraintsStale(); recompute(); scheduleAutoPreflight(); }));
+    // The stream sends changes only, with no replay: after a (re)connect, read the
+    // tracked orders once so a fill that landed while the socket was down is seen.
+    offs.push(client.events.on('stream.connected', () => { void refetchTracked(); }));
+    async function refetchTracked() {
+        if (destroyed || !state.position || trackedIds.size === 0 || TERMINAL_PHASES.has(state.phase))
+            return;
+        try {
+            const rows = await client.listOrders({ contestId: state.position.contest_id });
+            if (destroyed)
+                return;
+            for (const r of rows)
+                if (trackedIds.has(r.router_order_id))
+                    applyOrderRow(r);
+        }
+        catch { /* the next frame or reconnect tries again */ }
+    }
+    // ── boot ──
+    void load();
+    return {
+        getState: () => state,
+        subscribe(l) { listeners.add(l); return () => { listeners.delete(l); }; },
+        select(partnerId) {
+            if (state.phase === 'placing')
+                return;
+            clearConfirmation();
+            selectedPartnerId = partnerId;
+            if (state.maxPriceIsAuto)
+                userMaxPrice = null;
+            state = { ...state, preflight: null, preflightStatus: 'idle' };
+            recompute();
+            scheduleAutoPreflight();
+        },
+        set(patch) {
+            const next = {};
+            if (patch.stake !== undefined) {
+                next.stake = patch.stake === null
+                    ? { unit: state.stake.unit, value: null }
+                    : 'amount' in patch.stake ? { unit: 'amount', value: patch.stake.amount } : { unit: 'shares', value: patch.stake.shares };
+            }
+            if (patch.maxPrice !== undefined)
+                userMaxPrice = patch.maxPrice;
+            if (patch.orderType !== undefined) {
+                next.orderType = patch.orderType;
+                if (state.maxPriceIsAuto)
+                    userMaxPrice = null;
+            }
+            if (patch.mode !== undefined)
+                next.mode = patch.mode;
+            if (patch.oddsFormat !== undefined)
+                next.oddsFormat = patch.oddsFormat;
+            if (patch.slippage !== undefined)
+                next.slippage = patch.slippage;
+            // Any edit after confirm_required voids the confirmation: the user must
+            // see — and confirm — the order that will actually be placed.
+            clearConfirmation();
+            state = { ...state, error: null };
+            recompute(next);
+            scheduleAutoPreflight();
+        },
+        refresh: load,
+        preflight: (opts = {}) => runPreflight(opts),
+        place,
+        confirm,
+        cancelConfirm() { if (state.phase === 'placing')
+            return; clearConfirmation(); recompute(); },
+        async cancel() {
+            const ids = state.orders.filter((t) => t.fillStatus !== 'filled' && !t.settled).map((t) => t.routerOrderId);
+            if (ids.length === 0)
+                return { cancelled: [], skipped: [] };
+            const res = await client.cancelOrders(ids);
+            const cancelled = res.cancelled.map((c) => c.router_order_id);
+            const orders = state.orders.map((t) => cancelled.includes(t.routerOrderId) ? { ...t, status: 'cancelled', updatedAt: new Date(o.now()).toISOString() } : t);
+            state = { ...state, orders };
+            recompute({ phase: cancelled.length > 0 && orders.every((t) => t.status === 'cancelled' || t.fillStatus === 'filled') ? 'cancelled' : state.phase });
+            return { cancelled, skipped: [...res.skipped.map((s) => s.router_order_id), ...res.errors.map((e) => e.router_order_id)] };
+        },
+        reset() {
+            if (state.phase === 'placing')
+                return;
+            clearConfirmation();
+            userMaxPrice = init.maxPrice ?? null;
+            trackedIds.clear();
+            state = { ...state, stake: { unit: state.stake.unit, value: null }, result: null, orders: [], preflight: null, preflightStatus: 'idle', error: null };
+            recompute({ phase: 'idle' });
+        },
+        destroy() {
+            if (destroyed)
+                return;
+            destroyed = true;
+            clearConfirmation();
+            listeners.clear();
+            for (const off of offs)
+                off();
+            if (preflightTimer)
+                o.timers.clear(preflightTimer);
+            if (pollTimer)
+                o.timers.clear(pollTimer);
+        },
+        ingestOrderUpdate,
+        ingestOrderSettled,
+    };
+}
+// ─── helpers ───────────────────────────────────────────────────────────────────
+function refPartner(ref) {
+    if ('liquidityHash' in ref)
+        return ref.liquidityHash.split(':')[0] || null;
+    if ('partnerId' in ref && ref.partnerId)
+        return ref.partnerId;
+    return null;
+}
+export function newIdempotencyKey() {
+    const c = globalThis.crypto;
+    if (c?.randomUUID)
+        return `oms_${c.randomUUID()}`;
+    return `oms_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 12)}`;
+}
+function confirmLabel(phase, mode, venue, cost, o) {
+    const L = o.labels;
+    if (phase === 'placing')
+        return L.placing;
+    if (phase === 'confirming')
+        return `${L.confirmReal}${cost ? ` · ${cost}` : ''}${venue ? ` on ${venue.name}` : ''}`;
+    const verb = mode === 'real' ? L.placeReal : L.placePractice;
+    return cost && phase !== 'idle' ? `${verb} · ${cost}` : verb;
+}
+export function phaseFromSummary(summary) {
+    switch (summary) {
+        case 'filled': return 'filled';
+        case 'partial': return 'partial';
+        case 'resting': return 'resting';
+        case 'pending': return 'pending';
+        case 'failed': return 'failed';
+    }
+}
+/** Fold every tracked order's fill state into one phase. */
+export function phaseFromOrders(orders, current) {
+    if (orders.length === 0)
+        return current;
+    if (orders.every((t) => t.settled))
+        return 'settled';
+    if (orders.every((t) => t.fillStatus === 'filled'))
+        return 'filled';
+    if (orders.every((t) => t.status === 'cancelled'))
+        return orders.some((t) => t.filledAmt > 0) ? 'partial' : 'cancelled';
+    if (orders.some((t) => t.status === 'cancelled' || t.status === 'closed')) {
+        return orders.some((t) => t.filledAmt > 0) ? 'partial' : 'failed';
+    }
+    if (orders.some((t) => t.fillStatus === 'partially_filled'))
+        return 'partial';
+    return current === 'pending' ? 'pending' : 'resting';
+}
+export function toPlaceResult(raw, venue, account, idempotencyKey, now) {
+    const practiceBook = account?.practiceWallet.partnerId ?? null;
+    const legs = raw.results.map((r) => {
+        const routed = r.venues.map((v) => v.partner_id);
+        const isPaperBook = routed.length > 0 && practiceBook != null && routed.every((p) => p === practiceBook);
+        const substituted = !!r.requested_partner_id && routed.length > 0 && routed.some((p) => p !== r.requested_partner_id) && !isPaperBook;
+        const issue = r.rejected_code
+            ? {
+                code: r.rejected_code, severity: 'block', scope: 'leg', source: 'server',
+                message: r.message_user ?? localIssue(r.rejected_code, { venue: venue.name, detail: r.rejected_reason ?? undefined }).message,
+                detail: r.rejected_reason, fix: r.fix ?? localIssue(r.rejected_code).fix,
+            }
+            : (r.status === 'failed' || r.status === 'rejected')
+                ? { code: 'unknown', severity: 'block', scope: 'leg', source: 'server', message: r.rejected_reason ?? 'The venue declined this order.', detail: r.rejected_reason, fix: 'retry' }
+                : null;
+        return {
+            index: r.index, status: r.status, partnerId: r.requested_partner_id, routedPartnerIds: routed, substituted,
+            routerOrderIds: r.venues.map((v) => v.router_order_id).filter((id) => !!id),
+            fill: { notional: r.filled_notional, shares: r.filled_shares, avgPrice: r.avg_price, unfilled: r.unfilled_notional },
+            issue, sorDecisionId: r.sor_decision_id,
+        };
+    });
+    return { summary: summarize(legs), legs, opportunityId: raw.opportunity_id, idempotencyKey, placedAt: now, raw };
+}
+export function summarize(legs) {
+    if (legs.length === 0)
+        return 'failed';
+    if (legs.some((l) => l.status === 'failed' || l.status === 'rejected')) {
+        return legs.some((l) => l.fill.notional > 0) ? 'partial' : 'failed';
+    }
+    if (legs.some((l) => l.status === 'resting'))
+        return 'resting';
+    if (legs.some((l) => l.status === 'pending'))
+        return 'pending';
+    return legs.some((l) => l.fill.unfilled > 0.005) ? 'partial' : 'filled';
+}
+export function describeCost(n, currency) {
+    return formatMoney(n, currency);
+}
+//# sourceMappingURL=sheet.js.map