@symmio/trading-core 0.1.0

package/dist/quotes/resolve-quote-accounts.js

@@ -0,0 +1,43 @@
+import { getVirtualAccountsAddressesOfSubAccount as e } from "../symmio-contracts/account-layer/actions/get-virtual-accounts-addresses-of-sub-account.js";
+import { getPredictedNextVirtualAccount as t } from "../symmio-contracts/account-layer/actions/predict-next-virtual-account.js";
+import { isolationTypeForSide as n } from "../solvers/instant-open/shared/types.js";
+import { getAddress as r } from "viem";
+//#region src/quotes/resolve-quote-accounts.ts
+async function i(i, a) {
+	let { chainId: o, subAccount: s, instantOpens: c = [], includeVirtualAccounts: l = !0, extraAccounts: u = [] } = a, d = /* @__PURE__ */ new Set(), f = [], p = (e) => {
+		let t = r(e), n = t.toLowerCase();
+		d.has(n) || (d.add(n), f.push(t));
+	};
+	if (p(s), l) {
+		let t = await e(i, {
+			chainId: o,
+			subAccount: s
+		});
+		for (let e of t) p(e);
+	}
+	let m = /* @__PURE__ */ new Map(), h = c.map((e) => {
+		let r = n(e.positionType), a = BigInt(e.marketId), c = `${r}:${a}`, l = m.get(c);
+		return l || (l = t(i, {
+			chainId: o,
+			subAccount: s,
+			isolationType: r,
+			symbolId: a
+		}), m.set(c, l)), l.then((t) => ({
+			tempQuoteId: e.tempQuoteId,
+			predictedVa: t
+		}));
+	}), g = await Promise.all(h), _ = {};
+	for (let { tempQuoteId: e, predictedVa: t } of g) {
+		let n = r(t);
+		_[e] = n, p(n);
+	}
+	for (let e of u) p(e);
+	return {
+		accounts: f,
+		instantOpenVaByTempId: _
+	};
+}
+//#endregion
+export { i as resolveQuoteAccounts };
+
+//# sourceMappingURL=resolve-quote-accounts.js.map

package/dist/quotes/resolve-quote-accounts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-quote-accounts.js","names":[],"sources":["../../src/quotes/resolve-quote-accounts.ts"],"sourcesContent":["import { getAddress, type Address } from \"viem\";\nimport type { Config } from \"../core/config\";\nimport type { ChainIdParameter, Compute } from \"../shared/types/properties\";\nimport type { PendingInstantOpen } from \"../solvers/instant-open/get-instant-opens/to-pending-instant-open\";\nimport { isolationTypeForSide } from \"../solvers/instant-open/shared/types\";\nimport { getVirtualAccountsAddressesOfSubAccount } from \"../symmio-contracts/account-layer/actions/get-virtual-accounts-addresses-of-sub-account\";\nimport { getPredictedNextVirtualAccount } from \"../symmio-contracts/account-layer/actions/predict-next-virtual-account\";\n\n/**\n * Parameters for {@link resolveQuoteAccounts}.\n */\nexport type ResolveQuoteAccountsParameters = Compute<\n  ChainIdParameter & {\n    /** The subaccount whose full quote picture is being assembled. */\n    subAccount: Address;\n    /**\n     * Pending instant-opens for the subaccount. Each lands in a Virtual Account\n     * (VA) that may not exist on-chain yet; its address is predicted up front.\n     */\n    instantOpens?: readonly PendingInstantOpen[];\n    /**\n     * Union the subaccount's existing on-chain VAs into the result.\n     * @default true\n     */\n    includeVirtualAccounts?: boolean;\n    /** Extra accounts to union in (e.g. VAs already known to the consumer). */\n    extraAccounts?: readonly Address[];\n  }\n>;\n\n/** Result of {@link resolveQuoteAccounts}. */\nexport interface ResolveQuoteAccountsResult {\n  /**\n   * The deduplicated, checksummed set of on-chain `partyA` accounts to read\n   * quotes across — the subaccount itself, its existing VAs, the predicted VAs\n   * of its pending instant-opens, and any `extraAccounts`. Order is preserved\n   * (subaccount first, then VAs, then predicted VAs, then extras).\n   */\n  accounts: Address[];\n  /**\n   * Map from a pending instant-open's `tempQuoteId` to the predicted VA address\n   * its position will land in. Lets the caller stamp the optimistic quote row\n   * with its eventual VA before the trade anchors on-chain.\n   */\n  instantOpenVaByTempId: Record<number, Address>;\n}\n\n/**\n * Resolve the full set of on-chain `partyA` accounts that together hold a\n * subaccount's quote picture.\n *\n * In lowcap, each isolated position lives under a Virtual Account (VA), and the\n * VA — not the subaccount — is the on-chain `partyA` for quote reads. A\n * brand-new instant-open lands in a VA that does not exist on-chain yet, so its\n * address is predicted from `(subAccount, isolationType, symbolId)` via\n * {@link getPredictedNextVirtualAccount}. This assembles:\n *\n * 1. the subaccount itself;\n * 2. its existing VAs (when `includeVirtualAccounts`, default `true`);\n * 3. one predicted VA per pending instant-open (predictions are deduped by\n *    `(isolationType, symbolId)` and run in parallel);\n * 4. any `extraAccounts`.\n *\n * Addresses are deduped case-insensitively, returned checksummed, and kept in\n * the order above.\n *\n * @param config - The SDK config.\n * @param parameters - Subaccount, optional pending opens / VA inclusion / extras, optional chain id.\n * @returns The account set plus the `tempQuoteId` → predicted-VA map.\n * @throws {SymmError} when the chain is not supported.\n * @throws Viem's `ContractFunctionExecutionError` and friends for on-chain failures.\n *\n * @example\n * ```ts\n * const { accounts, instantOpenVaByTempId } = await resolveQuoteAccounts(config, {\n *   subAccount: \"0xsub…\",\n *   instantOpens,\n * });\n * ```\n */\nexport async function resolveQuoteAccounts(\n  config: Config,\n  parameters: ResolveQuoteAccountsParameters,\n): Promise<ResolveQuoteAccountsResult> {\n  const { chainId, subAccount, instantOpens = [], includeVirtualAccounts = true, extraAccounts = [] } = parameters;\n\n  /**\n   * `seen` tracks lowercased addresses already collected so dedupe is\n   * case-insensitive; `accounts` keeps the checksummed addresses in order.\n   */\n  const seen = new Set<string>();\n  const accounts: Address[] = [];\n\n  const add = (address: Address) => {\n    const checksummed = getAddress(address);\n    const lower = checksummed.toLowerCase();\n    if (seen.has(lower)) return;\n    seen.add(lower);\n    accounts.push(checksummed);\n  };\n\n  add(subAccount);\n\n  if (includeVirtualAccounts) {\n    const virtualAccounts = await getVirtualAccountsAddressesOfSubAccount(config, { chainId, subAccount });\n    for (const virtualAccount of virtualAccounts) add(virtualAccount);\n  }\n\n  /**\n   * TODO: dose we need to predict the VA's?\n   * Predict each pending open's VA. Many opens may share the same\n   * `(isolationType, symbolId)` — the prediction is identical for those (until\n   * the nonce advances), so dedupe the on-chain reads while still mapping every\n   * `tempQuoteId` to its address.\n   */\n  const predictionByKey = new Map<string, Promise<Address>>();\n  const predictPromises = instantOpens.map((open) => {\n    const isolationType = isolationTypeForSide(open.positionType);\n    const symbolId = BigInt(open.marketId);\n    const key = `${isolationType}:${symbolId}`;\n    let prediction = predictionByKey.get(key);\n    if (!prediction) {\n      prediction = getPredictedNextVirtualAccount(config, { chainId, subAccount, isolationType, symbolId });\n      predictionByKey.set(key, prediction);\n    }\n    return prediction.then((predictedVa) => ({ tempQuoteId: open.tempQuoteId, predictedVa }));\n  });\n  const predicted = await Promise.all(predictPromises);\n\n  const instantOpenVaByTempId: Record<number, Address> = {};\n  for (const { tempQuoteId, predictedVa } of predicted) {\n    const checksummed = getAddress(predictedVa);\n    instantOpenVaByTempId[tempQuoteId] = checksummed;\n    add(checksummed);\n  }\n\n  for (const extra of extraAccounts) add(extra);\n\n  return { accounts, instantOpenVaByTempId };\n}\n"],"mappings":";;;;;AAgFA,eAAsB,EACpB,GACA,GACqC;CACrC,IAAM,EAAE,YAAS,eAAY,kBAAe,CAAC,GAAG,4BAAyB,IAAM,mBAAgB,CAAC,MAAM,GAMhG,oBAAO,IAAI,IAAY,GACvB,IAAsB,CAAC,GAEvB,KAAO,MAAqB;EAChC,IAAM,IAAc,EAAW,CAAO,GAChC,IAAQ,EAAY,YAAY;EAClC,EAAK,IAAI,CAAK,MAClB,EAAK,IAAI,CAAK,GACd,EAAS,KAAK,CAAW;CAC3B;CAIA,IAFA,EAAI,CAAU,GAEV,GAAwB;EAC1B,IAAM,IAAkB,MAAM,EAAwC,GAAQ;GAAE;GAAS;EAAW,CAAC;EACrG,KAAK,IAAM,KAAkB,GAAiB,EAAI,CAAc;CAClE;CASA,IAAM,oBAAkB,IAAI,IAA8B,GACpD,IAAkB,EAAa,KAAK,MAAS;EACjD,IAAM,IAAgB,EAAqB,EAAK,YAAY,GACtD,IAAW,OAAO,EAAK,QAAQ,GAC/B,IAAM,GAAG,EAAc,GAAG,KAC5B,IAAa,EAAgB,IAAI,CAAG;EAKxC,OAJK,MACH,IAAa,EAA+B,GAAQ;GAAE;GAAS;GAAY;GAAe;EAAS,CAAC,GACpG,EAAgB,IAAI,GAAK,CAAU,IAE9B,EAAW,MAAM,OAAiB;GAAE,aAAa,EAAK;GAAa;EAAY,EAAE;CAC1F,CAAC,GACK,IAAY,MAAM,QAAQ,IAAI,CAAe,GAE7C,IAAiD,CAAC;CACxD,KAAK,IAAM,EAAE,gBAAa,oBAAiB,GAAW;EACpD,IAAM,IAAc,EAAW,CAAW;EAE1C,AADA,EAAsB,KAAe,GACrC,EAAI,CAAW;CACjB;CAEA,KAAK,IAAM,KAAS,GAAe,EAAI,CAAK;CAE5C,OAAO;EAAE;EAAU;CAAsB;AAC3C"}

