@symmio/trading-core 2.0.0 → 3.0.0

package/dist/solvers/instant-open/shared/open-estimate-guard.d.ts

@@ -0,0 +1,89 @@
+import { SolverId } from '../../../core/chains/types.js';
+import { Config } from '../../../core/config/index.js';
+import { PositionType } from './types.js';
+/**
+ * Validate a user-supplied slippage percent before any network work.
+ *
+ * Accepts a finite number in `[0, 100)` — `0` is a legal "no tolerance"
+ * choice; `100`+ would zero or invert a SHORT's price bound.
+ *
+ * @throws {SymmError} `INVALID_SLIPPAGE` when out of range.
+ */
+export declare function assertValidSlippage(slippage: number): void;
+/**
+ * Parameters for {@link fetchOpenEstimatePrice}.
+ */
+export interface FetchOpenEstimatePriceParameters {
+    chainId?: number;
+    /** Solver whose dry-run estimate to read. Defaults to the chain's `defaultSolverId`. */
+    solverId?: SolverId;
+    /** Solver market id. */
+    symbolId: number;
+    /** Trade side. */
+    positionType: PositionType;
+    /** Leveraged order quantity (decimal string) — the size that will go on the wire. */
+    quantity: string;
+    /** Mark price the order was sized at (decimal string). */
+    markPrice: string;
+}
+/**
+ * Fetch the solver's expected fill price for an open, best-effort.
+ *
+ * Requests with the wide fixed bound ({@link OPEN_ESTIMATE_REQUEST_TOLERANCE})
+ * so the solver's price gate never rejects the question. Returns `undefined`
+ * instead of throwing when the estimate is unusable — network error,
+ * non-Enigma solver, zero/NaN price, zero mark.
+ */
+export declare function fetchOpenEstimatePrice(config: Config, parameters: FetchOpenEstimatePriceParameters): Promise<string | undefined>;
+/**
+ * Derive a slippage percent from the solver's expected fill price.
+ *
+ * The price bound is the estimate plus 4% headroom
+ * ({@link AUTO_SLIPPAGE_ESTIMATE_MARGIN}) — `estimate × 1.04` for a LONG,
+ * `estimate × 0.96` for a SHORT — re-expressed as a percent deviation from the
+ * mark price (the basis `calculateTradeParams` applies slippage to). Clamped to
+ * `[0, 99]` so the result always passes {@link assertValidSlippage}. Falls back
+ * to a flat {@link AUTO_SLIPPAGE_FALLBACK_PERCENT}% when no usable estimate or
+ * mark exists.
+ */
+export declare function deriveAutoSlippage({ markPrice, expectedFillPrice, positionType, }: {
+    markPrice: string;
+    expectedFillPrice: string | undefined;
+    positionType: PositionType;
+}): number;
+/**
+ * Parameters for {@link assertOpenEstimateWithinSlippage}.
+ */
+export interface AssertOpenEstimateWithinSlippageParameters extends FetchOpenEstimatePriceParameters {
+    /** User slippage tolerance percent (e.g. `5` for 5%). */
+    slippage: number;
+    /**
+     * Pre-fetched expected fill price ({@link fetchOpenEstimatePrice}). When
+     * supplied, the dry-run fetch is skipped and this value gates instead.
+     */
+    expectedFillPrice?: string;
+}
+/**
+ * Dry-run the order and reject when the expected fill sits outside the user's
+ * slippage tolerance.
+ *
+ * `expectedFillPrice` comes from `GET /estimated-price` (requested with a wide
+ * fixed bound — see {@link OPEN_ESTIMATE_REQUEST_TOLERANCE}); the gate is
+ *
+ * ```text
+ * |expectedFillPrice − markPrice| / markPrice > slippage/100 + ε → reject
+ * ```
+ *
+ * A rejection here is a good estimate saying the market cannot fill within
+ * tolerance — the solver would reject the order anyway, so failing early with a
+ * clear error beats a wire round-trip ending in a solver error code.
+ *
+ * Best-effort by design: an unavailable estimate (network error, non-Enigma
+ * solver, zero price) skips the gate rather than blocking the open — the
+ * mark-sized order is always valid to submit.
+ *
+ * @throws {SymmError} `SLIPPAGE_EXCEEDED` when the estimated fill deviates
+ *   from mark beyond the tolerance.
+ */
+export declare function assertOpenEstimateWithinSlippage(config: Config, parameters: AssertOpenEstimateWithinSlippageParameters): Promise<void>;
+//# sourceMappingURL=open-estimate-guard.d.ts.map

package/dist/solvers/instant-open/shared/open-estimate-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open-estimate-guard.d.ts","sourceRoot":"","sources":["../../../../src/solvers/instant-open/shared/open-estimate-guard.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAGnD,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAkBvC;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAQ1D;AAaD;;GAEG;AACH,MAAM,WAAW,gCAAgC;IAC/C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,wFAAwF;IACxF,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,wBAAwB;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,kBAAkB;IAClB,YAAY,EAAE,YAAY,CAAC;IAC3B,qFAAqF;IACrF,QAAQ,EAAE,MAAM,CAAC;IACjB,0DAA0D;IAC1D,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;GAOG;AACH,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,gCAAgC,GAC3C,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CA2B7B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,SAAS,EACT,iBAAiB,EACjB,YAAY,GACb,EAAE;IACD,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,GAAG,SAAS,CAAC;IACtC,YAAY,EAAE,YAAY,CAAC;CAC5B,GAAG,MAAM,CAkBT;AAED;;GAEG;AACH,MAAM,WAAW,0CAA2C,SAAQ,gCAAgC;IAClG,yDAAyD;IACzD,QAAQ,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,gCAAgC,CACpD,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,0CAA0C,GACrD,OAAO,CAAC,IAAI,CAAC,CAkBf"}

package/dist/solvers/instant-open/shared/open-estimate-guard.js

@@ -0,0 +1,52 @@
+import { SymmError as e } from "../../../shared/errors/symm-error.js";
+import { PositionType as t } from "../../../symmio-contracts/symmio/types.js";
+import { getEstimatedPrice as n } from "../../estimated-price/get-estimated-price.js";
+import { toDecimal as r } from "@symmio/utils/decimal";
+//#region src/solvers/instant-open/shared/open-estimate-guard.ts
+var i = 1e-9, a = .5;
+function o(t) {
+	if (typeof t != "number" || !Number.isFinite(t) || t < 0 || t >= 100) throw new e("validation", "INVALID_SLIPPAGE", `Invalid slippage "${String(t)}": expected a finite percent in [0, 100), e.g. 1 for 1%.`);
+}
+var s = .04, c = 4;
+async function l(e, i) {
+	let o = r(i.markPrice);
+	if (o.isZero() || o.isNaN()) return;
+	let s = i.positionType === t.SHORT ? o.times(1 - a) : o.times(1 + a), c;
+	try {
+		({estimatedPrice: c} = await n(e, {
+			chainId: i.chainId,
+			solverId: i.solverId,
+			symbolId: i.symbolId,
+			quantity: i.quantity,
+			positionType: i.positionType,
+			entry: "open",
+			price: s.toString()
+		}));
+	} catch {
+		return;
+	}
+	let l = r(c);
+	if (!(l.isZero() || l.isNaN())) return c;
+}
+function u({ markPrice: e, expectedFillPrice: n, positionType: i }) {
+	let a = r(e);
+	if (a.isZero() || a.isNaN() || n === void 0) return c;
+	let o = r(n);
+	if (o.isZero() || o.isNaN()) return c;
+	let l = i === t.SHORT ? r(1).minus(o.times(1 - s).div(a)).times(100) : o.times(1 + s).div(a).minus(1).times(100);
+	return Math.min(99, Math.max(0, l.toNumber()));
+}
+async function d(t, n) {
+	let a = r(n.markPrice);
+	if (a.isZero() || a.isNaN()) return;
+	let o = n.expectedFillPrice ?? await l(t, n);
+	if (o === void 0) return;
+	let s = r(o);
+	if (s.isZero() || s.isNaN()) return;
+	let c = s.minus(a).abs().div(a);
+	if (c.gt(r(n.slippage).div(100).plus(i))) throw new e("validation", "SLIPPAGE_EXCEEDED", `Estimated execution price ${o} deviates ${c.times(100).toFixed(4)}% from mark ${n.markPrice}, above the ${n.slippage}% slippage tolerance. Raise the tolerance or reduce the size.`);
+}
+//#endregion
+export { d as assertOpenEstimateWithinSlippage, o as assertValidSlippage, u as deriveAutoSlippage, l as fetchOpenEstimatePrice };
+
+//# sourceMappingURL=open-estimate-guard.js.map

