gloomberb 0.18.1 → 0.18.2

package/src/plugins/builtin/broker-trading/strategy.ts

@@ -0,0 +1,153 @@
+import type { Quote } from "../../../types/financials";
+import type { BrokerContractRef } from "../../../types/instrument";
+import type { BrokerOrderLeg, BrokerOrderRequest } from "../../../types/trading";
+import { chainOptionContract, formatExpDate, optionContractIdentity } from "../../../utils/options";
+
+type Side = "BUY" | "SELL";
+
+/** A strategy leg as a builder holds it: an OCC contract, signed contracts, and a premium per share to tell debit from credit. */
+export interface StrategyLegInput { contractSymbol: string; quantity: number; price?: number }
+
+/** A leg a ticket opens with, before it is bound to a broker profile. */
+export interface StrategyIntentLeg { contractSymbol: string; action: Side; ratio: number }
+
+export interface StrategyIntent { action: Side; quantity: number; legs: StrategyIntentLeg[] }
+
+/** The most legs any broker's multi-leg order takes. */
+export const MAX_STRATEGY_LEGS = 4;
+
+const gcd = (a: number, b: number): number => b ? gcd(b, a % b) : a;
+const flip = (action: Side): Side => action === "BUY" ? "SELL" : "BUY";
+
+/**
+ * A builder's legs as one order: each leg keeps its side, the common factor of
+ * the contract counts becomes the spread quantity, and the entry premiums say
+ * whether opening it pays a debit (BUY) or receives a credit (SELL). Null when
+ * a quantity is not a whole number of contracts.
+ */
+export function strategyFromLegs(inputs: readonly StrategyLegInput[]): StrategyIntent | null {
+  const legs = inputs.filter((leg) => leg.quantity !== 0);
+  if (!legs.length || legs.some((leg) => !Number.isSafeInteger(leg.quantity) || !leg.contractSymbol.trim())) return null;
+  const quantity = legs.map((leg) => Math.abs(leg.quantity)).reduce(gcd);
+  const net = legs.every((leg) => Number.isFinite(leg.price)) ? legs.reduce((sum, leg) => sum + leg.quantity * leg.price!, 0) : 0;
+  return {
+    action: net < 0 ? "SELL" : "BUY", quantity,
+    legs: legs.map((leg) => ({ contractSymbol: leg.contractSymbol.trim().toUpperCase(), action: leg.quantity > 0 ? "BUY" : "SELL", ratio: Math.abs(leg.quantity) / quantity })),
+  };
+}
+
+/** The opposite trade: every leg the other way, and a debit becomes a credit. */
+export function reverseStrategy<T extends { action: Side; legs?: readonly { action: Side }[] }>(order: T): T {
+  return { ...order, action: flip(order.action), ...(order.legs ? { legs: order.legs.map((leg) => ({ ...leg, action: flip(leg.action) })) } : {}) };
+}
+
+/** The order's contract: the underlying's symbol on the same profile, as a combo. */
+export function strategyContract(underlying: BrokerContractRef, currency?: string): BrokerContractRef {
+  return { brokerId: underlying.brokerId, ...(underlying.brokerInstanceId ? { brokerInstanceId: underlying.brokerInstanceId } : {}),
+    symbol: underlying.symbol.trim().toUpperCase(), secType: "BAG", exchange: "SMART", currency: currency || underlying.currency || "USD", multiplier: "100" };
+}
+
+/** Binds a strategy's legs to the underlying's broker profile; null when one is not a listed contract of that underlying. */
+export function strategyOrderLegs(legs: readonly StrategyIntentLeg[], underlying: BrokerContractRef, currency?: string): BrokerOrderLeg[] | null {
+  const bound = legs.map((leg) => {
+    const contract = chainOptionContract(leg.contractSymbol, underlying, currency || underlying.currency || "USD");
+    return contract && contract.symbol === underlying.symbol.trim().toUpperCase() ? { contract, action: leg.action, ratio: leg.ratio } : null;
+  });
+  return bound.every((leg): leg is BrokerOrderLeg => leg !== null) ? bound : null;
+}
+
+export function isStrategyOrder(order: { contract: BrokerContractRef; legs?: readonly unknown[] }): boolean {
+  return !!order.legs?.length || order.contract.secType?.toUpperCase() === "BAG";
+}
+
+/**
+ * The spread's quote from its legs' quotes, as the debit side reads it: bid is
+ * what selling one spread receives at once, ask what buying one pays. A credit
+ * order sells that debit spread, so it reads the bid, as a sell does.
+ */
+export function strategyQuote(request: Pick<BrokerOrderRequest, "action" | "legs" | "contract">, quotes: readonly (Quote | undefined)[]): Quote | null {
+  const legs = request.legs ?? [];
+  if (!legs.length || quotes.length !== legs.length) return null;
+  let bid = 0, ask = 0;
+  for (const [index, leg] of legs.entries()) {
+    const quote = quotes[index];
+    if (!quote || !Number.isFinite(quote.bid) || !Number.isFinite(quote.ask)) return null;
+    // The debit side buys what a BUY order buys, and buys back what a SELL order sells.
+    const buys = (leg.action === "BUY") === (request.action === "BUY");
+    bid += buys ? leg.ratio * quote.bid! : -leg.ratio * quote.ask!;
+    ask += buys ? leg.ratio * quote.ask! : -leg.ratio * quote.bid!;
+  }
+  const round = (value: number) => Math.round(value * 1e6) / 1e6;
+  const present = quotes as Quote[];
+  return {
+    symbol: request.contract.symbol, name: strategyName(legs), price: round((bid + ask) / 2), bid: round(bid), ask: round(ask),
+    change: NaN, changePercent: NaN, currency: request.contract.currency ?? present[0]!.currency,
+    lastUpdated: Math.min(...present.map((quote) => quote.lastUpdated)),
+    dataSource: present.every((quote) => quote.dataSource === "live") ? "live" : "delayed",
+    stale: present.some((quote) => quote.stale === true), marketState: present[0]!.marketState,
+  };
+}
+
+interface ParsedLeg { underlying: string; expiry: string; right: "C" | "P"; strike: number; action: Side; ratio: number }
+
+function parseLeg(leg: { contract?: BrokerContractRef; contractSymbol?: string; action: Side; ratio: number }): ParsedLeg | null {
+  const identity = leg.contract ? optionContractIdentity(leg.contract) : optionContractIdentity({ brokerId: "", symbol: leg.contractSymbol ?? "", secType: "OPT" });
+  const [underlying, expiry, right, strike] = identity?.split("|") ?? [];
+  return underlying && expiry && (right === "C" || right === "P") ? { underlying, expiry, right, strike: Number(strike), action: leg.action, ratio: leg.ratio } : null;
+}
+
+type NamedLeg = { contract?: BrokerContractRef; contractSymbol?: string; action: Side; ratio: number };
+
+/** "AAPL call vertical", "SPY iron condor", or "AAPL 3-leg spread" when the shape has no common name. */
+export function strategyName(legs: readonly NamedLeg[]): string {
+  const underlying = parseLeg(legs[0] ?? { action: "BUY", ratio: 1 })?.underlying;
+  return [underlying, strategyShape(legs)].filter(Boolean).join(" ");
+}
+
+/** The shape alone, for a list already on its underlying: "call vertical". */
+export function strategyShape(legs: readonly NamedLeg[]): string {
+  const parsed = legs.map(parseLeg);
+  const named = (shape: string) => shape;
+  if (parsed.some((leg) => !leg) || new Set(parsed.map((leg) => leg!.underlying)).size > 1) return named(`${legs.length}-leg spread`);
+  const all = parsed as ParsedLeg[];
+  const same = <K extends keyof ParsedLeg>(key: K, set = all) => new Set(set.map((leg) => leg[key])).size === 1;
+  const right = (leg: ParsedLeg) => leg.right === "C" ? "call" : "put";
+  const [a, b] = all;
+  if (all.length === 2 && a && b) {
+    const opposite = a.action !== b.action;
+    if (same("right") && opposite && a.ratio !== b.ratio && same("expiry")) return named(`${right(a)} ratio spread`);
+    if (same("right") && opposite && same("expiry")) return named(`${right(a)} vertical`);
+    if (same("right") && opposite && same("strike")) return named(`${right(a)} calendar`);
+    if (same("right") && opposite) return named(`${right(a)} diagonal`);
+    if (!same("right") && !opposite && same("expiry")) return named(same("strike") ? "straddle" : "strangle");
+  }
+  if (all.length === 3 && same("right") && same("expiry")) {
+    const [low, middle, high] = all.toSorted((x, y) => x.strike - y.strike);
+    if (low && middle && high && low.action === high.action && middle.action !== low.action && middle.ratio === low.ratio + high.ratio
+      && Math.abs(middle.strike - low.strike - (high.strike - middle.strike)) < 1e-9) return named(`${right(low)} butterfly`);
+  }
+  if (all.length === 4 && same("expiry") && all.filter((leg) => leg.right === "C").length === 2) {
+    const calls = all.filter((leg) => leg.right === "C").toSorted((x, y) => x.strike - y.strike);
+    const puts = all.filter((leg) => leg.right === "P").toSorted((x, y) => x.strike - y.strike);
+    // Short the inner strikes, long the wings (or the reverse): the two verticals of an iron condor.
+    if (calls[0]!.action !== calls[1]!.action && puts[0]!.action !== puts[1]!.action && calls[0]!.action === puts[1]!.action
+      && puts[1]!.strike <= calls[0]!.strike) return named(puts[1]!.strike === calls[0]!.strike ? "iron butterfly" : "iron condor");
+  }
+  return named(`${all.length}-leg spread`);
+}
+
+/** "Buy 1 · Oct 26 '26 345 Call": a leg's side, contracts per spread times the spread count, and its contract. */
+export function strategyLegLabel(leg: BrokerOrderLeg, spreads = 1): { side: string; contracts: string; contract: string } {
+  const parsed = parseLeg(leg);
+  const contracts = Number.isFinite(spreads) && spreads > 0 ? leg.ratio * spreads : leg.ratio;
+  if (!parsed) return { side: leg.action === "BUY" ? "Buy" : "Sell", contracts: String(contracts), contract: leg.contract.localSymbol || leg.contract.symbol };
+  const expiry = formatExpDate(Date.UTC(Number(parsed.expiry.slice(0, 4)), Number(parsed.expiry.slice(4, 6)) - 1, Number(parsed.expiry.slice(6, 8))) / 1000);
+  const strike = parsed.strike.toLocaleString("en-US", { maximumFractionDigits: 3 });
+  return { side: leg.action === "BUY" ? "Buy" : "Sell", contracts: String(contracts), contract: `${expiry} ${strike} ${parsed.right === "C" ? "Call" : "Put"}` };
+}
+
+/** An order's instrument in a row or toast: the strategy's name for a spread, else the contract's symbol. */
+export function orderInstrumentLabel(order: { contract: BrokerContractRef; legs?: readonly BrokerOrderLeg[] }): string {
+  if (order.legs?.length) return strategyName(order.legs);
+  return order.contract.secType?.toUpperCase() === "BAG" ? `${order.contract.symbol} spread` : order.contract.localSymbol || order.contract.symbol;
+}