package/dist/quotes/should-accelerate.d.ts

@@ -0,0 +1,39 @@
+import { ReconcileQuotesResult } from './reconcile-quotes';
+/**
+ * Decide whether quote polling should run at the accelerated interval.
+ *
+ * Returns `true` while any row is mid-transition (the open stages `OPTIMISTIC` /
+ * `PRICE_FILLED` / `WRITE_ONCHAIN`, or the close stages `OPTIMISTIC_CLOSE` /
+ * `CLOSE_PRICE_FILLED` / `WRITE_ONCHAIN_CLOSE` / `CLOSING`) — those rows are waiting
+ * on an on-chain change the SDK can only observe by re-reading, so the consumer
+ * should shorten its `refetchInterval` until everything settles, then fall back to
+ * the idle interval.
+ *
+ * @param result - The latest reconciliation result.
+ * @returns `true` when at least one transitioning row exists.
+ *
+ * @example
+ * ```ts
+ * const interval = shouldAccelerateQuotePolling(result) ? 1_500 : 10_000;
+ * ```
+ */
+export declare function shouldAccelerateQuotePolling(result: ReconcileQuotesResult): boolean;
+/**
+ * Decide whether the **on-chain reads** specifically should poll at the accelerated
+ * interval — the RPC-lag retry. Unlike {@link shouldAccelerateQuotePolling} (which is
+ * `true` for every mid-transition stage, including the purely off-chain ones), this is
+ * `true` only while a row awaits on-chain confirmation (`WRITE_ONCHAIN` /
+ * `WRITE_ONCHAIN_CLOSE` / `CLOSING`). The off-chain stages (`OPTIMISTIC` /
+ * `PRICE_FILLED` / `OPTIMISTIC_CLOSE` / `CLOSE_PRICE_FILLED`) have nothing on-chain to
+ * read before the anchor, so they must not drive on-chain polling.
+ *
+ * @param result - The latest reconciliation result.
+ * @returns `true` when at least one row is awaiting on-chain confirmation.
+ *
+ * @example
+ * ```ts
+ * const onchainInterval = shouldAccelerateOnchainReads(result) ? 1_500 : false;
+ * ```
+ */
+export declare function shouldAccelerateOnchainReads(result: ReconcileQuotesResult): boolean;
+//# sourceMappingURL=should-accelerate.d.ts.map

package/dist/quotes/should-accelerate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"should-accelerate.d.ts","sourceRoot":"","sources":["../../src/quotes/should-accelerate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAmBhE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAEnF;AAcD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAEnF"}

package/dist/quotes/should-accelerate.js

@@ -0,0 +1,26 @@
+import { QuoteLifecycle as e } from "./unified-quote.js";
+//#region src/quotes/should-accelerate.ts
+var t = new Set([
+	e.OPTIMISTIC,
+	e.PRICE_FILLED,
+	e.WRITE_ONCHAIN,
+	e.OPTIMISTIC_CLOSE,
+	e.CLOSE_PRICE_FILLED,
+	e.WRITE_ONCHAIN_CLOSE,
+	e.CLOSING
+]);
+function n(e) {
+	return e.quotes.some((e) => t.has(e.lifecycle));
+}
+var r = new Set([
+	e.WRITE_ONCHAIN,
+	e.WRITE_ONCHAIN_CLOSE,
+	e.CLOSING
+]);
+function i(e) {
+	return e.quotes.some((e) => r.has(e.lifecycle));
+}
+//#endregion
+export { i as shouldAccelerateOnchainReads, n as shouldAccelerateQuotePolling };
+
+//# sourceMappingURL=should-accelerate.js.map

