@openmarketsai/order-sheet 0.1.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/NOTICE

@@ -0,0 +1,5 @@
+OpenMarkets SDK
+Copyright 2026 OpenMarkets
+
+This product includes software developed at OpenMarkets
+(https://app.openmarkets.ai/developers).

package/README.md

@@ -0,0 +1,183 @@
+# @openmarketsai/order-sheet
+
+**The bet slip, solved.** Every venue's rules, fees and balances checked before the tap — in your app's style.
+
+Zero runtime dependencies. React optional. Types included.
+
+The sheet carries **no venue name and no venue rule**. The OpenMarkets API serves the rules for the account in front of it (`GET /flow/v1/auth/orders/constraints`); the sheet validates against that table for instant feedback, refines the numbers through `POST /orders/preflight`, places through `POST /orders/buy`, and follows the order on the stream to fill and settlement. When a venue changes its minimum, nothing in your app changes. (The only numbers of its own are platform-wide fallbacks used before the constraints load — the 1¢–99¢ probability band — and the default 2¢ market-order slippage, which you set with `defaults.slippage`.)
+
+```bash
+npm install @openmarketsai/order-sheet
+```
+
+Three entry points:
+
+| Entry | What | Needs |
+|---|---|---|
+| `@openmarketsai/order-sheet` | headless core — a state machine + API client for one slip; browser, Node, agents | nothing |
+| `@openmarketsai/order-sheet/react` | hooks + **unstyled** primitives with `data-oms-part` attributes | `react` |
+| `@openmarketsai/order-sheet/ui` | the styled `<OrderSheetCard>`, OpenMarkets brand by default, themeable | `react` + `ui/styles.css` |
+
+## Founder rules the SDK enforces
+
+- **The user picks the venue.** The sheet lists every venue quoting the position, sorted cheapest-first with a `best` badge, and may say *"40¢ available on Polymarket — switch?"*. It never switches for them. Best-price routing is coming; nothing here pre-empts it.
+- **Practice by default; real money is opt-in twice.** Every leg is sent with an explicit `mode` (the API's own default is *real*) — the raw `om.buy()` / `om.preflight()` refuse a leg without one, and `om.buy()` refuses a `real` leg unless `realMoney.enabled`. Real money requires the developer to enable it (`realMoney.enabled`) **and** the account to be able to (`money_modes` from the server: plan, environment, execution policy) — and then a second confirm click per order. A confirmation covers exactly the inputs it was shown with: any edit voids it and the user confirms again.
+- **Never re-encode a venue rule.** Minimums, whole contracts, `min_contracts`, increments, price bands and ticks, fee direction, fill semantics, what's connected and funded — all read from the server. The server stays the authority: a preflight or buy answer always overrides a local check.
+- **No auto-retry of a buy, no double submit.** A fresh `Idempotency-Key` per placement (generated by `om.buy()` too when you pass none), kept across a transport failure so *your* retry replays instead of doubling. While a placement is in flight, `place()` / `confirm()` return that same promise.
+
+## Headless — no framework, no DOM
+
+```ts
+import { createOrderSheetClient } from '@openmarketsai/order-sheet'
+
+const om = createOrderSheetClient({
+  apiKey: process.env.OM_EXEC_KEY!,       // or { getToken } (player JWT) or { auth } (app-sdk)
+  // baseUrl: 'https://api.openmarkets.ai',
+  // realMoney: { enabled: false, confirm: true },   ← the defaults. `confirm: false` removes the
+  //   second click on real orders: only do that if YOUR UI already makes the user confirm the exact
+  //   order — the SDK then places real money on the first place(), and that is your liability.
+  // defaults: { mode: 'paper', orderType: 'market', stakeUnit: 'amount', slippage: 0.02, oddsFormat: 'cents' },
+})
+
+// One slip per position. From a liquidity cell, a position hash, or a full position.
+const sheet = om.openSheet({ liquidityHash: cell.liquidity_hash })
+
+sheet.subscribe((s) => console.log(s.phase, s.validation.blocking.map((i) => i.message)))
+
+sheet.set({ stake: { amount: 5 } })       // or { shares: 10 }; also maxPrice, orderType, mode, oddsFormat
+sheet.select('pg-kalshi')                  // the user's choice — never the cheapest by default
+
+const s = sheet.getState()
+s.venues          // VenueOption[] — price, available, account { connected, expectedBalance }, eligibility { status, issues }, best
+s.quote           // contracts, cost, payout, leftover, fee (estimated → exact after preflight), effectivePrice, profit, display.*
+s.validation      // { ok, blocking, warnings, info } — Issue { code, severity, message, fix, scope, source }
+
+await sheet.preflight()                     // exact fees, expected fill, every pre-placement check, in the server's words
+const out = await sheet.place()             // { status: 'placed', result } | { status: 'blocked', issues } | { status: 'confirm_required' }
+if (out.status === 'confirm_required') await sheet.confirm()   // places only if nothing changed since; else { status: 'blocked', issues: [confirm_expired] }
+if (out.status === 'placed') console.log(out.result.summary, out.result.legs[0].fill)   // 'filled' { shares: 11, notional: 4.62, avgPrice: 0.42, unfilled: 0.38 }
+
+// Afterwards
+sheet.getState().phase     // 'filled' | 'partial' | 'resting' | 'pending' | 'failed' → 'settled' | 'cancelled' (follows the orders stream)
+await sheet.cancel()       // the resting order(s) this sheet placed
+```
+
+Errors: a transport/4xx failure **throws** `OrderSheetError { code, status, retryable, details }` (the code is the API's — `real_money_not_permitted`, `unsupported_order_type`, …). A leg the venue declines **never throws**: it is `result.legs[i].issue`, the same `Issue` shape the validation uses, with the server's plain-language `message` and a `fix`.
+
+Multi-leg: `om.buy(legs, { atomic: true })` expands to the hedge recipe (`check_all_first` + `on_leg_failure: 'halt'` + `placement: 'parallel'` + `verify_liquidity`). A multi-leg *sheet* (`openSlip`) is a later phase; the types are shaped for it.
+
+## React — hooks + unstyled primitives
+
+```tsx
+import { OrderSheet, useOrderSheet } from '@openmarketsai/order-sheet/react'
+
+function Slip({ om, cell }) {
+  const h = useOrderSheet(om, { liquidityHash: cell.liquidity_hash })   // subscribes; re-renders on state
+  return (
+    <OrderSheet.Root handle={h} onOutcome={(o) => console.log(o)}>
+      <OrderSheet.Venues />             {/* <div data-oms-part="venue" data-state="ok|warn|blocked" data-best data-selected> */}
+      <OrderSheet.Mode />               {/* practice / real, aria-pressed */}
+      <OrderSheet.Stake />  <OrderSheet.Price />
+      <OrderSheet.Quote />  <OrderSheet.Issues />  <OrderSheet.Hint />
+      <OrderSheet.Submit />             {/* disabled until canPlace; label "Place practice order · $5.00" */}
+      <OrderSheet.Outcome />
+    </OrderSheet.Root>
+  )
+}
+```
+
+`useOrderSheet` opens the sheet in an effect, so server rendering (Next.js client components included) fetches nothing and starts no timer; until the effect runs the handle is `phase: 'loading'` and its actions are inert. `<OrderSheet.Venues>` is a WAI-ARIA radio group: one venue is in the tab order (the selected one, else the first enabled), arrow keys / Home / End move and select, skipping venues the mode blocks.
+
+Every primitive renders a plain element with `data-oms-part="…"` and state attributes and **no class of its own**, so a Tailwind user styles them with `[data-oms-part=submit][data-mode=real]:bg-red-600`. Each takes `className`, spreads the rest, and accepts `render` / `children` to swap the markup while keeping the wiring. Wrap the tree in `<OrderSheetProvider client={om}>` to omit the client argument; `useOrderSheetAccount()` gives `money_modes` before any position is open.
+
+## Styled — `<OrderSheetCard>` in the OpenMarkets brand
+
+```tsx
+import { OrderSheetCard } from '@openmarketsai/order-sheet/ui'
+import '@openmarketsai/order-sheet/ui/styles.css'
+
+<OrderSheetCard client={om} position={{ liquidityHash }} />
+```
+
+Zinc neutrals, indigo accent, JetBrains Mono for numbers, 4px radius, no shadows; light / dark by system preference. Practice CTA in the accent; the real-money CTA in the danger colour with a confirm step. Container queries, not media queries, drive the layout — the sheet adapts to *its* box.
+
+### Theming
+
+Three levels, cheapest first.
+
+**1. A theme** — colours, type, radius, density, scheme. Partial overrides deep-merge over a preset; a strong colour given alone derives its tint.
+
+```tsx
+import { OrderSheetCard, OrderSheetTheme, createTheme, presets } from '@openmarketsai/order-sheet/ui'
+
+const theme = createTheme({
+  scheme: 'system',                              // 'light' | 'dark' | 'system'
+  accent: '#c7780f',                             // one value for both schemes …
+  danger: { light: '#b91c1c', dark: '#f87171' }, // … or one per scheme
+  font: '"Söhne", system-ui, sans-serif',
+  radius: '10px',
+  density: 0.9,                                  // 0.85 compact · 1 · 1.15 touch
+})
+// or start from a preset: createTheme({ accent: '#000' }, presets.slate)
+
+<OrderSheetTheme theme={theme}>                  {/* <div class="oms-root oms-theme-…"> + a scoped <style> of --oms-* vars */}
+  <OrderSheetCard client={om} position={{ liquidityHash }} />
+</OrderSheetTheme>
+```
+
+The stylesheet's contract with your page: every rule under `.oms-root`, every class `oms-*`, every variable `--oms-*`, all inside `@layer oms` (your unlayered rules always win), no `:root` / `body` / `*` rules, no `@font-face`. Force a scheme on any ancestor with `data-oms-theme="light|dark"`.
+
+**2. `classNames` per part** — a string, or a function of that part's state:
+
+```tsx
+<OrderSheetCard … classNames={{
+  root: 'my-slip',
+  submit: ({ handle }) => handle.mode === 'real' && 'my-danger-cta',
+  venueName: ({ venue }) => venue?.best && 'font-bold',
+}} />
+```
+
+Parts: `root header title subtitle venues venue venueName venuePrice venueReason mode orderType fields stake price quote issues issue hint submit outcome footer`.
+
+**3. `slots`** — replace a part with your own component, receiving the same `handle` (and `venue` / `issue`) the default gets:
+
+```tsx
+<OrderSheetCard … slots={{ VenueRow: MyVenueRow, Outcome: MyOutcome }} labels={{ practice: 'Play money', real: 'Cash' }} />
+```
+
+Below that is the unstyled `/react` layer, and below that the headless core.
+
+### Card props
+
+`client?` · `position` (a ref, or a `Sheet` you opened) · `init?` · `theme?` · `scheme?` · `classNames?` · `slots?` · `labels?` · `oddsFormat?` (`cents` default, `american`, `percent`, `decimal`) · `showBlockedVenues?` (default **true** — the user should see where the better price is and why they can't use it) · `showModeSwitch?` · `showOrderType?` · `showFees?` · `onOutcome?` · `onPlaceError?` · `onFix?` (for fixes the sheet cannot apply itself: `connect_venue`, `fund_venue`, `grant_scope`, `upgrade_plan`).
+
+## Credentials
+
+| Option | Sent as | Stream |
+|---|---|---|
+| `{ apiKey }` — an execution key (`om_exec_live_…`) | `X-API-Key` | yes |
+| `{ auth }` — `createOpenMarketsAuth()` from `@openmarketsai/app-sdk` | `X-API-Key`, `getApiKey()` per request | yes |
+| `{ getToken }` — a player JWT | `Authorization: Bearer` | no — order updates are polled |
+
+`actAs: '<external_user_id>'` adds `X-OpenMarkets-Account` for OpenMarkets Connect (needs `connect:trade`). A test key (`om_*_test_*`) never sees the real-money option.
+
+## What the server answers (and the SDK never computes)
+
+| Question | Endpoint |
+|---|---|
+| Can this account place an order at this venue, in this mode, and what are the rules? | `GET /flow/v1/auth/orders/constraints` (cached; re-read on `balance.update`) |
+| What would this exact order cost, fill and pay — and would `/buy` refuse it? | `POST /flow/v1/auth/orders/preflight` (debounced 300 ms after each change; `preflight: { auto: false }` to run it yourself) |
+| Place it | `POST /flow/v1/auth/orders/buy` with `Idempotency-Key` |
+| Did it fill / settle? | `/flow/v1/stream` channels `orders` + `balance`, or `GET /auth/orders` polling on a JWT |
+
+Every rejection is one closed code (`IssueCode`) generated from the server's union, with a server-authored user message beside the developer reason.
+
+## Example
+
+```bash
+cd packages/order-sheet && npm run example     # http://localhost:8000 — the styled sheet against a mocked API, with a theme switcher
+```
+
+## License
+
+Apache-2.0

package/dist/auth.d.ts

@@ -0,0 +1,24 @@
+export interface AppSdkAuthLike {
+    getApiKey(): Promise<string | null> | string | null;
+}
+export type AuthOptions = {
+    apiKey: string;
+    getToken?: never;
+    auth?: never;
+} | {
+    getToken: () => Promise<string | null> | string | null;
+    apiKey?: never;
+    auth?: never;
+} | {
+    auth: AppSdkAuthLike;
+    apiKey?: never;
+    getToken?: never;
+};
+export interface ResolvedCredential {
+    kind: 'api_key' | 'jwt';
+    value: string;
+    headers: Record<string, string>;
+}
+export declare function resolveCredential(opts: AuthOptions): Promise<ResolvedCredential>;
+/** Which transport the credential supports for live order updates. */
+export declare function credentialSupportsStream(opts: AuthOptions): boolean;

package/dist/auth.js

@@ -0,0 +1,36 @@
+/**
+ * Credentials — every credential the platform has, one option each:
+ *
+ *   { apiKey }     an owner_self / server key (om_exec_live_…). Sent as X-API-Key.
+ *   { getToken }   a player JWT from a first-party app. Sent as Authorization: Bearer.
+ *   { auth }       a marketplace app's `createOpenMarketsAuth()` from @openmarketsai/app-sdk —
+ *                  `getApiKey()` is called PER REQUEST, never cached, so a refreshed key
+ *                  is always the one on the wire.
+ *
+ * The stream (/flow/v1/stream) authenticates with an API key only; a JWT session
+ * falls back to polling for order updates.
+ */
+import { OrderSheetError } from './errors.js';
+export async function resolveCredential(opts) {
+    if ('apiKey' in opts && opts.apiKey) {
+        return { kind: 'api_key', value: opts.apiKey, headers: { 'X-API-Key': opts.apiKey } };
+    }
+    if ('auth' in opts && opts.auth) {
+        const key = await opts.auth.getApiKey();
+        if (!key)
+            throw new OrderSheetError({ code: 'no_credential', message: 'Not signed in to OpenMarkets — no API key is available for this request.' });
+        return { kind: 'api_key', value: key, headers: { 'X-API-Key': key } };
+    }
+    if ('getToken' in opts && opts.getToken) {
+        const token = await opts.getToken();
+        if (!token)
+            throw new OrderSheetError({ code: 'no_credential', message: 'No session token is available for this request.' });
+        return { kind: 'jwt', value: token, headers: { Authorization: `Bearer ${token}` } };
+    }
+    throw new OrderSheetError({ code: 'not_configured', message: 'createOrderSheetClient needs one of { apiKey }, { getToken } or { auth }.' });
+}
+/** Which transport the credential supports for live order updates. */
+export function credentialSupportsStream(opts) {
+    return ('apiKey' in opts && !!opts.apiKey) || ('auth' in opts && !!opts.auth);
+}
+//# sourceMappingURL=auth.js.map

package/dist/auth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.js","sourceRoot":"","sources":["../src/auth.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAiB7C,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAAC,IAAiB;IACrD,IAAI,QAAQ,IAAI,IAAI,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;QAClC,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,WAAW,EAAE,IAAI,CAAC,MAAM,EAAE,EAAE,CAAA;IACzF,CAAC;IACD,IAAI,MAAM,IAAI,IAAI,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC;QAC9B,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAA;QACvC,IAAI,CAAC,GAAG;YAAE,MAAM,IAAI,eAAe,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,0EAA0E,EAAE,CAAC,CAAA;QACnJ,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,EAAE,WAAW,EAAE,GAAG,EAAE,EAAE,CAAA;IACzE,CAAC;IACD,IAAI,UAAU,IAAI,IAAI,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;QACtC,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAA;QACnC,IAAI,CAAC,KAAK;YAAE,MAAM,IAAI,eAAe,CAAC,EAAE,IAAI,EAAE,eAAe,EAAE,OAAO,EAAE,iDAAiD,EAAE,CAAC,CAAA;QAC5H,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,aAAa,EAAE,UAAU,KAAK,EAAE,EAAE,EAAE,CAAA;IACvF,CAAC;IACD,MAAM,IAAI,eAAe,CAAC,EAAE,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,2EAA2E,EAAE,CAAC,CAAA;AAC/I,CAAC;AAED,sEAAsE;AACtE,MAAM,UAAU,wBAAwB,CAAC,IAAiB;IACtD,OAAO,CAAC,QAAQ,IAAI,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,IAAI,IAAI,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;AACjF,CAAC"}

package/dist/client.d.ts

@@ -0,0 +1,158 @@
+/**
+ * The client: one per credential. Caches the account's constraints, loads
+ * positions, opens sheets, talks to /preflight, /buy, /cancel and the resting
+ * list, and owns the stream. Everything venue-specific arrives from the server.
+ */
+import { type AuthOptions } from './auth.js';
+import { type FetchLike, type Http } from './http.js';
+import type { OddsFormat } from './odds.js';
+import { type Sheet, type SheetInit } from './sheet.js';
+import { type OrderStream, type WebSocketCtor } from './stream.js';
+import type { AccountFacts, MoneyMode, OrderType, PositionRef, StakeUnit } from './types.js';
+import type { BuyLeg, BuyResponse, CancelResponse, Me, OrderConstraints, OrderRow, Position, PreflightResponse, RestingOrder, StreamBalanceUpdate, StreamOrderSettled, StreamOrderUpdate } from './wire.js';
+export declare const DEFAULT_API_BASE = "https://api.openmarkets.ai";
+export interface OrderSheetLabels {
+    placePractice: string;
+    placeReal: string;
+    confirmReal: string;
+    placing: string;
+    practice: string;
+    real: string;
+}
+export interface OrderSheetClientOptions {
+    /** One of the three credentials — see ./auth.ts. */
+    apiKey?: string;
+    getToken?: () => Promise<string | null> | string | null;
+    auth?: {
+        getApiKey(): Promise<string | null> | string | null;
+    };
+    baseUrl?: string;
+    /** Defaults to baseUrl with ws(s):// and /flow/v1/stream. */
+    streamUrl?: string;
+    /** X-OpenMarkets-Account — act for a Connect end user. */
+    actAs?: string | null;
+    fetch?: FetchLike;
+    WebSocket?: WebSocketCtor;
+    defaults?: Partial<ResolvedClientOptions['defaults']>;
+    /**
+     * The developer arms real money; the user still confirms every real order (`confirm`). Both default to safe.
+     * `confirm: false` places a real order on the first `place()` — set it only when your own UI already has the
+     * user confirm the exact order; skipping the confirmation is then the integrating app's responsibility.
+     */
+    realMoney?: Partial<ResolvedClientOptions['realMoney']>;
+    preflight?: Partial<ResolvedClientOptions['preflight']>;
+    constraints?: Partial<ResolvedClientOptions['constraints']>;
+    stream?: Partial<ResolvedClientOptions['stream']>;
+    labels?: Partial<OrderSheetLabels>;
+    /** Test hooks. */
+    now?: () => number;
+    timers?: {
+        set: typeof setTimeout;
+        clear: typeof clearTimeout;
+    };
+}
+export interface ResolvedClientOptions {
+    auth: AuthOptions;
+    baseUrl: string;
+    streamUrl: string;
+    actAs: string | null;
+    defaults: {
+        mode: MoneyMode;
+        orderType: OrderType;
+        stakeUnit: StakeUnit;
+        slippage: number;
+        oddsFormat: OddsFormat;
+        staleAfterMs: number;
+    };
+    realMoney: {
+        enabled: boolean;
+        confirm: boolean;
+    };
+    preflight: {
+        auto: boolean;
+        debounceMs: number;
+    };
+    constraints: {
+        ttlMs: number;
+    };
+    stream: {
+        enabled: boolean;
+        pollIntervalMs: number;
+    };
+    labels: OrderSheetLabels;
+    now: () => number;
+    timers: {
+        set: typeof setTimeout;
+        clear: typeof clearTimeout;
+    };
+}
+export interface ClientEvents {
+    'order.update': StreamOrderUpdate;
+    'order.settled': StreamOrderSettled;
+    'balance.update': StreamBalanceUpdate;
+    'stream.connected': {
+        server_time: string | null;
+    };
+    /** The cached constraints were replaced or marked stale. */
+    constraints: OrderConstraints | null;
+}
+export interface ClientEventBus {
+    on<K extends keyof ClientEvents>(event: K, handler: (payload: ClientEvents[K]) => void): () => void;
+    emit<K extends keyof ClientEvents>(event: K, payload: ClientEvents[K]): void;
+}
+export interface OrderSheetClient {
+    readonly options: ResolvedClientOptions;
+    readonly http: Http;
+    readonly events: ClientEventBus;
+    /** Account facts: money modes, practice wallet, policy. Cached with the constraints. */
+    account(opts?: {
+        force?: boolean;
+    }): Promise<AccountFacts>;
+    /** The pre-trade answer, cached for `constraints.ttlMs` and re-read on a balance update. */
+    constraints(opts?: {
+        force?: boolean;
+    }): Promise<OrderConstraints>;
+    getCachedConstraints(): OrderConstraints | null;
+    /** True when the server's constraints_version differs from the one this SDK was built for: trust preflight over local checks. */
+    constraintsStale(): boolean;
+    accountFromConstraints(c: OrderConstraints): AccountFacts;
+    invalidateConstraints(): void;
+    loadPosition(ref: PositionRef): Promise<{
+        position: Position;
+        partnerId: string | null;
+    }>;
+    openSheet(ref: PositionRef, init?: SheetInit): Sheet;
+    preflight(legs: BuyLeg[], opts?: {
+        verifyLiquidity?: boolean;
+        atomic?: boolean;
+    }): Promise<PreflightResponse>;
+    /**
+     * Raw multi-leg buy. `atomic: true` = check_all_first + halt + parallel + verify_liquidity. No retries, ever.
+     * Every leg must carry an explicit `mode` (the API defaults an omitted mode to REAL); a `real` leg is
+     * refused unless the developer armed `realMoney.enabled`. An `Idempotency-Key` is generated when none
+     * is given — pass your own to make YOUR retry replay.
+     */
+    buy(legs: BuyLeg[], opts?: {
+        idempotencyKey?: string;
+        verifyLiquidity?: boolean;
+        atomic?: boolean;
+        opportunityId?: string;
+        modelId?: string;
+    }): Promise<BuyResponse>;
+    restingOrders(): Promise<RestingOrder[]>;
+    listOrders(opts?: {
+        contestId?: string;
+        status?: string;
+        limit?: number;
+    }): Promise<OrderRow[]>;
+    cancelOrders(routerOrderIds: string[]): Promise<CancelResponse>;
+    me(): Promise<Me>;
+    /** The stream, once connected (API-key credentials only). */
+    readonly stream: OrderStream | null;
+    ensureStream(): Promise<OrderStream | null>;
+    /** Session switch: drop every cache, close the stream. */
+    reset(): void;
+    destroy(): void;
+}
+export declare function resolveOptions(input: OrderSheetClientOptions): ResolvedClientOptions;
+export declare function createOrderSheetClient(input: OrderSheetClientOptions): OrderSheetClient;