package/dist/solvers/instant-open/shared/open-estimate-guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"open-estimate-guard.js","names":[],"sources":["../../../../src/solvers/instant-open/shared/open-estimate-guard.ts"],"sourcesContent":["import { toDecimal } from \"@symmio/utils/decimal\";\nimport type { SolverId } from \"../../../core/chains/types\";\nimport type { Config } from \"../../../core/config\";\nimport { SymmError } from \"../../../shared/errors/symm-error\";\nimport { getEstimatedPrice } from \"../../estimated-price/get-estimated-price\";\nimport { PositionType } from \"./types\";\n\n/**\n * Absorbs binary-float noise at the tolerance boundary, so a deviation sitting\n * exactly on the user's setting is not rejected by floating-point error.\n */\nconst BAND_EPSILON = 1e-9;\n\n/**\n * Price bound sent when ASKING the solver for an open estimate — never a\n * trading bound. The solver treats `price` as a hard gate and rejects a bound\n * tighter than its fill instead of answering, while above that threshold the\n * answer does not move. A wide fixed bound keeps the estimate request always\n * answerable and keeps the estimate a pure function of quantity rather than of\n * the user's slippage setting.\n */\nconst OPEN_ESTIMATE_REQUEST_TOLERANCE = 0.5;\n\n/**\n * Validate a user-supplied slippage percent before any network work.\n *\n * Accepts a finite number in `[0, 100)` — `0` is a legal \"no tolerance\"\n * choice; `100`+ would zero or invert a SHORT's price bound.\n *\n * @throws {SymmError} `INVALID_SLIPPAGE` when out of range.\n */\nexport function assertValidSlippage(slippage: number): void {\n  if (typeof slippage !== \"number\" || !Number.isFinite(slippage) || slippage < 0 || slippage >= 100) {\n    throw new SymmError(\n      \"validation\",\n      \"INVALID_SLIPPAGE\",\n      `Invalid slippage \"${String(slippage)}\": expected a finite percent in [0, 100), e.g. 1 for 1%.`,\n    );\n  }\n}\n\n/**\n * Headroom applied on top of the estimated fill price when deriving an\n * automatic slippage ({@link deriveAutoSlippage}): the price bound is\n * `estimate × (1 ± 4%)`, covering drift between the solver's estimate and the\n * actual fill.\n */\nconst AUTO_SLIPPAGE_ESTIMATE_MARGIN = 0.04;\n\n/** Fallback auto slippage percent when no usable estimate exists. */\nconst AUTO_SLIPPAGE_FALLBACK_PERCENT = 4;\n\n/**\n * Parameters for {@link fetchOpenEstimatePrice}.\n */\nexport interface FetchOpenEstimatePriceParameters {\n  chainId?: number;\n  /** Solver whose dry-run estimate to read. Defaults to the chain's `defaultSolverId`. */\n  solverId?: SolverId;\n  /** Solver market id. */\n  symbolId: number;\n  /** Trade side. */\n  positionType: PositionType;\n  /** Leveraged order quantity (decimal string) — the size that will go on the wire. */\n  quantity: string;\n  /** Mark price the order was sized at (decimal string). */\n  markPrice: string;\n}\n\n/**\n * Fetch the solver's expected fill price for an open, best-effort.\n *\n * Requests with the wide fixed bound ({@link OPEN_ESTIMATE_REQUEST_TOLERANCE})\n * so the solver's price gate never rejects the question. Returns `undefined`\n * instead of throwing when the estimate is unusable — network error,\n * non-Enigma solver, zero/NaN price, zero mark.\n */\nexport async function fetchOpenEstimatePrice(\n  config: Config,\n  parameters: FetchOpenEstimatePriceParameters,\n): Promise<string | undefined> {\n  const mark = toDecimal(parameters.markPrice);\n  if (mark.isZero() || mark.isNaN()) return undefined;\n\n  const requestPrice =\n    parameters.positionType === PositionType.SHORT\n      ? mark.times(1 - OPEN_ESTIMATE_REQUEST_TOLERANCE)\n      : mark.times(1 + OPEN_ESTIMATE_REQUEST_TOLERANCE);\n\n  let estimatedPrice: string;\n  try {\n    ({ estimatedPrice } = await getEstimatedPrice(config, {\n      chainId: parameters.chainId,\n      solverId: parameters.solverId,\n      symbolId: parameters.symbolId,\n      quantity: parameters.quantity,\n      positionType: parameters.positionType,\n      entry: \"open\",\n      price: requestPrice.toString(),\n    }));\n  } catch {\n    return undefined;\n  }\n\n  const estimate = toDecimal(estimatedPrice);\n  if (estimate.isZero() || estimate.isNaN()) return undefined;\n  return estimatedPrice;\n}\n\n/**\n * Derive a slippage percent from the solver's expected fill price.\n *\n * The price bound is the estimate plus 4% headroom\n * ({@link AUTO_SLIPPAGE_ESTIMATE_MARGIN}) — `estimate × 1.04` for a LONG,\n * `estimate × 0.96` for a SHORT — re-expressed as a percent deviation from the\n * mark price (the basis `calculateTradeParams` applies slippage to). Clamped to\n * `[0, 99]` so the result always passes {@link assertValidSlippage}. Falls back\n * to a flat {@link AUTO_SLIPPAGE_FALLBACK_PERCENT}% when no usable estimate or\n * mark exists.\n */\nexport function deriveAutoSlippage({\n  markPrice,\n  expectedFillPrice,\n  positionType,\n}: {\n  markPrice: string;\n  expectedFillPrice: string | undefined;\n  positionType: PositionType;\n}): number {\n  const mark = toDecimal(markPrice);\n  if (mark.isZero() || mark.isNaN() || expectedFillPrice === undefined) return AUTO_SLIPPAGE_FALLBACK_PERCENT;\n  const estimate = toDecimal(expectedFillPrice);\n  if (estimate.isZero() || estimate.isNaN()) return AUTO_SLIPPAGE_FALLBACK_PERCENT;\n\n  const percent =\n    positionType === PositionType.SHORT\n      ? toDecimal(1)\n          .minus(estimate.times(1 - AUTO_SLIPPAGE_ESTIMATE_MARGIN).div(mark))\n          .times(100)\n      : estimate\n          .times(1 + AUTO_SLIPPAGE_ESTIMATE_MARGIN)\n          .div(mark)\n          .minus(1)\n          .times(100);\n\n  return Math.min(99, Math.max(0, percent.toNumber()));\n}\n\n/**\n * Parameters for {@link assertOpenEstimateWithinSlippage}.\n */\nexport interface AssertOpenEstimateWithinSlippageParameters extends FetchOpenEstimatePriceParameters {\n  /** User slippage tolerance percent (e.g. `5` for 5%). */\n  slippage: number;\n  /**\n   * Pre-fetched expected fill price ({@link fetchOpenEstimatePrice}). When\n   * supplied, the dry-run fetch is skipped and this value gates instead.\n   */\n  expectedFillPrice?: string;\n}\n\n/**\n * Dry-run the order and reject when the expected fill sits outside the user's\n * slippage tolerance.\n *\n * `expectedFillPrice` comes from `GET /estimated-price` (requested with a wide\n * fixed bound — see {@link OPEN_ESTIMATE_REQUEST_TOLERANCE}); the gate is\n *\n * ```text\n * |expectedFillPrice − markPrice| / markPrice > slippage/100 + ε → reject\n * ```\n *\n * A rejection here is a good estimate saying the market cannot fill within\n * tolerance — the solver would reject the order anyway, so failing early with a\n * clear error beats a wire round-trip ending in a solver error code.\n *\n * Best-effort by design: an unavailable estimate (network error, non-Enigma\n * solver, zero price) skips the gate rather than blocking the open — the\n * mark-sized order is always valid to submit.\n *\n * @throws {SymmError} `SLIPPAGE_EXCEEDED` when the estimated fill deviates\n *   from mark beyond the tolerance.\n */\nexport async function assertOpenEstimateWithinSlippage(\n  config: Config,\n  parameters: AssertOpenEstimateWithinSlippageParameters,\n): Promise<void> {\n  const mark = toDecimal(parameters.markPrice);\n  if (mark.isZero() || mark.isNaN()) return;\n\n  const estimatedPrice = parameters.expectedFillPrice ?? (await fetchOpenEstimatePrice(config, parameters));\n  if (estimatedPrice === undefined) return;\n\n  const expectedFillPrice = toDecimal(estimatedPrice);\n  if (expectedFillPrice.isZero() || expectedFillPrice.isNaN()) return;\n\n  const deviation = expectedFillPrice.minus(mark).abs().div(mark);\n  if (deviation.gt(toDecimal(parameters.slippage).div(100).plus(BAND_EPSILON))) {\n    throw new SymmError(\n      \"validation\",\n      \"SLIPPAGE_EXCEEDED\",\n      `Estimated execution price ${estimatedPrice} deviates ${deviation.times(100).toFixed(4)}% from mark ${parameters.markPrice}, above the ${parameters.slippage}% slippage tolerance. Raise the tolerance or reduce the size.`,\n    );\n  }\n}\n"],"mappings":";;;;;AAWA,IAAM,IAAe,MAUf,IAAkC;AAUxC,SAAgB,EAAoB,GAAwB;CAC1D,IAAI,OAAO,KAAa,YAAY,CAAC,OAAO,SAAS,CAAQ,KAAK,IAAW,KAAK,KAAY,KAC5F,MAAM,IAAI,EACR,cACA,oBACA,qBAAqB,OAAO,CAAQ,EAAE,yDACxC;AAEJ;AAQA,IAAM,IAAgC,KAGhC,IAAiC;AA2BvC,eAAsB,EACpB,GACA,GAC6B;CAC7B,IAAM,IAAO,EAAU,EAAW,SAAS;CAC3C,IAAI,EAAK,OAAO,KAAK,EAAK,MAAM,GAAG;CAEnC,IAAM,IACJ,EAAW,iBAAiB,EAAa,QACrC,EAAK,MAAM,IAAI,CAA+B,IAC9C,EAAK,MAAM,IAAI,CAA+B,GAEhD;CACJ,IAAI;EACF,CAAC,sBAAqB,MAAM,EAAkB,GAAQ;GACpD,SAAS,EAAW;GACpB,UAAU,EAAW;GACrB,UAAU,EAAW;GACrB,UAAU,EAAW;GACrB,cAAc,EAAW;GACzB,OAAO;GACP,OAAO,EAAa,SAAS;EAC/B,CAAC;CACH,QAAQ;EACN;CACF;CAEA,IAAM,IAAW,EAAU,CAAc;CACrC,QAAS,OAAO,KAAK,EAAS,MAAM,IACxC,OAAO;AACT;AAaA,SAAgB,EAAmB,EACjC,cACA,sBACA,mBAKS;CACT,IAAM,IAAO,EAAU,CAAS;CAChC,IAAI,EAAK,OAAO,KAAK,EAAK,MAAM,KAAK,MAAsB,KAAA,GAAW,OAAO;CAC7E,IAAM,IAAW,EAAU,CAAiB;CAC5C,IAAI,EAAS,OAAO,KAAK,EAAS,MAAM,GAAG,OAAO;CAElD,IAAM,IACJ,MAAiB,EAAa,QAC1B,EAAU,CAAC,EACR,MAAM,EAAS,MAAM,IAAI,CAA6B,EAAE,IAAI,CAAI,CAAC,EACjE,MAAM,GAAG,IACZ,EACG,MAAM,IAAI,CAA6B,EACvC,IAAI,CAAI,EACR,MAAM,CAAC,EACP,MAAM,GAAG;CAElB,OAAO,KAAK,IAAI,IAAI,KAAK,IAAI,GAAG,EAAQ,SAAS,CAAC,CAAC;AACrD;AAqCA,eAAsB,EACpB,GACA,GACe;CACf,IAAM,IAAO,EAAU,EAAW,SAAS;CAC3C,IAAI,EAAK,OAAO,KAAK,EAAK,MAAM,GAAG;CAEnC,IAAM,IAAiB,EAAW,qBAAsB,MAAM,EAAuB,GAAQ,CAAU;CACvG,IAAI,MAAmB,KAAA,GAAW;CAElC,IAAM,IAAoB,EAAU,CAAc;CAClD,IAAI,EAAkB,OAAO,KAAK,EAAkB,MAAM,GAAG;CAE7D,IAAM,IAAY,EAAkB,MAAM,CAAI,EAAE,IAAI,EAAE,IAAI,CAAI;CAC9D,IAAI,EAAU,GAAG,EAAU,EAAW,QAAQ,EAAE,IAAI,GAAG,EAAE,KAAK,CAAY,CAAC,GACzE,MAAM,IAAI,EACR,cACA,qBACA,6BAA6B,EAAe,YAAY,EAAU,MAAM,GAAG,EAAE,QAAQ,CAAC,EAAE,cAAc,EAAW,UAAU,cAAc,EAAW,SAAS,8DAC/J;AAEJ"}