package/dist/quotes/should-accelerate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"should-accelerate.js","names":[],"sources":["../../src/quotes/should-accelerate.ts"],"sourcesContent":["import type { ReconcileQuotesResult } from \"./reconcile-quotes\";\nimport { QuoteLifecycle } from \"./unified-quote\";\n\n/**\n * Lifecycle stages that mean a quote is mid-transition and the consumer should\n * poll the on-chain reads faster until it settles. The `WRITE_ONCHAIN(_CLOSE)`\n * stages are explicitly waiting on the on-chain read to confirm an anchor/close,\n * so they accelerate too.\n */\nconst ACCELERATING_LIFECYCLES = new Set<QuoteLifecycle>([\n  QuoteLifecycle.OPTIMISTIC,\n  QuoteLifecycle.PRICE_FILLED,\n  QuoteLifecycle.WRITE_ONCHAIN,\n  QuoteLifecycle.OPTIMISTIC_CLOSE,\n  QuoteLifecycle.CLOSE_PRICE_FILLED,\n  QuoteLifecycle.WRITE_ONCHAIN_CLOSE,\n  QuoteLifecycle.CLOSING,\n]);\n\n/**\n * Decide whether quote polling should run at the accelerated interval.\n *\n * Returns `true` while any row is mid-transition (the open stages `OPTIMISTIC` /\n * `PRICE_FILLED` / `WRITE_ONCHAIN`, or the close stages `OPTIMISTIC_CLOSE` /\n * `CLOSE_PRICE_FILLED` / `WRITE_ONCHAIN_CLOSE` / `CLOSING`) — those rows are waiting\n * on an on-chain change the SDK can only observe by re-reading, so the consumer\n * should shorten its `refetchInterval` until everything settles, then fall back to\n * the idle interval.\n *\n * @param result - The latest reconciliation result.\n * @returns `true` when at least one transitioning row exists.\n *\n * @example\n * ```ts\n * const interval = shouldAccelerateQuotePolling(result) ? 1_500 : 10_000;\n * ```\n */\nexport function shouldAccelerateQuotePolling(result: ReconcileQuotesResult): boolean {\n  return result.quotes.some((quote) => ACCELERATING_LIFECYCLES.has(quote.lifecycle));\n}\n\n/**\n * Lifecycle stages where the SDK is waiting on the **on-chain read** to confirm a\n * change it already knows is coming — an anchored open (`WRITE_ONCHAIN`) or a\n * requested close (`WRITE_ONCHAIN_CLOSE` / `CLOSING`): the notification/overlay has\n * advanced the row but `raw.onchain` has not caught up yet.\n */\nconst ONCHAIN_PENDING_LIFECYCLES = new Set<QuoteLifecycle>([\n  QuoteLifecycle.WRITE_ONCHAIN,\n  QuoteLifecycle.WRITE_ONCHAIN_CLOSE,\n  QuoteLifecycle.CLOSING,\n]);\n\n/**\n * Decide whether the **on-chain reads** specifically should poll at the accelerated\n * interval — the RPC-lag retry. Unlike {@link shouldAccelerateQuotePolling} (which is\n * `true` for every mid-transition stage, including the purely off-chain ones), this is\n * `true` only while a row awaits on-chain confirmation (`WRITE_ONCHAIN` /\n * `WRITE_ONCHAIN_CLOSE` / `CLOSING`). The off-chain stages (`OPTIMISTIC` /\n * `PRICE_FILLED` / `OPTIMISTIC_CLOSE` / `CLOSE_PRICE_FILLED`) have nothing on-chain to\n * read before the anchor, so they must not drive on-chain polling.\n *\n * @param result - The latest reconciliation result.\n * @returns `true` when at least one row is awaiting on-chain confirmation.\n *\n * @example\n * ```ts\n * const onchainInterval = shouldAccelerateOnchainReads(result) ? 1_500 : false;\n * ```\n */\nexport function shouldAccelerateOnchainReads(result: ReconcileQuotesResult): boolean {\n  return result.quotes.some((quote) => ONCHAIN_PENDING_LIFECYCLES.has(quote.lifecycle));\n}\n"],"mappings":";;AASA,IAAM,IAA0B,IAAI,IAAoB;CACtD,EAAe;CACf,EAAe;CACf,EAAe;CACf,EAAe;CACf,EAAe;CACf,EAAe;CACf,EAAe;AACjB,CAAC;AAoBD,SAAgB,EAA6B,GAAwC;CACnF,OAAO,EAAO,OAAO,MAAM,MAAU,EAAwB,IAAI,EAAM,SAAS,CAAC;AACnF;AAQA,IAAM,IAA6B,IAAI,IAAoB;CACzD,EAAe;CACf,EAAe;CACf,EAAe;AACjB,CAAC;AAmBD,SAAgB,EAA6B,GAAwC;CACnF,OAAO,EAAO,OAAO,MAAM,MAAU,EAA2B,IAAI,EAAM,SAAS,CAAC;AACtF"}

package/dist/quotes/to-unified-quote.d.ts

@@ -0,0 +1,76 @@
+import { Address } from 'viem';
+import { PendingInstantClose } from '../solvers/instant-close/get-instant-closes/to-pending-instant-close';
+import { PendingInstantOpen } from '../solvers/instant-open/get-instant-opens/to-pending-instant-open';
+import { QuoteStatus, Quote } from '../symmio-contracts/symmio/types';
+import { QuoteLifecycle, UnifiedQuote } from './unified-quote';
+/**
+ * Map an on-chain {@link QuoteStatus} to a {@link QuoteLifecycle}. Open and
+ * pending statuses stay `ONCHAIN`; a pending close becomes `CLOSING`; a fully
+ * closed/cancelled/expired quote becomes `CLOSED`.
+ *
+ * @param status - The on-chain quote status.
+ * @returns The lifecycle stage to surface for an anchored row.
+ */
+export declare function lifecycleFromQuoteStatus(status: QuoteStatus): QuoteLifecycle;
+/**
+ * Build a {@link UnifiedQuote} from an on-chain {@link Quote}.
+ *
+ * The lifecycle is derived from the quote's {@link QuoteStatus} via
+ * {@link lifecycleFromQuoteStatus}. Every amount is already 18-decimal wei on the
+ * on-chain struct, so it carries through untouched.
+ *
+ * @param quote - The on-chain quote/position struct.
+ * @returns The unified row, keyed `onchain:<id>`.
+ *
+ * @example
+ * ```ts
+ * const row = toUnifiedQuoteFromOnchain(quote);
+ * ```
+ */
+export declare function toUnifiedQuoteFromOnchain(quote: Quote): UnifiedQuote;
+/**
+ * Build an optimistic {@link UnifiedQuote} from a pending instant-open record.
+ *
+ * The hedger reports human-scaled decimal strings; this normalizes price,
+ * quantity, and the locked legs to 18-decimal wei via {@link toWeiBigInt}. The
+ * row is `OPTIMISTIC` (no fill, no on-chain id yet) and keyed `temp:<tempId>`.
+ *
+ * @param pending - A normalized pending instant-open record.
+ * @returns The unified row.
+ *
+ * @example
+ * ```ts
+ * const row = toUnifiedQuoteFromInstantOpen(pending);
+ * ```
+ */
+export declare function toUnifiedQuoteFromInstantOpen(pending: PendingInstantOpen): UnifiedQuote;
+/**
+ * Inputs identifying the position a pending instant-close targets. A close
+ * record only carries the quote id and close amounts, so the market/side fields
+ * come from the already-known on-chain row (or sensible zero defaults).
+ */
+export interface ToUnifiedQuoteFromInstantCloseContext {
+    /** Sub-account (partyA) that owns the position being closed. */
+    partyA: Address;
+    /** Market identifier of the position being closed. */
+    symbolId: UnifiedQuote["symbolId"];
+    /** Side of the position being closed. */
+    positionType: UnifiedQuote["positionType"];
+    /** Order type of the position being closed. */
+    orderType: UnifiedQuote["orderType"];
+}
+/**
+ * Build a `CLOSING` {@link UnifiedQuote} from a pending instant-close record.
+ *
+ * A close record carries only the quote id and close amounts (already wei), so
+ * market/side metadata is supplied via `context` (typically copied from the
+ * matching on-chain row). Reconciliation overlays closes onto the existing
+ * on-chain row directly; this helper is exposed for consumers that want to render
+ * a standalone close-only row when the on-chain row is not available.
+ *
+ * @param pending - A normalized pending instant-close record.
+ * @param context - Market/side metadata for the targeted position.
+ * @returns The unified row, keyed `onchain:<quoteId>`.
+ */
+export declare function toUnifiedQuoteFromInstantClose(pending: PendingInstantClose, context: ToUnifiedQuoteFromInstantCloseContext): UnifiedQuote;
+//# sourceMappingURL=to-unified-quote.d.ts.map

package/dist/quotes/to-unified-quote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-unified-quote.d.ts","sourceRoot":"","sources":["../../src/quotes/to-unified-quote.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sEAAsE,CAAC;AAChH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mEAAmE,CAAC;AAE5G,OAAO,EAAE,WAAW,EAAqB,KAAK,KAAK,EAAE,MAAM,kCAAkC,CAAC;AAE9F,OAAO,EAAE,cAAc,EAAE,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAUpE;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,WAAW,GAAG,cAAc,CAc5E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,KAAK,GAAG,YAAY,CAuCpE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,kBAAkB,GAAG,YAAY,CAsBvF;AAED;;;;GAIG;AACH,MAAM,WAAW,qCAAqC;IACpD,gEAAgE;IAChE,MAAM,EAAE,OAAO,CAAC;IAChB,sDAAsD;IACtD,QAAQ,EAAE,YAAY,CAAC,UAAU,CAAC,CAAC;IACnC,yCAAyC;IACzC,YAAY,EAAE,YAAY,CAAC,cAAc,CAAC,CAAC;IAC3C,+CAA+C;IAC/C,SAAS,EAAE,YAAY,CAAC,WAAW,CAAC,CAAC;CACtC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,qCAAqC,GAC7C,YAAY,CAiBd"}

package/dist/quotes/to-unified-quote.js