package/src/plugins/builtin/broker-trading/ticket-parts.tsx

@@ -0,0 +1,117 @@
+import { FigureText } from "../../../components/ui/figure";
+import type { ReactNode } from "react";
+import { KeyValueRow, Notice, RatioBar, SectionHeading } from "../../../components";
+import { useThemeColors } from "../../../theme/theme-context";
+import { Box, Text, TextAttributes, useUiCapabilities } from "../../../ui";
+import type { TicketViewModel } from "./ticket";
+import { strategyLegLabel } from "./strategy";
+import { orderEstimatePrice } from "./orders-data";
+
+export const ticketNumber = (value: number | undefined) => value === undefined || !Number.isFinite(value) ? "Unavailable" : value.toLocaleString("en-US", { maximumFractionDigits: 4 });
+export const ticketMoney = (value: number | undefined, currency = "USD") => value === undefined || !Number.isFinite(value) ? "Not reported" : new Intl.NumberFormat("en-US", { style: "currency", currency, maximumFractionDigits: 2 }).format(value);
+export const ticketTypeName: Record<string, string> = { MKT: "Market", LMT: "Limit", STP: "Stop", "STP LMT": "Stop limit" };
+export const ticketTifName: Record<string, string> = { DAY: "Day", GTC: "Good til cancelled", IOC: "Immediate or cancel", FOK: "Fill or kill", EXTENDED_HOURS: "Extended hours", AT_THE_OPENING: "At the opening", AT_THE_CLOSE: "At the close" };
+/** `selectable`: a review or receipt whose figures someone may copy by hand. */
+export function TicketSection({ children, width, title, selectable = false }: { children: ReactNode; width?: number; title?: string; selectable?: boolean }) {
+  const native = useUiCapabilities().nativePaneChrome;
+  return <Box width={width} flexDirection="column" flexShrink={0} gap={native ? 0.35 : 0} data-gloom-selectable={selectable ? "true" : undefined}>
+    {title ? <SectionHeading title={title} /> : null}{children}
+  </Box>;
+}
+export function TicketReceiptRow({ label, value, color, width, emphasis = false }: { label: string; value: string; width: number; color?: string; emphasis?: boolean }) {
+  return <KeyValueRow label={label} value={value} width={width} labelWidth={Math.min(24, Math.floor(width * 0.48))} align="right" color={color} emphasis={emphasis} />;
+}
+export function TicketOrderHeadline({ model: m, large = false }: { model: TicketViewModel; large?: boolean }) {
+  const c = useThemeColors(); const draft = m.draft; const side = draft?.action === "SELL" ? "Sell" : "Buy";
+  return <Box flexDirection="row" alignItems="center" gap={1} flexWrap="wrap">
+    <FigureText part={large ? "value" : "sub"} fg={side === "Buy" ? c.positive : c.negative} style={large ? undefined : { fontSize: "var(--gloom-type-heading)", fontWeight: "var(--gloom-weight-bold)" }}>{side}</FigureText>
+    <FigureText part={large ? "value" : "sub"} style={large ? undefined : { fontSize: "var(--gloom-type-heading)", fontWeight: "var(--gloom-weight-bold)" }}>{`${ticketNumber(draft?.quantity)} ${m.symbol}`}</FigureText>
+  </Box>;
+}
+/** A spread's legs as they fill: side, contracts across all spreads, contract, and each leg's mid at this broker. */
+/** `inset`: in the order form, the legs line up with the fields' labels. */
+export function TicketLegs({ model: m, width, inset = false }: { model: TicketViewModel; width: number; inset?: boolean }) {
+  const c = useThemeColors();
+  const native = useUiCapabilities().nativePaneChrome;
+  const draft = m.draft;
+  if (!draft?.legs?.length) return null;
+  const pad = inset && !native ? 2 : 0;
+  return <Box flexDirection="column" width={width} paddingLeft={pad} data-gloom-selectable="true">
+    {draft.legs.map((leg, index) => {
+      const label = strategyLegLabel(leg, draft.quantity);
+      const quote = m.legQuotes?.[index];
+      const mid = quote && Number.isFinite(quote.bid) && Number.isFinite(quote.ask) ? (quote.bid! + quote.ask!) / 2 : undefined;
+      return <Box key={index} flexDirection="row" gap={1}>
+        <Text fg={leg.action === "BUY" ? c.positive : c.negative} attributes={TextAttributes.BOLD}>{label.side}</Text>
+        <Text fg={c.text}>{label.contracts}</Text>
+        <Box flexGrow={1} minWidth={0}><Text fg={c.text} truncate>{label.contract}</Text></Box>
+        {mid !== undefined ? <Text fg={c.textDim}>{mid.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 4 })}</Text> : null}
+      </Box>;
+    })}
+  </Box>;
+}
+export function TicketOrderSummary({ model: m, width, compact = false, receipt = false }: { model: TicketViewModel; width: number; compact?: boolean; receipt?: boolean }) {
+  const c = useThemeColors(); const draft = m.draft; const account = m.accounts.find((a) => a.accountId === m.accountId);
+  // A ticker opened by its symbol alone can carry an empty currency, which no formatter takes.
+  const currency = draft?.contract.currency || account?.currency || "USD";
+  const px = draft ? orderEstimatePrice(draft, m.quote) : undefined;
+  const total = m.phase === "result" ? m.preview?.estimatedCost === undefined ? undefined : Math.abs(m.preview.estimatedCost) : draft && px !== undefined ? px * draft.quantity * Number(draft.contract.multiplier ?? 1) : undefined;
+  const strategy = !!draft?.legs?.length;
+  const unit = strategy ? "spreads" : draft?.contract.secType === "OPT" ? "contracts" : "shares";
+  // A spread changes each leg's position, which its legs list.
+  const positionAfter = !strategy && m.position !== undefined && draft ? m.position + (draft.action === "SELL" ? -draft.quantity : draft.quantity) : undefined;
+  const powerAfter = m.preview?.buyingPowerAfter;
+  const sideColor = draft?.action === "SELL" ? c.negative : c.positive;
+  if (compact && receipt) return <Box flexDirection="column">
+    <Text fg={c.textDim}>Buying power · broker preview</Text>
+    <TicketReceiptRow label={powerAfter === undefined ? "Impact" : "After order"} value={ticketMoney(powerAfter ?? m.preview?.buyingPowerImpact, currency)} width={width} />
+  </Box>;
+  if (compact) return <Box flexDirection="row" justifyContent="space-between" paddingX={1} backgroundColor={c.panel}>
+    <Text fg={sideColor} attributes={TextAttributes.BOLD}>{`${draft?.action ?? "BUY"} ${ticketNumber(draft?.quantity)} ${m.symbol}`}</Text>
+    <Text fg={c.textBright} attributes={TextAttributes.BOLD}>{`Est. ${ticketMoney(total, currency)}`}</Text>
+  </Box>;
+  const rowWidth = width;
+  if (receipt) return <TicketSection width={width} title="Account impact" selectable>
+    <Text fg={c.textDim}>After this order fills</Text>
+    {strategy ? <Box paddingY={1}><TicketLegs model={m} width={rowWidth} /></Box> : <>
+      <Box paddingY={1}><FigureText>{positionAfter === undefined ? "Unknown position" : `${ticketNumber(positionAfter)} ${unit}`}</FigureText></Box>
+      <TicketReceiptRow label="Current position" value={ticketNumber(m.position)} width={rowWidth} />
+      <TicketReceiptRow label="Order quantity" value={`${draft?.action === "SELL" ? "−" : "+"}${ticketNumber(draft?.quantity)}`} color={sideColor} width={rowWidth} />
+    </>}
+    <Box marginTop={1}><SectionHeading title="Buying power · broker preview" /></Box>
+    <TicketReceiptRow label="Before order" value={ticketMoney(m.preview?.buyingPowerBefore ?? account?.buyingPower, currency)} width={rowWidth} />
+    <TicketReceiptRow label="Broker impact" value={ticketMoney(m.preview?.buyingPowerImpact, currency)} width={rowWidth} />
+    <TicketReceiptRow label="After order" value={ticketMoney(m.preview?.buyingPowerAfter, currency)} width={rowWidth} />
+  </TicketSection>;
+  return <TicketSection width={width} title="Order summary" selectable>
+    <TicketOrderHeadline model={m} large />
+    <Text fg={c.textDim}>{`${ticketTypeName[draft?.orderType ?? "LMT"]} · ${ticketTifName[draft?.tif ?? "DAY"] ?? draft?.tif}${draft?.outsideRth ? " · Outside RTH" : ""}`}</Text>
+    <Box flexDirection="column" paddingY={1}><Text fg={c.textDim}>Estimated order value</Text><FigureText>{ticketMoney(total, currency)}</FigureText></Box>
+    {strategy ? <TicketLegs model={m} width={rowWidth} /> : null}
+    <TicketReceiptRow label="Quantity" value={`${ticketNumber(draft?.quantity)} ${unit}`} width={rowWidth} />
+    <TicketReceiptRow label={strategy ? draft?.action === "SELL" ? "Net credit" : "Net debit" : "Price"} value={draft?.orderType === "MKT" ? "At market" : ticketMoney(px, currency)} width={rowWidth} />
+    {m.phase === "result" ? <Text fg={c.textDim}>Estimates from order preview</Text> : null}
+    <TicketReceiptRow label="Fees / commission" value={m.preview || m.phase === "result" ? `${ticketMoney(m.preview?.fees, currency)} / ${ticketMoney(m.preview?.commission, currency)}` : "At review"} width={rowWidth} />
+    <TicketReceiptRow label="Broker power after" value={ticketMoney(powerAfter, currency)} width={rowWidth} />
+    {strategy ? null : <TicketReceiptRow label="Position after" value={positionAfter === undefined ? "Not reported" : `${ticketNumber(positionAfter)} ${unit}`} width={rowWidth} />}
+    {m.phase !== "result" ? <Box marginTop={1}><Notice variant="callout" tone="warning">{m.quoteData !== "realtime" ? "Delayed broker quote. Execution prices may differ." : "Final cost and availability are checked at review."}</Notice></Box> : null}
+  </TicketSection>;
+}
+export function TicketStatus({ model: m, width }: { model: TicketViewModel; width: number }) {
+  const native = useUiCapabilities().nativePaneChrome;
+  const c = useThemeColors(); const status = m.result?.status.toUpperCase() ?? "UNKNOWN";
+  const filled = status === "FILLED"; const partial = status === "PARTIALLY_FILLED"; const active = !["UNKNOWN", "REJECTED", "CANCELLED", "CANCELED", "PENDING_CANCEL"].includes(status);
+  const currentStep = filled ? 2 : ["SUBMITTED", "PENDING_NEW"].includes(status) ? 0 : 1;
+  return <Box flexDirection="column" gap={native ? 0.35 : 0}>
+    {active ? <Box flexDirection="row" gap={1}>{["Submitted", "Working", "Filled"].map((label, index) =>
+      <Text key={label} fg={index <= currentStep ? c.positive : c.textDim} attributes={index === currentStep ? TextAttributes.BOLD : undefined}>{`${index ? "· " : ""}${label}`}</Text>)}</Box> : null}
+    {partial || filled ? <>
+      <RatioBar width={Math.max(10, width)} ratio={(m.result?.filled ?? 0) / Math.max(1, m.result?.quantity ?? 1)} color={c.positive} track thickness={6} />
+      <Text fg={c.text} wrapText>{`${ticketNumber(m.result?.filled)} of ${ticketNumber(m.result?.quantity)} filled · Avg. ${ticketMoney(m.result?.avgFillPrice, m.draft?.contract.currency)}`}</Text>
+    </> : null}
+    {status === "UNKNOWN" ? <Notice variant="callout" tone="warning">
+      {m.result?.orderId ? "Not confirmed yet. Checking with the broker." : "Not confirmed. Check open orders before placing it again."}</Notice> : null}
+    {status === "REJECTED" ? <Notice variant="callout" tone="negative">{m.error ?? m.result?.warningText ?? "The broker rejected this order. Check the order before trying again."}</Notice> : null}
+    {status === "PENDING_CANCEL" ? <Notice variant="callout" tone="warning">Cancellation requested. The order can still fill until the broker confirms.</Notice> : null}
+  </Box>;
+}