package/dist/solvers/instant-open/shared/selectors.d.ts

@@ -1,4 +1,5 @@
 import { Hex } from 'viem';
+import { Config } from '../../../core/config/index.js';
 /**
  * 4-byte function selector for `AccountLayer.addMarginToNextVA(...)`.
  *
@@ -7,7 +8,17 @@ import { Hex } from 'viem';
  */
 export declare const ADD_MARGIN_TO_NEXT_VA_SELECTOR: Hex;
 /**
- * 4-byte function selector for `Symmio.sendQuoteWithAffiliateAndData(...)`.
+ * 4-byte function selector for `Symmio.sendQuote(...)` — the perps-core v0.8.6
+ * overload carrying `SolverFeeCaps`. This is the selector the Enigma
+ * instant-open flow signs, and the one a session key needs delegation for.
+ */
+export declare const SEND_QUOTE_SELECTOR: Hex;
+/**
+ * 4-byte function selector for the legacy `Symmio.sendQuoteWithAffiliateAndData(...)`.
+ *
+ * Kept for the Rasa flow, which still signs the legacy method (it stores zero
+ * solver-fee caps on-chain). The Enigma delegation set uses
+ * {@link SEND_QUOTE_SELECTOR} instead.
  */
 export declare const SEND_QUOTE_WITH_AFFILIATE_AND_DATA_SELECTOR: Hex;
 /**
@@ -15,21 +26,49 @@ export declare const SEND_QUOTE_WITH_AFFILIATE_AND_DATA_SELECTOR: Hex;
  */
 export declare const REQUEST_TO_CLOSE_POSITION_SELECTOR: Hex;
 /**
- * The full set of selectors a session key needs delegation for in order to
- * sign the InstantLayer v2 trade lifecycle on behalf of a sub-account: open
- * (`sendQuoteWithAffiliateAndData`), close (`requestToClosePosition`), and
- * margin top-up (`addMarginToNextVA`). Pass to `grantDelegation` in one
- * transaction.
+ * The selectors a session key needs delegation for to sign the InstantLayer v2
+ * trade lifecycle on a **perps-core v0.8.6 chain**: open (`sendQuote`), close
+ * (`requestToClosePosition`), and margin top-up (`addMarginToNextVA`). Pass to
+ * `grantDelegation` in one transaction.
+ *
+ * **The set is per-chain.** A v0.8.5 chain's open leg is the legacy
+ * `sendQuoteWithAffiliateAndData` ({@link LEGACY_INSTANT_TRADE_REQUIRED_SELECTORS});
+ * in a flow that serves several chains, resolve the right set with
+ * {@link getInstantTradeRequiredSelectors} instead of hardcoding either
+ * constant.
  *
  * @example
  * ```ts
  * grantDelegation(config, {
  *   account: { addr: subAccountAddress, isPartyB: false },
  *   delegatedSigner: sessionKeyAddress,
- *   selectors: INSTANT_TRADE_REQUIRED_SELECTORS,
+ *   selectors: getInstantTradeRequiredSelectors(config, { chainId }),
  *   expiryTimestamp,
  * });
  * ```
  */
 export declare const INSTANT_TRADE_REQUIRED_SELECTORS: readonly [`0x${string}`, `0x${string}`, `0x${string}`];