@@ -0,0 +1,110 @@
+import { QuoteStatus as e } from "../symmio-contracts/symmio/types.js";
+import { toWeiBigInt as t } from "../solvers/instant-open/shared/trade-math.js";
+import { QuoteLifecycle as n } from "./unified-quote.js";
+import { quoteOpenQuantity as r } from "./open-quantity.js";
+//#region src/quotes/to-unified-quote.ts
+var i = {
+	cva: 0n,
+	lf: 0n,
+	partyAmm: 0n,
+	partyBmm: 0n
+};
+function a(t) {
+	switch (t) {
+		case e.CLOSE_PENDING:
+		case e.CANCEL_CLOSE_PENDING: return n.CLOSING;
+		case e.CLOSED:
+		case e.CANCELED:
+		case e.EXPIRED: return n.CLOSED;
+		case e.LIQUIDATED: return n.FAILED;
+		default: return n.ONCHAIN;
+	}
+}
+function o(e) {
+	let t = a(e.quoteStatus);
+	return {
+		key: `onchain:${e.id}`,
+		origin: "onchain",
+		lifecycle: t,
+		quoteId: e.id,
+		partyA: e.partyA,
+		partyB: e.partyB,
+		symbolId: e.symbolId,
+		positionType: e.positionType,
+		orderType: e.orderType,
+		quoteStatus: e.quoteStatus,
+		requestedOpenPrice: e.requestedOpenPrice,
+		openedPrice: e.openedPrice,
+		initialOpenedPrice: e.initialOpenedPrice,
+		avgClosedPrice: e.avgClosedPrice,
+		requestedClosePrice: e.requestedClosePrice,
+		marketPrice: e.marketPrice,
+		quantity: e.quantity,
+		closedAmount: e.closedAmount,
+		openQuantity: r({
+			quantity: e.quantity,
+			closedAmount: e.closedAmount
+		}),
+		quantityToClose: e.quantityToClose,
+		lockedValues: e.lockedValues,
+		initialLockedValues: e.initialLockedValues,
+		maxFundingRate: e.maxFundingRate,
+		accumulatedPaidFunding: e.accumulatedPaidFunding,
+		lastFundingPaymentTimestamp: e.lastFundingPaymentTimestamp,
+		deadline: e.deadline,
+		tradingFee: e.tradingFee,
+		closeFee: e.closeFee,
+		affiliate: e.affiliate,
+		partyBsWhiteList: e.partyBsWhiteList,
+		parentId: e.parentId,
+		data: e.data,
+		createTimestamp: e.createTimestamp,
+		statusModifyTimestamp: e.statusModifyTimestamp,
+		raw: { onchain: e }
+	};
+}
+function s(e) {
+	let r = t(e.quantity);
+	return {
+		key: `temp:${e.tempQuoteId}`,
+		origin: "offchain",
+		lifecycle: n.OPTIMISTIC,
+		tempQuoteId: e.tempQuoteId,
+		partyA: e.partyA,
+		symbolId: BigInt(e.marketId),
+		positionType: e.positionType,
+		orderType: e.orderType,
+		requestedOpenPrice: t(e.requestedOpenPrice),
+		quantity: r,
+		openQuantity: r,
+		lockedValues: {
+			cva: t(e.cva),
+			lf: t(e.lf),
+			partyAmm: t(e.partyAmm),
+			partyBmm: t(e.partyBmm)
+		},
+		raw: { instantOpen: e }
+	};
+}
+function c(e, t) {
+	return {
+		key: `onchain:${e.quoteId}`,
+		origin: "onchain",
+		lifecycle: n.CLOSING,
+		quoteId: e.quoteId,
+		partyA: t.partyA,
+		symbolId: t.symbolId,
+		positionType: t.positionType,
+		orderType: t.orderType,
+		requestedOpenPrice: 0n,
+		quantity: 0n,
+		openQuantity: 0n,
+		quantityToClose: e.quantityToClose,
+		lockedValues: i,
+		raw: { instantClose: e }
+	};
+}
+//#endregion
+export { a as lifecycleFromQuoteStatus, c as toUnifiedQuoteFromInstantClose, s as toUnifiedQuoteFromInstantOpen, o as toUnifiedQuoteFromOnchain };
+
+//# sourceMappingURL=to-unified-quote.js.map

package/dist/quotes/to-unified-quote.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-unified-quote.js","names":[],"sources":["../../src/quotes/to-unified-quote.ts"],"sourcesContent":["import type { Address } from \"viem\";\nimport type { PendingInstantClose } from \"../solvers/instant-close/get-instant-closes/to-pending-instant-close\";\nimport type { PendingInstantOpen } from \"../solvers/instant-open/get-instant-opens/to-pending-instant-open\";\nimport { toWeiBigInt } from \"../solvers/instant-open/shared/trade-math\";\nimport { QuoteStatus, type LockedValues, type Quote } from \"../symmio-contracts/symmio/types\";\nimport { quoteOpenQuantity } from \"./open-quantity\";\nimport { QuoteLifecycle, type UnifiedQuote } from \"./unified-quote\";\n\n/** All-zero locked values, used when an off-chain row has no per-leg margin yet. */\nconst EMPTY_LOCKED_VALUES: LockedValues = {\n  cva: 0n,\n  lf: 0n,\n  partyAmm: 0n,\n  partyBmm: 0n,\n};\n\n/**\n * Map an on-chain {@link QuoteStatus} to a {@link QuoteLifecycle}. Open and\n * pending statuses stay `ONCHAIN`; a pending close becomes `CLOSING`; a fully\n * closed/cancelled/expired quote becomes `CLOSED`.\n *\n * @param status - The on-chain quote status.\n * @returns The lifecycle stage to surface for an anchored row.\n */\nexport function lifecycleFromQuoteStatus(status: QuoteStatus): QuoteLifecycle {\n  switch (status) {\n    case QuoteStatus.CLOSE_PENDING:\n    case QuoteStatus.CANCEL_CLOSE_PENDING:\n      return QuoteLifecycle.CLOSING;\n    case QuoteStatus.CLOSED:\n    case QuoteStatus.CANCELED:\n    case QuoteStatus.EXPIRED:\n      return QuoteLifecycle.CLOSED;\n    case QuoteStatus.LIQUIDATED:\n      return QuoteLifecycle.FAILED;\n    default:\n      return QuoteLifecycle.ONCHAIN;\n  }\n}\n\n/**\n * Build a {@link UnifiedQuote} from an on-chain {@link Quote}.\n *\n * The lifecycle is derived from the quote's {@link QuoteStatus} via\n * {@link lifecycleFromQuoteStatus}. Every amount is already 18-decimal wei on the\n * on-chain struct, so it carries through untouched.\n *\n * @param quote - The on-chain quote/position struct.\n * @returns The unified row, keyed `onchain:<id>`.\n *\n * @example\n * ```ts\n * const row = toUnifiedQuoteFromOnchain(quote);\n * ```\n */\nexport function toUnifiedQuoteFromOnchain(quote: Quote): UnifiedQuote {\n  const lifecycle = lifecycleFromQuoteStatus(quote.quoteStatus);\n  return {\n    key: `onchain:${quote.id}`,\n    origin: \"onchain\",\n    lifecycle,\n    quoteId: quote.id,\n    partyA: quote.partyA,\n    partyB: quote.partyB,\n    symbolId: quote.symbolId,\n    positionType: quote.positionType,\n    orderType: quote.orderType,\n    quoteStatus: quote.quoteStatus,\n    requestedOpenPrice: quote.requestedOpenPrice,\n    openedPrice: quote.openedPrice,\n    initialOpenedPrice: quote.initialOpenedPrice,\n    avgClosedPrice: quote.avgClosedPrice,\n    requestedClosePrice: quote.requestedClosePrice,\n    marketPrice: quote.marketPrice,\n    quantity: quote.quantity,\n    closedAmount: quote.closedAmount,\n    openQuantity: quoteOpenQuantity({ quantity: quote.quantity, closedAmount: quote.closedAmount }),\n    quantityToClose: quote.quantityToClose,\n    lockedValues: quote.lockedValues,\n    initialLockedValues: quote.initialLockedValues,\n    maxFundingRate: quote.maxFundingRate,\n    accumulatedPaidFunding: quote.accumulatedPaidFunding,\n    lastFundingPaymentTimestamp: quote.lastFundingPaymentTimestamp,\n    deadline: quote.deadline,\n    tradingFee: quote.tradingFee,\n    closeFee: quote.closeFee,\n    affiliate: quote.affiliate,\n    partyBsWhiteList: quote.partyBsWhiteList,\n    parentId: quote.parentId,\n    data: quote.data,\n    createTimestamp: quote.createTimestamp,\n    statusModifyTimestamp: quote.statusModifyTimestamp,\n    raw: { onchain: quote },\n  };\n}\n\n/**\n * Build an optimistic {@link UnifiedQuote} from a pending instant-open record.\n *\n * The hedger reports human-scaled decimal strings; this normalizes price,\n * quantity, and the locked legs to 18-decimal wei via {@link toWeiBigInt}. The\n * row is `OPTIMISTIC` (no fill, no on-chain id yet) and keyed `temp:<tempId>`.\n *\n * @param pending - A normalized pending instant-open record.\n * @returns The unified row.\n *\n * @example\n * ```ts\n * const row = toUnifiedQuoteFromInstantOpen(pending);\n * ```\n */\nexport function toUnifiedQuoteFromInstantOpen(pending: PendingInstantOpen): UnifiedQuote {\n  const quantity = toWeiBigInt(pending.quantity);\n  return {\n    key: `temp:${pending.tempQuoteId}`,\n    origin: \"offchain\",\n    lifecycle: QuoteLifecycle.OPTIMISTIC,\n    tempQuoteId: pending.tempQuoteId,\n    partyA: pending.partyA,\n    symbolId: BigInt(pending.marketId),\n    positionType: pending.positionType,\n    orderType: pending.orderType,\n    requestedOpenPrice: toWeiBigInt(pending.requestedOpenPrice),\n    quantity,\n    openQuantity: quantity,\n    lockedValues: {\n      cva: toWeiBigInt(pending.cva),\n      lf: toWeiBigInt(pending.lf),\n      partyAmm: toWeiBigInt(pending.partyAmm),\n      partyBmm: toWeiBigInt(pending.partyBmm),\n    },\n    raw: { instantOpen: pending },\n  };\n}\n\n/**\n * Inputs identifying the position a pending instant-close targets. A close\n * record only carries the quote id and close amounts, so the market/side fields\n * come from the already-known on-chain row (or sensible zero defaults).\n */\nexport interface ToUnifiedQuoteFromInstantCloseContext {\n  /** Sub-account (partyA) that owns the position being closed. */\n  partyA: Address;\n  /** Market identifier of the position being closed. */\n  symbolId: UnifiedQuote[\"symbolId\"];\n  /** Side of the position being closed. */\n  positionType: UnifiedQuote[\"positionType\"];\n  /** Order type of the position being closed. */\n  orderType: UnifiedQuote[\"orderType\"];\n}\n\n/**\n * Build a `CLOSING` {@link UnifiedQuote} from a pending instant-close record.\n *\n * A close record carries only the quote id and close amounts (already wei), so\n * market/side metadata is supplied via `context` (typically copied from the\n * matching on-chain row). Reconciliation overlays closes onto the existing\n * on-chain row directly; this helper is exposed for consumers that want to render\n * a standalone close-only row when the on-chain row is not available.\n *\n * @param pending - A normalized pending instant-close record.\n * @param context - Market/side metadata for the targeted position.\n * @returns The unified row, keyed `onchain:<quoteId>`.\n */\nexport function toUnifiedQuoteFromInstantClose(\n  pending: PendingInstantClose,\n  context: ToUnifiedQuoteFromInstantCloseContext,\n): UnifiedQuote {\n  return {\n    key: `onchain:${pending.quoteId}`,\n    origin: \"onchain\",\n    lifecycle: QuoteLifecycle.CLOSING,\n    quoteId: pending.quoteId,\n    partyA: context.partyA,\n    symbolId: context.symbolId,\n    positionType: context.positionType,\n    orderType: context.orderType,\n    requestedOpenPrice: 0n,\n    quantity: 0n,\n    openQuantity: 0n,\n    quantityToClose: pending.quantityToClose,\n    lockedValues: EMPTY_LOCKED_VALUES,\n    raw: { instantClose: pending },\n  };\n}\n"],"mappings":";;;;;AASA,IAAM,IAAoC;CACxC,KAAK;CACL,IAAI;CACJ,UAAU;CACV,UAAU;AACZ;AAUA,SAAgB,EAAyB,GAAqC;CAC5E,QAAQ,GAAR;EACE,KAAK,EAAY;EACjB,KAAK,EAAY,sBACf,OAAO,EAAe;EACxB,KAAK,EAAY;EACjB,KAAK,EAAY;EACjB,KAAK,EAAY,SACf,OAAO,EAAe;EACxB,KAAK,EAAY,YACf,OAAO,EAAe;EACxB,SACE,OAAO,EAAe;CAC1B;AACF;AAiBA,SAAgB,EAA0B,GAA4B;CACpE,IAAM,IAAY,EAAyB,EAAM,WAAW;CAC5D,OAAO;EACL,KAAK,WAAW,EAAM;EACtB,QAAQ;EACR;EACA,SAAS,EAAM;EACf,QAAQ,EAAM;EACd,QAAQ,EAAM;EACd,UAAU,EAAM;EAChB,cAAc,EAAM;EACpB,WAAW,EAAM;EACjB,aAAa,EAAM;EACnB,oBAAoB,EAAM;EAC1B,aAAa,EAAM;EACnB,oBAAoB,EAAM;EAC1B,gBAAgB,EAAM;EACtB,qBAAqB,EAAM;EAC3B,aAAa,EAAM;EACnB,UAAU,EAAM;EAChB,cAAc,EAAM;EACpB,cAAc,EAAkB;GAAE,UAAU,EAAM;GAAU,cAAc,EAAM;EAAa,CAAC;EAC9F,iBAAiB,EAAM;EACvB,cAAc,EAAM;EACpB,qBAAqB,EAAM;EAC3B,gBAAgB,EAAM;EACtB,wBAAwB,EAAM;EAC9B,6BAA6B,EAAM;EACnC,UAAU,EAAM;EAChB,YAAY,EAAM;EAClB,UAAU,EAAM;EAChB,WAAW,EAAM;EACjB,kBAAkB,EAAM;EACxB,UAAU,EAAM;EAChB,MAAM,EAAM;EACZ,iBAAiB,EAAM;EACvB,uBAAuB,EAAM;EAC7B,KAAK,EAAE,SAAS,EAAM;CACxB;AACF;AAiBA,SAAgB,EAA8B,GAA2C;CACvF,IAAM,IAAW,EAAY,EAAQ,QAAQ;CAC7C,OAAO;EACL,KAAK,QAAQ,EAAQ;EACrB,QAAQ;EACR,WAAW,EAAe;EAC1B,aAAa,EAAQ;EACrB,QAAQ,EAAQ;EAChB,UAAU,OAAO,EAAQ,QAAQ;EACjC,cAAc,EAAQ;EACtB,WAAW,EAAQ;EACnB,oBAAoB,EAAY,EAAQ,kBAAkB;EAC1D;EACA,cAAc;EACd,cAAc;GACZ,KAAK,EAAY,EAAQ,GAAG;GAC5B,IAAI,EAAY,EAAQ,EAAE;GAC1B,UAAU,EAAY,EAAQ,QAAQ;GACtC,UAAU,EAAY,EAAQ,QAAQ;EACxC;EACA,KAAK,EAAE,aAAa,EAAQ;CAC9B;AACF;AA+BA,SAAgB,EACd,GACA,GACc;CACd,OAAO;EACL,KAAK,WAAW,EAAQ;EACxB,QAAQ;EACR,WAAW,EAAe;EAC1B,SAAS,EAAQ;EACjB,QAAQ,EAAQ;EAChB,UAAU,EAAQ;EAClB,cAAc,EAAQ;EACtB,WAAW,EAAQ;EACnB,oBAAoB;EACpB,UAAU;EACV,cAAc;EACd,iBAAiB,EAAQ;EACzB,cAAc;EACd,KAAK,EAAE,cAAc,EAAQ;CAC/B;AACF"}

package/dist/quotes/unified-quote.d.ts