+/**
+ * The {@link INSTANT_TRADE_REQUIRED_SELECTORS} counterpart for a **perps-core
+ * v0.8.5 chain**, whose open leg is the legacy `sendQuoteWithAffiliateAndData`
+ * (the capped `sendQuote` selector does not exist on its diamond).
+ */
+export declare const LEGACY_INSTANT_TRADE_REQUIRED_SELECTORS: readonly [`0x${string}`, `0x${string}`, `0x${string}`];
+/**
+ * Resolve the session-key delegation selector set for a chain by its
+ * `contractsVersion`: {@link INSTANT_TRADE_REQUIRED_SELECTORS} on `"0.8.6"`,
+ * {@link LEGACY_INSTANT_TRADE_REQUIRED_SELECTORS} on `"0.8.5"`.
+ *
+ * Use this (or the `useInstantTradeRequiredSelectors` hook) in any flow that
+ * can point at more than one chain — a hardcoded set is wrong on the other
+ * generation's chains.
+ *
+ * @param config - The SDK config.
+ * @param parameters - Optional `chainId`; defaults to the config's `defaultChainId`.
+ * @returns The selector set matching the chain's contracts generation.
+ * @throws {SymmError} `UNSUPPORTED_CHAIN` when the chain is not configured.
+ */
+export declare function getInstantTradeRequiredSelectors(config: Config, parameters?: {
+    chainId?: number;
+}): typeof INSTANT_TRADE_REQUIRED_SELECTORS | typeof LEGACY_INSTANT_TRADE_REQUIRED_SELECTORS;
 //# sourceMappingURL=selectors.d.ts.map