@@ -0,0 +1,162 @@
+import { Address, Hex } from 'viem';
+import { PendingInstantClose } from '../solvers/instant-close/get-instant-closes/to-pending-instant-close';
+import { PendingInstantOpen } from '../solvers/instant-open/get-instant-opens/to-pending-instant-open';
+import { LockedValues, OrderType, PositionType, Quote, QuoteStatus } from '../symmio-contracts/symmio/types';
+/**
+ * Where a {@link UnifiedQuote} was sourced from before reconciliation.
+ *
+ * - `"onchain"` — read from the SYMMIO core (`getPartyAOpenPositions` /
+ *   `getPartyAPendingQuotes` + `getQuote`); the row carries a real `quoteId`.
+ * - `"offchain"` — only known to a hedger so far (a pending instant-open or
+ *   instant-close); the row carries a `tempQuoteId` and waits to anchor on-chain.
+ */
+export type QuoteOrigin = "onchain" | "offchain";
+/**
+ * The stage of a quote's lifecycle as tracked across the on-chain + off-chain
+ * merge. Drives row styling and polling acceleration in the consumer.
+ *
+ * The off-chain stages (`OPTIMISTIC`, `PRICE_FILLED`) and the transient `CLOSING`
+ * stage are SDK-side overlays — they do not exist on the on-chain
+ * {@link QuoteStatus}; reconciliation assigns them from notifications and hedger
+ * records.
+ */
+export declare enum QuoteLifecycle {
+    /** Submitted to a hedger; no on-chain quote and no fill report yet. */
+    OPTIMISTIC = "optimistic",
+    /** A hedger reported a fill price (`InstantRFQ` success) but the on-chain quote has not landed yet. */
+    PRICE_FILLED = "price-filled",
+    /**
+     * The open anchored on-chain per the notification (the `quoteId` is known), but
+     * the on-chain read has not returned the quote struct yet. The row is being
+     * "written on-chain": shown with its anchored id while the SDK waits for the RPC
+     * to confirm it. Resolves to {@link QuoteLifecycle.ONCHAIN} once the on-chain
+     * read returns the struct.
+     */
+    WRITE_ONCHAIN = "write-onchain",
+    /** Anchored on-chain; mirrors a real {@link QuoteStatus}. */
+    ONCHAIN = "onchain",
+    /**
+     * A close was just submitted and the hedger's pending-instant-close feed has it,
+     * but no close notification has confirmed a price yet — the close-side analog of
+     * {@link QuoteLifecycle.OPTIMISTIC}. Advances to {@link QuoteLifecycle.CLOSE_PRICE_FILLED}.
+     */
+    OPTIMISTIC_CLOSE = "optimistic-close",
+    /**
+     * A close notification reported the close price/fill request
+     * (`InstantRequestToClosePosition`) — the close-side analog of
+     * {@link QuoteLifecycle.PRICE_FILLED}. Advances to {@link QuoteLifecycle.WRITE_ONCHAIN_CLOSE}.
+     */
+    CLOSE_PRICE_FILLED = "close-price-filled",
+    /**
+     * The close fill (`FillMarketOrderInstantClose`) was reported, or a pending
+     * instant-close overlays the row while the on-chain status still shows the
+     * position open — the close is being "written on-chain", awaiting the RPC. The
+     * close-side analog of {@link QuoteLifecycle.WRITE_ONCHAIN}. Resolves to
+     * {@link QuoteLifecycle.CLOSING} when the on-chain status reflects the pending close.
+     */
+    WRITE_ONCHAIN_CLOSE = "write-onchain-close",
+    /** The close is confirmed pending on-chain — on-chain `CLOSE_PENDING` / `CANCEL_CLOSE_PENDING`. */
+    CLOSING = "closing",
+    /** The position is fully closed. */
+    CLOSED = "closed",
+    /** A hedger or notification reported the open/close failed. */
+    FAILED = "failed"
+}
+/**
+ * A single quote/position row merged from every source (on-chain reads, pending
+ * instant-opens, pending instant-closes, and notifications) into one stable,
+ * de-duplicated shape.
+ *
+ * All amount and price fields are 18-decimal-wei `bigint`, matching the on-chain
+ * {@link Quote}. Off-chain hedger amounts are normalized to wei before they reach
+ * this type. The `key` is a stable identity for React lists and the removal
+ * ledger; `raw` carries the untouched source rows for advanced use.
+ */
+export interface UnifiedQuote {
+    /** Stable identity for this row (`onchain:<id>` or `temp:<tempId>`). */
+    key: string;
+    /** Source the row was reconciled from. */
+    origin: QuoteOrigin;
+    /** Current lifecycle stage. */
+    lifecycle: QuoteLifecycle;
+    /** On-chain quote id, once anchored. */
+    quoteId?: bigint;
+    /** Hedger-local temp id, before the on-chain id exists. */
+    tempQuoteId?: number;
+    /** Sub-account (partyA) that owns the row. */
+    partyA: Address;
+    /** PartyB (hedger/solver) that locked/opened the quote, when known. */
+    partyB?: Address;
+    /** Solver-assigned Virtual Account address (lowcap), when known. */
+    vaAddress?: Address;
+    /** Market identifier (`symbolId`). */
+    symbolId: bigint;
+    /** Long or short. */
+    positionType: PositionType;
+    /** Limit or market order. */
+    orderType: OrderType;
+    /** On-chain status, when the row is anchored on-chain. */
+    quoteStatus?: QuoteStatus;
+    /** Price partyA requested to open at (wei). */
+    requestedOpenPrice: bigint;
+    /** Price partyB actually opened at (wei), when known. */
+    openedPrice?: bigint;
+    /** Initial price partyB opened at before any edits (wei), when known. */
+    initialOpenedPrice?: bigint;
+    /** Average price across executed closes (wei), when known. */
+    avgClosedPrice?: bigint;
+    /** Requested limit price for a pending close (wei), when known. */
+    requestedClosePrice?: bigint;
+    /** Market price snapshot at last state change (wei), when known. */
+    marketPrice?: bigint;
+    /** Total requested quantity (wei) — fixed for the life of the position; partial closes do not shrink it. */
+    quantity: bigint;
+    /** Quantity already closed (wei), when known. */
+    closedAmount?: bigint;
+    /**
+     * Remaining **open** size (wei): `quantity − closedAmount`, the live quantity
+     * still on the position (the figure a UI shows as "position size"); `0` once
+     * fully closed. Derived from the other amount fields by {@link quoteOpenQuantity}.
+     */
+    openQuantity: bigint;
+    /** Quantity targeted by a pending close (wei), when closing. */
+    quantityToClose?: bigint;
+    /** Margin locked against the row (wei). */
+    lockedValues: LockedValues;
+    /** Margin locked at open time — basis for leverage (wei), when known. */
+    initialLockedValues?: LockedValues;
+    /** Maximum funding rate partyA accepts, when known. */
+    maxFundingRate?: bigint;
+    /** Net funding paid (positive) or received (negative) over the position's life (wei), when known. */
+    accumulatedPaidFunding?: bigint;
+    /** Block timestamp funding was last applied, when known. */
+    lastFundingPaymentTimestamp?: bigint;
+    /** Quote deadline (expiry) timestamp, when known. */
+    deadline?: bigint;
+    /** Trading fee charged on the quote (wei), when known. */
+    tradingFee?: bigint;
+    /** Fee charged on close (wei), when known. */
+    closeFee?: bigint;
+    /** Affiliate address attributed to the quote, when known. */
+    affiliate?: Address;
+    /** PartyB addresses allowed to fill this quote (empty means any), when known. */
+    partyBsWhiteList?: readonly Address[];
+    /** Parent quote id for a partially-opened child, when known. */
+    parentId?: bigint;
+    /** Opaque per-quote data, when known. */
+    data?: Hex;
+    /** Block timestamp the quote was created, when known. */
+    createTimestamp?: bigint;
+    /** Block timestamp of the last status change (sort key), when known. */
+    statusModifyTimestamp?: bigint;
+    /** Untouched source rows this was reconciled from. */
+    raw: {
+        /** The on-chain quote, when the row is anchored. */
+        onchain?: Quote;
+        /** The pending instant-open record, when sourced off-chain. */
+        instantOpen?: PendingInstantOpen;
+        /** The pending instant-close record, when closing off-chain. */
+        instantClose?: PendingInstantClose;
+    };
+}
+//# sourceMappingURL=unified-quote.d.ts.map

package/dist/quotes/unified-quote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unified-quote.d.ts","sourceRoot":"","sources":["../../src/quotes/unified-quote.ts"],"names":[],"mappings":"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"}

package/dist/quotes/unified-quote.js

@@ -0,0 +1,8 @@
+//#region src/quotes/unified-quote.ts
+var e = /* @__PURE__ */ function(e) {
+	return e.OPTIMISTIC = "optimistic", e.PRICE_FILLED = "price-filled", e.WRITE_ONCHAIN = "write-onchain", e.ONCHAIN = "onchain", e.OPTIMISTIC_CLOSE = "optimistic-close", e.CLOSE_PRICE_FILLED = "close-price-filled", e.WRITE_ONCHAIN_CLOSE = "write-onchain-close", e.CLOSING = "closing", e.CLOSED = "closed", e.FAILED = "failed", e;
+}({});
+//#endregion
+export { e as QuoteLifecycle };
+
+//# sourceMappingURL=unified-quote.js.map

package/dist/quotes/unified-quote.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unified-quote.js","names":[],"sources":["../../src/quotes/unified-quote.ts"],"sourcesContent":["import type { Address, Hex } from \"viem\";\nimport type { PendingInstantClose } from \"../solvers/instant-close/get-instant-closes/to-pending-instant-close\";\nimport type { PendingInstantOpen } from \"../solvers/instant-open/get-instant-opens/to-pending-instant-open\";\nimport type { LockedValues, OrderType, PositionType, Quote, QuoteStatus } from \"../symmio-contracts/symmio/types\";\n\n/**\n * Where a {@link UnifiedQuote} was sourced from before reconciliation.\n *\n * - `\"onchain\"` — read from the SYMMIO core (`getPartyAOpenPositions` /\n *   `getPartyAPendingQuotes` + `getQuote`); the row carries a real `quoteId`.\n * - `\"offchain\"` — only known to a hedger so far (a pending instant-open or\n *   instant-close); the row carries a `tempQuoteId` and waits to anchor on-chain.\n */\nexport type QuoteOrigin = \"onchain\" | \"offchain\";\n\n/**\n * The stage of a quote's lifecycle as tracked across the on-chain + off-chain\n * merge. Drives row styling and polling acceleration in the consumer.\n *\n * The off-chain stages (`OPTIMISTIC`, `PRICE_FILLED`) and the transient `CLOSING`\n * stage are SDK-side overlays — they do not exist on the on-chain\n * {@link QuoteStatus}; reconciliation assigns them from notifications and hedger\n * records.\n */\nexport enum QuoteLifecycle {\n  /** Submitted to a hedger; no on-chain quote and no fill report yet. */\n  OPTIMISTIC = \"optimistic\",\n  /** A hedger reported a fill price (`InstantRFQ` success) but the on-chain quote has not landed yet. */\n  PRICE_FILLED = \"price-filled\",\n  /**\n   * The open anchored on-chain per the notification (the `quoteId` is known), but\n   * the on-chain read has not returned the quote struct yet. The row is being\n   * \"written on-chain\": shown with its anchored id while the SDK waits for the RPC\n   * to confirm it. Resolves to {@link QuoteLifecycle.ONCHAIN} once the on-chain\n   * read returns the struct.\n   */\n  WRITE_ONCHAIN = \"write-onchain\",\n  /** Anchored on-chain; mirrors a real {@link QuoteStatus}. */\n  ONCHAIN = \"onchain\",\n  /**\n   * A close was just submitted and the hedger's pending-instant-close feed has it,\n   * but no close notification has confirmed a price yet — the close-side analog of\n   * {@link QuoteLifecycle.OPTIMISTIC}. Advances to {@link QuoteLifecycle.CLOSE_PRICE_FILLED}.\n   */\n  OPTIMISTIC_CLOSE = \"optimistic-close\",\n  /**\n   * A close notification reported the close price/fill request\n   * (`InstantRequestToClosePosition`) — the close-side analog of\n   * {@link QuoteLifecycle.PRICE_FILLED}. Advances to {@link QuoteLifecycle.WRITE_ONCHAIN_CLOSE}.\n   */\n  CLOSE_PRICE_FILLED = \"close-price-filled\",\n  /**\n   * The close fill (`FillMarketOrderInstantClose`) was reported, or a pending\n   * instant-close overlays the row while the on-chain status still shows the\n   * position open — the close is being \"written on-chain\", awaiting the RPC. The\n   * close-side analog of {@link QuoteLifecycle.WRITE_ONCHAIN}. Resolves to\n   * {@link QuoteLifecycle.CLOSING} when the on-chain status reflects the pending close.\n   */\n  WRITE_ONCHAIN_CLOSE = \"write-onchain-close\",\n  /** The close is confirmed pending on-chain — on-chain `CLOSE_PENDING` / `CANCEL_CLOSE_PENDING`. */\n  CLOSING = \"closing\",\n  /** The position is fully closed. */\n  CLOSED = \"closed\",\n  /** A hedger or notification reported the open/close failed. */\n  FAILED = \"failed\",\n}\n\n/**\n * A single quote/position row merged from every source (on-chain reads, pending\n * instant-opens, pending instant-closes, and notifications) into one stable,\n * de-duplicated shape.\n *\n * All amount and price fields are 18-decimal-wei `bigint`, matching the on-chain\n * {@link Quote}. Off-chain hedger amounts are normalized to wei before they reach\n * this type. The `key` is a stable identity for React lists and the removal\n * ledger; `raw` carries the untouched source rows for advanced use.\n */\nexport interface UnifiedQuote {\n  /** Stable identity for this row (`onchain:<id>` or `temp:<tempId>`). */\n  key: string;\n  /** Source the row was reconciled from. */\n  origin: QuoteOrigin;\n  /** Current lifecycle stage. */\n  lifecycle: QuoteLifecycle;\n  /** On-chain quote id, once anchored. */\n  quoteId?: bigint;\n  /** Hedger-local temp id, before the on-chain id exists. */\n  tempQuoteId?: number;\n  /** Sub-account (partyA) that owns the row. */\n  partyA: Address;\n  /** PartyB (hedger/solver) that locked/opened the quote, when known. */\n  partyB?: Address;\n  /** Solver-assigned Virtual Account address (lowcap), when known. */\n  vaAddress?: Address;\n  /** Market identifier (`symbolId`). */\n  symbolId: bigint;\n  /** Long or short. */\n  positionType: PositionType;\n  /** Limit or market order. */\n  orderType: OrderType;\n  /** On-chain status, when the row is anchored on-chain. */\n  quoteStatus?: QuoteStatus;\n  /** Price partyA requested to open at (wei). */\n  requestedOpenPrice: bigint;\n  /** Price partyB actually opened at (wei), when known. */\n  openedPrice?: bigint;\n  /** Initial price partyB opened at before any edits (wei), when known. */\n  initialOpenedPrice?: bigint;\n  /** Average price across executed closes (wei), when known. */\n  avgClosedPrice?: bigint;\n  /** Requested limit price for a pending close (wei), when known. */\n  requestedClosePrice?: bigint;\n  /** Market price snapshot at last state change (wei), when known. */\n  marketPrice?: bigint;\n  /** Total requested quantity (wei) — fixed for the life of the position; partial closes do not shrink it. */\n  quantity: bigint;\n  /** Quantity already closed (wei), when known. */\n  closedAmount?: bigint;\n  /**\n   * Remaining **open** size (wei): `quantity − closedAmount`, the live quantity\n   * still on the position (the figure a UI shows as \"position size\"); `0` once\n   * fully closed. Derived from the other amount fields by {@link quoteOpenQuantity}.\n   */\n  openQuantity: bigint;\n  /** Quantity targeted by a pending close (wei), when closing. */\n  quantityToClose?: bigint;\n  /** Margin locked against the row (wei). */\n  lockedValues: LockedValues;\n  /** Margin locked at open time — basis for leverage (wei), when known. */\n  initialLockedValues?: LockedValues;\n  /** Maximum funding rate partyA accepts, when known. */\n  maxFundingRate?: bigint;\n  /** Net funding paid (positive) or received (negative) over the position's life (wei), when known. */\n  accumulatedPaidFunding?: bigint;\n  /** Block timestamp funding was last applied, when known. */\n  lastFundingPaymentTimestamp?: bigint;\n  /** Quote deadline (expiry) timestamp, when known. */\n  deadline?: bigint;\n  /** Trading fee charged on the quote (wei), when known. */\n  tradingFee?: bigint;\n  /** Fee charged on close (wei), when known. */\n  closeFee?: bigint;\n  /** Affiliate address attributed to the quote, when known. */\n  affiliate?: Address;\n  /** PartyB addresses allowed to fill this quote (empty means any), when known. */\n  partyBsWhiteList?: readonly Address[];\n  /** Parent quote id for a partially-opened child, when known. */\n  parentId?: bigint;\n  /** Opaque per-quote data, when known. */\n  data?: Hex;\n  /** Block timestamp the quote was created, when known. */\n  createTimestamp?: bigint;\n  /** Block timestamp of the last status change (sort key), when known. */\n  statusModifyTimestamp?: bigint;\n  /** Untouched source rows this was reconciled from. */\n  raw: {\n    /** The on-chain quote, when the row is anchored. */\n    onchain?: Quote;\n    /** The pending instant-open record, when sourced off-chain. */\n    instantOpen?: PendingInstantOpen;\n    /** The pending instant-close record, when closing off-chain. */\n    instantClose?: PendingInstantClose;\n  };\n}\n"],"mappings":";AAwBA,IAAY,IAAL,yBAAA,GAAA;QAEL,EAAA,aAAA,cAEA,EAAA,eAAA,gBAQA,EAAA,gBAAA,iBAEA,EAAA,UAAA,WAMA,EAAA,mBAAA,oBAMA,EAAA,qBAAA,sBAQA,EAAA,sBAAA,uBAEA,EAAA,UAAA,WAEA,EAAA,SAAA,UAEA,EAAA,SAAA;AACF,EAAA,CAAA,CAAA"}