package/dist/solvers/instant-open/shared/selectors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"selectors.d.ts","sourceRoot":"","sources":["../../../../src/solvers/instant-open/shared/selectors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkD,KAAK,GAAG,EAAE,MAAM,MAAM,CAAC;AAUhF;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,EAAE,GAAkE,CAAC;AAEhH;;GAEG;AACH,eAAO,MAAM,2CAA2C,EAAE,GAGzD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kCAAkC,EAAE,GAAiE,CAAC;AAEnH;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,gCAAgC,wDAInC,CAAC"}
+{"version":3,"file":"selectors.d.ts","sourceRoot":"","sources":["../../../../src/solvers/instant-open/shared/selectors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkD,KAAK,GAAG,EAAE,MAAM,MAAM,CAAC;AAChF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAUnD;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,EAAE,GAAkE,CAAC;AAEhH;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,GAAoD,CAAC;AAEvF;;;;;;GAMG;AACH,eAAO,MAAM,2CAA2C,EAAE,GAGzD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kCAAkC,EAAE,GAAiE,CAAC;AAEnH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,gCAAgC,wDAInC,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,uCAAuC,wDAI1C,CAAC;AAEX;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gCAAgC,CAC9C,MAAM,EAAE,MAAM,EACd,UAAU,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GACpC,OAAO,gCAAgC,GAAG,OAAO,uCAAuC,CAI1F"}

package/dist/solvers/instant-open/shared/selectors.js

@@ -1,5 +1,5 @@
-import { accountLayerAbi as e } from "../../../symmio-contracts/abi/v0.8.5/account-layer.js";
-import { symmioAbi as t } from "../../../symmio-contracts/abi/v0.8.5/symmio.js";
+import { accountLayerAbi as e } from "../../../symmio-contracts/abi/v0.8.6/account-layer.js";
+import { symmioAbi as t } from "../../../symmio-contracts/abi/v0.8.6/symmio.js";
 import { toFunctionSelector as n } from "viem";
 //#region src/solvers/instant-open/shared/selectors.ts
 function r(e, t) {
@@ -7,12 +7,19 @@ function r(e, t) {
 	if (!r) throw Error(`Selector lookup failed: "${t}" not in ABI.`);
 	return n(r);
 }
-var i = r(e, "addMarginToNextVA"), a = r(t, "sendQuoteWithAffiliateAndData"), o = r(t, "requestToClosePosition"), s = [
+var i = r(e, "addMarginToNextVA"), a = r(t, "sendQuote"), o = r(t, "sendQuoteWithAffiliateAndData"), s = r(t, "requestToClosePosition"), c = [
 	i,
 	a,
-	o
+	s
+], l = [
+	i,
+	o,
+	s
 ];
+function u(e, t = {}) {
+	return e.getChainConfig(t.chainId).contractsVersion === "0.8.5" ? l : c;
+}
 //#endregion
-export { i as ADD_MARGIN_TO_NEXT_VA_SELECTOR, s as INSTANT_TRADE_REQUIRED_SELECTORS, o as REQUEST_TO_CLOSE_POSITION_SELECTOR, a as SEND_QUOTE_WITH_AFFILIATE_AND_DATA_SELECTOR };
+export { i as ADD_MARGIN_TO_NEXT_VA_SELECTOR, c as INSTANT_TRADE_REQUIRED_SELECTORS, l as LEGACY_INSTANT_TRADE_REQUIRED_SELECTORS, s as REQUEST_TO_CLOSE_POSITION_SELECTOR, a as SEND_QUOTE_SELECTOR, o as SEND_QUOTE_WITH_AFFILIATE_AND_DATA_SELECTOR, u as getInstantTradeRequiredSelectors };
 
 //# sourceMappingURL=selectors.js.map

package/dist/solvers/instant-open/shared/selectors.js.map

@@ -1 +1 @@
-{"version":3,"file":"selectors.js","names":[],"sources":["../../../../src/solvers/instant-open/shared/selectors.ts"],"sourcesContent":["import { toFunctionSelector, type Abi, type AbiFunction, type Hex } from \"viem\";\nimport { accountLayerAbi } from \"../../../symmio-contracts/abi/v0.8.5/account-layer\";\nimport { symmioAbi } from \"../../../symmio-contracts/abi/v0.8.5/symmio\";\n\nfunction selectorFromAbi(abi: Abi, name: string): Hex {\n  const fragment = abi.find((item) => item.type === \"function\" && item.name === name) as AbiFunction | undefined;\n  if (!fragment) throw new Error(`Selector lookup failed: \"${name}\" not in ABI.`);\n  return toFunctionSelector(fragment);\n}\n\n/**\n * 4-byte function selector for `AccountLayer.addMarginToNextVA(...)`.\n *\n * Computed once from the ABI fragment so it stays in sync if the function\n * signature changes in a future ABI version.\n */\nexport const ADD_MARGIN_TO_NEXT_VA_SELECTOR: Hex = selectorFromAbi(accountLayerAbi as Abi, \"addMarginToNextVA\");\n\n/**\n * 4-byte function selector for `Symmio.sendQuoteWithAffiliateAndData(...)`.\n */\nexport const SEND_QUOTE_WITH_AFFILIATE_AND_DATA_SELECTOR: Hex = selectorFromAbi(\n  symmioAbi as Abi,\n  \"sendQuoteWithAffiliateAndData\",\n);\n\n/**\n * 4-byte function selector for `Symmio.requestToClosePosition(...)`.\n */\nexport const REQUEST_TO_CLOSE_POSITION_SELECTOR: Hex = selectorFromAbi(symmioAbi as Abi, \"requestToClosePosition\");\n\n/**\n * The full set of selectors a session key needs delegation for in order to\n * sign the InstantLayer v2 trade lifecycle on behalf of a sub-account: open\n * (`sendQuoteWithAffiliateAndData`), close (`requestToClosePosition`), and\n * margin top-up (`addMarginToNextVA`). Pass to `grantDelegation` in one\n * transaction.\n *\n * @example\n * ```ts\n * grantDelegation(config, {\n *   account: { addr: subAccountAddress, isPartyB: false },\n *   delegatedSigner: sessionKeyAddress,\n *   selectors: INSTANT_TRADE_REQUIRED_SELECTORS,\n *   expiryTimestamp,\n * });\n * ```\n */\nexport const INSTANT_TRADE_REQUIRED_SELECTORS = [\n  ADD_MARGIN_TO_NEXT_VA_SELECTOR,\n  SEND_QUOTE_WITH_AFFILIATE_AND_DATA_SELECTOR,\n  REQUEST_TO_CLOSE_POSITION_SELECTOR,\n] as const;\n"],"mappings":";;;;AAIA,SAAS,EAAgB,GAAU,GAAmB;CACpD,IAAM,IAAW,EAAI,MAAM,MAAS,EAAK,SAAS,cAAc,EAAK,SAAS,CAAI;CAClF,IAAI,CAAC,GAAU,MAAU,MAAM,4BAA4B,EAAK,cAAc;CAC9E,OAAO,EAAmB,CAAQ;AACpC;AAQA,IAAa,IAAsC,EAAgB,GAAwB,mBAAmB,GAKjG,IAAmD,EAC9D,GACA,+BACF,GAKa,IAA0C,EAAgB,GAAkB,wBAAwB,GAmBpG,IAAmC;CAC9C;CACA;CACA;AACF"}
+{"version":3,"file":"selectors.js","names":[],"sources":["../../../../src/solvers/instant-open/shared/selectors.ts"],"sourcesContent":["import { toFunctionSelector, type Abi, type AbiFunction, type Hex } from \"viem\";\nimport type { Config } from \"../../../core/config\";\nimport { accountLayerAbi } from \"../../../symmio-contracts/abi/v0.8.6/account-layer\";\nimport { symmioAbi } from \"../../../symmio-contracts/abi/v0.8.6/symmio\";\n\nfunction selectorFromAbi(abi: Abi, name: string): Hex {\n  const fragment = abi.find((item) => item.type === \"function\" && item.name === name) as AbiFunction | undefined;\n  if (!fragment) throw new Error(`Selector lookup failed: \"${name}\" not in ABI.`);\n  return toFunctionSelector(fragment);\n}\n\n/**\n * 4-byte function selector for `AccountLayer.addMarginToNextVA(...)`.\n *\n * Computed once from the ABI fragment so it stays in sync if the function\n * signature changes in a future ABI version.\n */\nexport const ADD_MARGIN_TO_NEXT_VA_SELECTOR: Hex = selectorFromAbi(accountLayerAbi as Abi, \"addMarginToNextVA\");\n\n/**\n * 4-byte function selector for `Symmio.sendQuote(...)` — the perps-core v0.8.6\n * overload carrying `SolverFeeCaps`. This is the selector the Enigma\n * instant-open flow signs, and the one a session key needs delegation for.\n */\nexport const SEND_QUOTE_SELECTOR: Hex = selectorFromAbi(symmioAbi as Abi, \"sendQuote\");\n\n/**\n * 4-byte function selector for the legacy `Symmio.sendQuoteWithAffiliateAndData(...)`.\n *\n * Kept for the Rasa flow, which still signs the legacy method (it stores zero\n * solver-fee caps on-chain). The Enigma delegation set uses\n * {@link SEND_QUOTE_SELECTOR} instead.\n */\nexport const SEND_QUOTE_WITH_AFFILIATE_AND_DATA_SELECTOR: Hex = selectorFromAbi(\n  symmioAbi as Abi,\n  \"sendQuoteWithAffiliateAndData\",\n);\n\n/**\n * 4-byte function selector for `Symmio.requestToClosePosition(...)`.\n */\nexport const REQUEST_TO_CLOSE_POSITION_SELECTOR: Hex = selectorFromAbi(symmioAbi as Abi, \"requestToClosePosition\");\n\n/**\n * The selectors a session key needs delegation for to sign the InstantLayer v2\n * trade lifecycle on a **perps-core v0.8.6 chain**: open (`sendQuote`), close\n * (`requestToClosePosition`), and margin top-up (`addMarginToNextVA`). Pass to\n * `grantDelegation` in one transaction.\n *\n * **The set is per-chain.** A v0.8.5 chain's open leg is the legacy\n * `sendQuoteWithAffiliateAndData` ({@link LEGACY_INSTANT_TRADE_REQUIRED_SELECTORS});\n * in a flow that serves several chains, resolve the right set with\n * {@link getInstantTradeRequiredSelectors} instead of hardcoding either\n * constant.\n *\n * @example\n * ```ts\n * grantDelegation(config, {\n *   account: { addr: subAccountAddress, isPartyB: false },\n *   delegatedSigner: sessionKeyAddress,\n *   selectors: getInstantTradeRequiredSelectors(config, { chainId }),\n *   expiryTimestamp,\n * });\n * ```\n */\nexport const INSTANT_TRADE_REQUIRED_SELECTORS = [\n  ADD_MARGIN_TO_NEXT_VA_SELECTOR,\n  SEND_QUOTE_SELECTOR,\n  REQUEST_TO_CLOSE_POSITION_SELECTOR,\n] as const;\n\n/**\n * The {@link INSTANT_TRADE_REQUIRED_SELECTORS} counterpart for a **perps-core\n * v0.8.5 chain**, whose open leg is the legacy `sendQuoteWithAffiliateAndData`\n * (the capped `sendQuote` selector does not exist on its diamond).\n */\nexport const LEGACY_INSTANT_TRADE_REQUIRED_SELECTORS = [\n  ADD_MARGIN_TO_NEXT_VA_SELECTOR,\n  SEND_QUOTE_WITH_AFFILIATE_AND_DATA_SELECTOR,\n  REQUEST_TO_CLOSE_POSITION_SELECTOR,\n] as const;\n\n/**\n * Resolve the session-key delegation selector set for a chain by its\n * `contractsVersion`: {@link INSTANT_TRADE_REQUIRED_SELECTORS} on `\"0.8.6\"`,\n * {@link LEGACY_INSTANT_TRADE_REQUIRED_SELECTORS} on `\"0.8.5\"`.\n *\n * Use this (or the `useInstantTradeRequiredSelectors` hook) in any flow that\n * can point at more than one chain — a hardcoded set is wrong on the other\n * generation's chains.\n *\n * @param config - The SDK config.\n * @param parameters - Optional `chainId`; defaults to the config's `defaultChainId`.\n * @returns The selector set matching the chain's contracts generation.\n * @throws {SymmError} `UNSUPPORTED_CHAIN` when the chain is not configured.\n */\nexport function getInstantTradeRequiredSelectors(\n  config: Config,\n  parameters: { chainId?: number } = {},\n): typeof INSTANT_TRADE_REQUIRED_SELECTORS | typeof LEGACY_INSTANT_TRADE_REQUIRED_SELECTORS {\n  return config.getChainConfig(parameters.chainId).contractsVersion === \"0.8.5\"\n    ? LEGACY_INSTANT_TRADE_REQUIRED_SELECTORS\n    : INSTANT_TRADE_REQUIRED_SELECTORS;\n}\n"],"mappings":";;;;AAKA,SAAS,EAAgB,GAAU,GAAmB;CACpD,IAAM,IAAW,EAAI,MAAM,MAAS,EAAK,SAAS,cAAc,EAAK,SAAS,CAAI;CAClF,IAAI,CAAC,GAAU,MAAU,MAAM,4BAA4B,EAAK,cAAc;CAC9E,OAAO,EAAmB,CAAQ;AACpC;AAQA,IAAa,IAAsC,EAAgB,GAAwB,mBAAmB,GAOjG,IAA2B,EAAgB,GAAkB,WAAW,GASxE,IAAmD,EAC9D,GACA,+BACF,GAKa,IAA0C,EAAgB,GAAkB,wBAAwB,GAwBpG,IAAmC;CAC9C;CACA;CACA;AACF,GAOa,IAA0C;CACrD;CACA;CACA;AACF;AAgBA,SAAgB,EACd,GACA,IAAmC,CAAC,GACsD;CAC1F,OAAO,EAAO,eAAe,EAAW,OAAO,EAAE,qBAAqB,UAClE,IACA;AACN"}

package/dist/solvers/instant-open/shared/trade-math.d.ts

@@ -81,8 +81,11 @@ export interface CalculateTradeParamsReturnType {
  *
  * Steps:
  * 1. `requestedOpenPrice = markPrice × (1 ± slippage/100)` trimmed to `pricePrecision`.
- * 2. `quantityBasic = userInput / requestedOpenPrice` (when `inputField === "PRICE"`) or
+ * 2. `quantityBasic = userInput / markPrice` (when `inputField === "PRICE"`) or
  *    `userInput` (when `inputField === "TOKEN"`) trimmed to `quantityPrecision`.
+ *    Sized at the raw mark price, never the slippage-adjusted bound: `V × L` of
+ *    notional at mark `M` is `V × L / M` units on every fill, so changing the
+ *    slippage setting moves only the price bound and never resizes the position.
  * 3. `notionalBasic = quantityBasic × requestedOpenPrice`.
  * 4. `cva / lf / partyAmm / partyBmm = notionalBasic × percent / 100`.
  * 5. `quantity = quantityBasic × leverage` trimmed to `quantityPrecision`.
@@ -91,6 +94,65 @@ export interface CalculateTradeParamsReturnType {
  * @returns `null` when `markPrice` is zero/NaN or `userInput` is invalid.
  */
 export declare function calculateTradeParams(parameters: CalculateTradeParamsParameters): CalculateTradeParamsReturnType | null;
+/**
+ * Solver fees charged on the position, funded from the VA at open.
+ */
+export interface SolverFees {
+    /** `hedgerFeeOpen × notional`, decimal string. */
+    openSolverFee: string;
+    /**
+     * Close fee provisioned at open, decimal string. The solver charges more to
+     * close a freshly opened position, so — since the holding time is unknown at
+     * open — this provisions the **worst case**: `hedgerFeeCloseEarlyRate ×
+     * notional` when the early-rate field is supplied, else the flat
+     * `hedgerFeeClose × notional`.
+     */
+    closeSolverFee: string;
+}
+/**
+ * Compute the solver's open and close fees on the leveraged notional.
+ *
+ * The solver charges its fees from the **VA balance**, so both legs must ride
+ * the `addMargin` transfer from the SubAccount into the VA. The open leg is
+ * `hedgerFeeOpen × notional`. The close leg is provisioned for the **worst
+ * case**, because the holding time is unknown at open and an early close costs
+ * more: when `hedgerFeeCloseEarlyRate` is supplied it uses the peak rate (the
+ * rate at holding time 0); without it it falls back to the flat
+ * `hedgerFeeClose`. An absent, NaN, or negative rate contributes `"0"`.
+ */
+export declare function calculateSolverFees({ notional, hedgerFeeOpen, hedgerFeeClose, hedgerFeeCloseEarlyRate, hedgerFeeCloseEarlyThreshold, hedgerFeeCloseStandardThreshold, }: {
+    /** Leveraged notional (decimal string). */
+    notional: string;
+    /** Solver open-fee rate as a decimal fraction string (e.g. `"0.0004"`). */
+    hedgerFeeOpen: string | undefined;
+    /** Solver standard close-fee rate as a decimal fraction string. Used when no early rate is given. */
+    hedgerFeeClose: string | undefined;
+    /** Early (peak) close-fee rate; when given, the close leg provisions this worst-case rate. */
+    hedgerFeeCloseEarlyRate?: string;
+    /** Early-window length in seconds (paired with `hedgerFeeCloseEarlyRate`). */
+    hedgerFeeCloseEarlyThreshold?: number;
+    /** Standard-rate threshold in seconds (paired with `hedgerFeeCloseEarlyRate`). */
+    hedgerFeeCloseStandardThreshold?: number;
+}): SolverFees;
+/**
+ * Expected settlement loss charged from the VA when the fill lands away from
+ * the mark price the order was sized at.
+ *
+ * Side-aware: a LONG loses when the expected fill is **above** mark
+ * (`(expectedFillPrice − markPrice) × quantity`), a SHORT when it is **below**
+ * (`(markPrice − expectedFillPrice) × quantity`). Clamped at zero — a
+ * favorable expected fill never shrinks the transfer. Returns `"0"` when no
+ * usable estimate exists.
+ */
+export declare function calculateExpectedSettlementLoss({ positionType, markPrice, expectedFillPrice, quantity, }: {
+    positionType: PositionType;
+    /** Mark price the order was sized at (decimal string). */
+    markPrice: string;
+    /** Solver's estimated fill price (decimal string), when available. */
+    expectedFillPrice: string | undefined;
+    /** Leveraged order quantity (decimal string). */
+    quantity: string;
+}): string;
 /**
  * Parameters for {@link calculateMargin}.
  */
@@ -115,13 +177,38 @@ export interface CalculateMarginParameters {
     partyAmmPercent?: string;
     /** On-chain platform fee as decimal string (from {@link computePlatformFee}). */
     platformFee: string;
+    /** Solver open fee funded from the VA (from {@link calculateSolverFees}). Defaults to `"0"`. */
+    openSolverFee?: string;
+    /** Solver close fee provisioned at open (from {@link calculateSolverFees}). Defaults to `"0"`. */
+    closeSolverFee?: string;
+    /** Expected settlement loss vs the estimated fill (from {@link calculateExpectedSettlementLoss}). Defaults to `"0"`. */
+    expectedSettlementLoss?: string;
+    /**
+     * Extra funding headroom percent applied to a SHORT's margin basis
+     * (`markPrice × (1 + percent/100)`). A SHORT's `requestedOpenPrice` is a
+     * contract FLOOR — a fill above it rescales the signed locks up, so the
+     * prefund needs headroom the signed values do not carry. Defaults to `0`;
+     * the lowcap open flow passes {@link SHORT_FUNDING_BUFFER_PERCENT}.
+     */
+    shortFundingBufferPercent?: number;
 }
+/**
+ * Funding headroom percent the lowcap open flow applies to a SHORT's margin
+ * basis (see {@link CalculateMarginParameters.shortFundingBufferPercent}).
+ */
+export declare const SHORT_FUNDING_BUFFER_PERCENT = 1;
 /**
  * Compute the `addMargin` amount for lowcap isolation.
  *
- * - **LONG**: `margin = cva + lf + partyAmm + platformFee`.
- * - **SHORT**: recompute the locked values at `markPrice`,
- *   then sum + `platformFee`.
+ * - **LONG**: `margin = cva + lf + partyAmm + fees`.
+ * - **SHORT**: recompute the locked values at
+ *   `markPrice × (1 + shortFundingBufferPercent/100)`, then sum + fees — the
+ *   buffer covers lock growth when the fill lands above the SHORT's floor.
+ *
+ * `fees = platformFee + openSolverFee + closeSolverFee +
+ * expectedSettlementLoss` — the solver charges its fees and the open-price
+ * settlement from the **VA balance**, so every leg must ride this SubAccount →
+ * VA transfer or the position opens underfunded.
  *
  * @returns Margin as decimal string.
  */
@@ -146,6 +233,23 @@ export interface ComputePlatformFeeRates {
  * @returns Total fee as decimal string.
  */
 export declare function computePlatformFee(rates: ComputePlatformFeeRates, initialNotional: string, closeNotional: string): string;
+/**
+ * The two platform-fee legs, separated. Their sum equals
+ * {@link computePlatformFee} for the same inputs.
+ */
+export interface PlatformFeeLegs {
+    /** `openFee × openNotional / 1e18`, decimal string. */
+    platformOpenFee: string;
+    /** `closeFee × closeNotional / 1e18`, decimal string — provisioned at open. */
+    platformCloseFee: string;
+}
+/**
+ * Compute the platform open and close fee legs separately.
+ *
+ * Same math as {@link computePlatformFee}, split per leg for fee-breakdown
+ * displays. Rates come from on-chain `getFeeForUser` (18-decimal fixed-point).
+ */
+export declare function computePlatformFeeLegs(rates: ComputePlatformFeeRates, openNotional: string, closeNotional: string): PlatformFeeLegs;
 /**
  * Convert a decimal string to an 18-decimal-fixed-point `bigint`.
  *
@@ -182,10 +286,10 @@ export interface CalculateAvailableInstantOpenMarginParameters {
  *           × max(0, 1 − leverage × (openFee + closeFee))
  * ```
  *
- * A SHORT sizes quantity off `requestOpenPrice = markPrice × (1 − s)` (below
- * mark), so a worse fill inflates notional by up to `1 / (1 − s)`; capping usable
- * balance at `balance × (1 − s)` covers it. A LONG sets the request above mark,
- * so fills deflate notional and need no cap.
+ * A SHORT's `requestOpenPrice = markPrice × (1 − s)` is a contract FLOOR: a fill
+ * above it rescales the signed locks by up to `1 / (1 − s)`, so capping usable
+ * balance at `balance × (1 − s)` covers that growth. A LONG's request price is a
+ * ceiling, so fills can only shrink the locks and need no cap.
  *
  * @returns spendable margin in 18-decimal wei.
  * @example

package/dist/solvers/instant-open/shared/trade-math.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trade-math.d.ts","sourceRoot":"","sources":["../../../../src/solvers/instant-open/shared/trade-math.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"trade-math.d.ts","sourceRoot":"","sources":["../../../../src/solvers/instant-open/shared/trade-math.ts"],"names":[],"mappings":"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"}

package/dist/solvers/instant-open/shared/trade-math.js

@@ -1,50 +1,84 @@
 import { PositionType as e } from "../../../symmio-contracts/symmio/types.js";
-import { RoundingMode as t, parseEther as n, toDecimal as r } from "@symmio/utils/decimal";
+import { calculateSolverCloseFee as t } from "../../shared/solver-close-fee.js";
+import { RoundingMode as n, parseEther as r, toDecimal as i } from "@symmio/utils/decimal";
 //#region src/solvers/instant-open/shared/trade-math.ts
-var i = 300n;
-function a(e) {
-	return (e ?? BigInt(Math.floor(Date.now() / 1e3))) + i;
+var a = 300n;
+function o(e) {
+	return (e ?? BigInt(Math.floor(Date.now() / 1e3))) + a;
 }
-var o = 900n;
-function s(e) {
-	return (e ?? BigInt(Math.floor(Date.now() / 1e3))) + o;
+var s = 900n;
+function c(e) {
+	return (e ?? BigInt(Math.floor(Date.now() / 1e3))) + s;
 }
-function c(n) {
-	let { markPrice: i, slippage: a, positionType: o, userInput: s, inputField: c, leverage: l, pricePrecision: u, quantityPrecision: d, cvaPercent: f, lfPercent: p, partyAmmPercent: m, partyBmmPercent: h } = n, g = r(i);
+function l(t) {
+	let { markPrice: r, slippage: a, positionType: o, userInput: s, inputField: c, leverage: l, pricePrecision: u, quantityPrecision: d, cvaPercent: f, lfPercent: p, partyAmmPercent: m, partyBmmPercent: h } = t, g = i(r);
 	if (g.isZero() || g.isNaN()) return null;
-	let _ = r(s);
+	let _ = i(s);
 	if (_.isZero() || _.isNaN()) return null;
-	let v = r(100 - (o === e.SHORT ? a : -a)).div(100), y = g.times(v).toFixed(u, t.ROUND_DOWN), b = c === "PRICE" ? _.div(y).toFixed(d, t.ROUND_DOWN) : _.toFixed(d, t.ROUND_DOWN), x = r(b).times(y).toString(), S = r(x).times(r(f)).div(100).toString(), C = r(x).times(r(p)).div(100).toString(), w = r(x).times(r(m)).div(100).toString(), T = r(x).times(r(h)).div(100).toString();
+	let v = i(100 - (o === e.SHORT ? a : -a)).div(100), y = g.times(v).toFixed(u, n.ROUND_DOWN), b = c === "PRICE" ? _.div(g).toFixed(d, n.ROUND_DOWN) : _.toFixed(d, n.ROUND_DOWN), x = i(b).times(y).toString(), S = i(x).times(i(f)).div(100).toString(), C = i(x).times(i(p)).div(100).toString(), w = i(x).times(i(m)).div(100).toString(), T = i(x).times(i(h)).div(100).toString();
 	return {
 		requestedOpenPrice: y,
 		quantityBasic: b,
-		quantity: r(b).times(l).toFixed(d, t.ROUND_DOWN),
+		quantity: i(b).times(l).toFixed(d, n.ROUND_DOWN),
 		notionalBasic: x,
-		notional: r(x).times(l).toString(),
+		notional: i(x).times(l).toString(),
 		cva: S,
 		lf: C,
 		partyAmm: w,
 		partyBmm: T
 	};
 }
-function l(t) {
-	let { positionType: n, markPrice: i, quantityBasic: a, cva: o, lf: s, partyAmm: c, cvaPercent: l, lfPercent: u, partyAmmPercent: d, platformFee: f } = t;
-	if (n === e.LONG) return r(o).plus(s).plus(c).plus(f).toString();
-	let p = r(i), m = r(a).times(p).toString(), h = r(m).times(r(l)).div(100).toString(), g = r(m).times(r(u)).div(100).toString(), _ = r(m).times(r(d)).div(100).toString();
-	return r(h).plus(g).plus(_).plus(f).toString();
+function u({ notional: e, hedgerFeeOpen: n, hedgerFeeClose: r, hedgerFeeCloseEarlyRate: a, hedgerFeeCloseEarlyThreshold: o, hedgerFeeCloseStandardThreshold: s }) {
+	let c = i(e), l = (e) => {
+		let t = i(e);
+		return t.isNaN() || t.isNegative() || c.isNaN() ? "0" : c.times(t).toString();
+	}, u = a === void 0 ? l(r) : t({
+		hedgerFeeClose: r ?? "0",
+		hedgerFeeCloseEarlyRate: a,
+		hedgerFeeCloseEarlyThreshold: o ?? 0,
+		hedgerFeeCloseStandardThreshold: s ?? 0
+	}, {
+		notional: e,
+		holdingSeconds: 0
+	});
+	return {
+		openSolverFee: l(n),
+		closeSolverFee: u
+	};
+}
+function d({ positionType: t, markPrice: n, expectedFillPrice: r, quantity: a }) {
+	if (r === void 0) return "0";
+	let o = i(n), s = i(r), c = i(a);
+	if (o.isNaN() || s.isNaN() || s.isZero() || c.isNaN()) return "0";
+	let l = t === e.SHORT ? o.minus(s).times(c) : s.minus(o).times(c);
+	return l.isNegative() || l.isNaN() ? "0" : l.toString();
 }
-function u(e, t, n) {
-	let i = r(e.openFee.toString()).times(t), a = r(e.closeFee.toString()).times(n);
-	return i.plus(a).div(r("1e18")).toString();
+var f = 1;
+function p(t) {
+	let { positionType: n, markPrice: r, quantityBasic: a, cva: o, lf: s, partyAmm: c, cvaPercent: l, lfPercent: u, partyAmmPercent: d, platformFee: f, openSolverFee: p = "0", closeSolverFee: m = "0", expectedSettlementLoss: h = "0", shortFundingBufferPercent: g = 0 } = t, _ = i(f).plus(p).plus(m).plus(h);
+	if (n === e.LONG) return i(o).plus(s).plus(c).plus(_).toString();
+	let v = i(r).times(i(100 + g).div(100)), y = i(a).times(v).toString(), b = i(y).times(i(l)).div(100).toString(), x = i(y).times(i(u)).div(100).toString(), S = i(y).times(i(d)).div(100).toString();
+	return i(b).plus(x).plus(S).plus(_).toString();
+}
+function m(e, t, n) {
+	let r = i(e.openFee.toString()).times(t), a = i(e.closeFee.toString()).times(n);
+	return r.plus(a).div(i("1e18")).toString();
+}
+function h(e, t, n) {
+	let r = i("1e18");
+	return {
+		platformOpenFee: i(e.openFee.toString()).times(t).div(r).toString(),
+		platformCloseFee: i(e.closeFee.toString()).times(n).div(r).toString()
+	};
 }
-function d(e) {
-	return BigInt(n(e).toFixed(0, t.ROUND_DOWN));
+function g(e) {
+	return BigInt(r(e).toFixed(0, n.ROUND_DOWN));
 }
-function f(t) {
+function _(t) {
 	let { balance: n, openFee: r, closeFee: i, slippageFractionWei: a, leverage: o, positionType: s } = t, c = 10n ** 18n, l = s === e.SHORT ? a >= c ? 0n : c - a : c, u = BigInt(o) * (r + i), d = u >= c ? 0n : c - u;
 	return n * l / c * d / c;
 }
 //#endregion
-export { i as MARKET_ORDER_DEADLINE_SECONDS, f as calculateAvailableInstantOpenMargin, l as calculateMargin, c as calculateTradeParams, u as computePlatformFee, s as getLimitOrderDeadline, a as getMarketOrderDeadline, d as toWeiBigInt };
+export { a as MARKET_ORDER_DEADLINE_SECONDS, f as SHORT_FUNDING_BUFFER_PERCENT, _ as calculateAvailableInstantOpenMargin, d as calculateExpectedSettlementLoss, p as calculateMargin, u as calculateSolverFees, l as calculateTradeParams, m as computePlatformFee, h as computePlatformFeeLegs, c as getLimitOrderDeadline, o as getMarketOrderDeadline, g as toWeiBigInt };
 
 //# sourceMappingURL=trade-math.js.map