package/dist/quotes/upnl/calculate-quote-leverage.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Inputs for {@link calculateQuoteLeverage}. All bigint fields are 18-decimal wei.
+ */
+export interface CalculateQuoteLeverageParameters {
+    /** Quote quantity. */
+    quantity: bigint;
+    /** Quote's requested open price (used as the notional reference price). */
+    requestedOpenPrice: bigint;
+    /** Locked-margin legs (partyA + partyB) committed when the quote opened. */
+    lockedValues: {
+        cva: bigint;
+        lf: bigint;
+        partyAmm: bigint;
+        partyBmm: bigint;
+    };
+}
+/**
+ * Quote leverage as a decimal string.
+ *
+ * `leverage = quantity × requestedOpenPrice / (CVA + LF + partyAMM + partyBMM)`.
+ *
+ * Returns `"0"` when the locked-margin sum is zero (i.e. the quote has no
+ * partyA-locked collateral on record yet) or when any input is non-finite.
+ *
+ * @example
+ * ```ts
+ * const lev = calculateQuoteLeverage({
+ *   quantity: 1_000_000_000_000_000_000n,
+ *   requestedOpenPrice: 50_000_000_000_000_000_000n,
+ *   lockedValues: { cva: 1_000_000_000_000_000_000n, lf: 500_000_000_000_000_000n, partyAmm: 1_500_000_000_000_000_000n },
+ * });
+ * ```
+ */
+export declare function calculateQuoteLeverage(parameters: CalculateQuoteLeverageParameters): string;
+//# sourceMappingURL=calculate-quote-leverage.d.ts.map

package/dist/quotes/upnl/calculate-quote-leverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculate-quote-leverage.d.ts","sourceRoot":"","sources":["../../../src/quotes/upnl/calculate-quote-leverage.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,MAAM,WAAW,gCAAgC;IAC/C,sBAAsB;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,2EAA2E;IAC3E,kBAAkB,EAAE,MAAM,CAAC;IAC3B,4EAA4E;IAC5E,YAAY,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;CAC/E;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,gCAAgC,GAAG,MAAM,CAiB3F"}

package/dist/quotes/upnl/calculate-quote-leverage.js

@@ -0,0 +1,13 @@
+import { formatUnits as e } from "viem";
+//#region src/quotes/upnl/calculate-quote-leverage.ts
+var t = 18;
+function n(n) {
+	let r = Number(e(n.quantity, t)), i = Number(e(n.requestedOpenPrice, t)), a = Number(e(n.lockedValues.cva + n.lockedValues.lf + n.lockedValues.partyAmm + n.lockedValues.partyBmm, t));
+	if (!Number.isFinite(r) || !Number.isFinite(i) || !Number.isFinite(a) || a === 0) return "0";
+	let o = r * i / a;
+	return Number.isFinite(o) ? String(o) : "0";
+}
+//#endregion
+export { n as calculateQuoteLeverage };
+
+//# sourceMappingURL=calculate-quote-leverage.js.map

package/dist/quotes/upnl/calculate-quote-leverage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculate-quote-leverage.js","names":[],"sources":["../../../src/quotes/upnl/calculate-quote-leverage.ts"],"sourcesContent":["import { formatUnits } from \"viem\";\n\n/** Decimal places of an 18-decimal-wei fixed-point value. */\nconst WEI_DECIMALS = 18;\n\n/**\n * Inputs for {@link calculateQuoteLeverage}. All bigint fields are 18-decimal wei.\n */\nexport interface CalculateQuoteLeverageParameters {\n  /** Quote quantity. */\n  quantity: bigint;\n  /** Quote's requested open price (used as the notional reference price). */\n  requestedOpenPrice: bigint;\n  /** Locked-margin legs (partyA + partyB) committed when the quote opened. */\n  lockedValues: { cva: bigint; lf: bigint; partyAmm: bigint; partyBmm: bigint };\n}\n\n/**\n * Quote leverage as a decimal string.\n *\n * `leverage = quantity × requestedOpenPrice / (CVA + LF + partyAMM + partyBMM)`.\n *\n * Returns `\"0\"` when the locked-margin sum is zero (i.e. the quote has no\n * partyA-locked collateral on record yet) or when any input is non-finite.\n *\n * @example\n * ```ts\n * const lev = calculateQuoteLeverage({\n *   quantity: 1_000_000_000_000_000_000n,\n *   requestedOpenPrice: 50_000_000_000_000_000_000n,\n *   lockedValues: { cva: 1_000_000_000_000_000_000n, lf: 500_000_000_000_000_000n, partyAmm: 1_500_000_000_000_000_000n },\n * });\n * ```\n */\nexport function calculateQuoteLeverage(parameters: CalculateQuoteLeverageParameters): string {\n  const quantity = Number(formatUnits(parameters.quantity, WEI_DECIMALS));\n  const requestedOpenPrice = Number(formatUnits(parameters.requestedOpenPrice, WEI_DECIMALS));\n  const lockedSum = Number(\n    formatUnits(\n      parameters.lockedValues.cva +\n        parameters.lockedValues.lf +\n        parameters.lockedValues.partyAmm +\n        parameters.lockedValues.partyBmm,\n      WEI_DECIMALS,\n    ),\n  );\n  if (!Number.isFinite(quantity) || !Number.isFinite(requestedOpenPrice) || !Number.isFinite(lockedSum)) return \"0\";\n  if (lockedSum === 0) return \"0\";\n  const leverage = (quantity * requestedOpenPrice) / lockedSum;\n  if (!Number.isFinite(leverage)) return \"0\";\n  return String(leverage);\n}\n"],"mappings":";;AAGA,IAAM,IAAe;AA+BrB,SAAgB,EAAuB,GAAsD;CAC3F,IAAM,IAAW,OAAO,EAAY,EAAW,UAAU,CAAY,CAAC,GAChE,IAAqB,OAAO,EAAY,EAAW,oBAAoB,CAAY,CAAC,GACpF,IAAY,OAChB,EACE,EAAW,aAAa,MACtB,EAAW,aAAa,KACxB,EAAW,aAAa,WACxB,EAAW,aAAa,UAC1B,CACF,CACF;CAEA,IADI,CAAC,OAAO,SAAS,CAAQ,KAAK,CAAC,OAAO,SAAS,CAAkB,KAAK,CAAC,OAAO,SAAS,CAAS,KAChG,MAAc,GAAG,OAAO;CAC5B,IAAM,IAAY,IAAW,IAAsB;CAEnD,OADK,OAAO,SAAS,CAAQ,IACtB,OAAO,CAAQ,IADiB;AAEzC"}