@symmio/trading-core 3.1.0 → 3.3.0

package/dist/solvers/instant-open/get-instant-open-fees/get-instant-open-fees.d.ts

@@ -2,21 +2,20 @@ import { Address } from 'viem';
 import { Config } from '../../../core/config/index.js';
 import { Compute, ReadSolverParameter } from '../../../shared/types/properties.js';
 import { FeeForUser } from '../../../symmio-contracts/symmio/actions/get-fee-for-user.js';
+import { EnigmaSolverInfo } from '../../get-solver-info/index.js';
+import { ApiLockedParamsBySymbolIdResponse } from '../../types/generated/enigma-solver.js';
+import { FullBalanceFunding } from '../prepare-instant-open-params/index.js';
 import { InstantOpenMarketData, PositionType } from '../shared/types.js';
 /**
- * Parameters for {@link getInstantOpenFees}. A subset of
- * `PrepareInstantOpenParameters` — the trade intent plus optional pre-fetched
- * data; every pre-filled optional field skips its network fetch.
+ * Fields shared by every {@link GetInstantOpenFeesParameters} funding mode.
  */
-export type GetInstantOpenFeesParameters = Compute<ReadSolverParameter & {
+type BaseGetInstantOpenFeesParameters = ReadSolverParameter & {
     /** Sub-account / partyA address the platform fee rates are read for. */
     subAccountAddress: Address;
     /** Market identification + optional pre-fetched precision metadata. */
     market: InstantOpenMarketData;
     /** Trade side. */
     positionType: PositionType;
-    /** Collateral (USD) the user enters as initial margin. Decimal string. */
-    initialMargin: string;
     /** Position leverage (integer ≥ 1). */
     leverage: number;
     /**
@@ -27,6 +26,13 @@ export type GetInstantOpenFeesParameters = Compute<ReadSolverParameter & {
      * actually charge.
      */
     slippage?: number;
+    /**
+     * Whether `totalFee` includes the `expectedSettlementLoss` provision.
+     * Defaults to `true` — the provision is part of what the open funds, even
+     * though it is a provision rather than a fee the solver keeps. Pass `false`
+     * to report fee legs only; the provision stays available as its own field.
+     */
+    includeSettlementInTotalFee?: boolean;
     /** Pre-fetched mark price as decimal string. When omitted, fetched via the price service. */
     markPrice?: string;
     /** Pre-fetched on-chain fee rates (matches `getFeeForUser` return). When omitted, fetched. */
@@ -34,50 +40,105 @@ export type GetInstantOpenFeesParameters = Compute<ReadSolverParameter & {
     /**
      * Pre-fetched solver estimated open (fill) price as decimal string —
      * **lowcap/Enigma only**; ignored on any other solver kind. When omitted
-     * on a lowcap solver, fetched via `GET /estimated-price`.
+     * on a lowcap solver, fetched via `GET /estimated-price`. Pass `null` when
+     * an estimate was attempted but unavailable to skip fetching and use the fallback.
+     */
+    estimatedOpenPrice?: string | null;
+    /**
+     * Pre-fetched solver locked params (matches `getLockedParams` return).
+     * Consulted for explicit or automatic full-balance sizing, which needs the
+     * locked-param percents; when omitted there, fetched via `getLockedParams`.
      */
-    estimatedOpenPrice?: string;
+    lockedParamPercent?: ApiLockedParamsBySymbolIdResponse;
+    /**
+     * Pre-fetched solver static fees (matches `getSolverInfo` return) —
+     * **lowcap/Enigma only**; ignored on any other solver kind. When omitted on
+     * a lowcap solver, fetched via `getSolverInfo` (fail-soft: an unreachable
+     * `/info` prices the static open leg at `"0"`).
+     */
+    solverInfo?: EnigmaSolverInfo;
+};
+/**
+ * Parameters for {@link getInstantOpenFees}. A subset of
+ * `PrepareInstantOpenParameters` — the trade intent plus optional pre-fetched
+ * data; every pre-filled optional field skips its network fetch.
+ *
+ * The funding source mirrors `prepareInstantOpenParams`: pass a typed
+ * `initialMargin`, **or** `fund` ({@link FullBalanceFunding}, lowcap only) to
+ * preview a full-balance open — the preview then runs the same
+ * probe-and-rescale sizing as the open, so its legs and `quantity` equal what
+ * the open charges. Provide exactly one; passing both, or neither, throws.
+ * With `initialMargin`, `availableBalance` opts into automatic full-balance sizing
+ * only when the typed position's required funding exceeds the raw balance.
+ * The typed initialMargin itself must not exceed availableBalance.
+ */
+export type GetInstantOpenFeesParameters = Compute<BaseGetInstantOpenFeesParameters & {
+    /** Collateral (USD) the user enters as initial margin. Decimal string. Provide this **or** `fund`. */
+    initialMargin?: string;
+    /**
+     * Raw available collateral (USD decimal string). With initialMargin, previews the
+     * same automatic full-balance fallback as prepareInstantOpenParams. Lowcap only;
+     * must be positive and finite. initialMargin above this balance throws. Cannot accompany fund.
+     */
+    availableBalance?: string;
+    /**
+     * Preview a full-balance open — lowcap (Enigma) only. Provide this **or**
+     * `initialMargin`. See {@link FullBalanceFunding}.
+     */
+    fund?: FullBalanceFunding;
 }>;
 /**
- * Fee legs every solver kind charges on an instant open.
+ * Fee legs every solver kind charges **at open**. Close fees are charged at
+ * close from the position — preview them in the close flow with
+ * `getInstantCloseFees`, where the notional and holding time are real.
  */
 export interface BaseInstantOpenFees {
+    /** Effective sizing mode, including automatic fallback from a typed initial margin. */
+    fundingMode: "initial-margin" | "full-balance";
     /** Platform open fee: `getFeeForUser.openFee × notional / 1e18` (decimal string). */
     platformOpenFee: string;
-    /** Platform close fee, provisioned at open: `getFeeForUser.closeFee × notional / 1e18` (decimal string). */
-    platformCloseFee: string;
     /** Leveraged notional the fee rates were applied to (decimal string). */
     notional: string;
-    /** Sum of every fee leg on this quote (decimal string). */
+    /**
+     * Leveraged base-asset quantity the legs were computed on (decimal string) —
+     * in full-balance mode this is the rescaled, lot-snapped size the open will
+     * actually submit. Feed this to TP/SL and constraint previews instead of
+     * re-deriving from the typed margin.
+     */
+    quantity: string;
+    /**
+     * Sum of every leg the open charges now (decimal string). Includes the
+     * settlement provision by default; pass `includeSettlementInTotalFee: false`
+     * to sum the fee legs only.
+     */
     totalFee: string;
 }
 /**
  * Fee breakdown for a **lowcap (Enigma)** instant open. Extends the platform
- * legs with the solver fees and the settlement provision the solver charges
- * from the VA balance.
+ * leg with the solver open legs and the settlement provision the solver
+ * charges from the VA balance.
  */
 export interface EnigmaInstantOpenFees extends BaseInstantOpenFees {
     /** Discriminant: these fees were priced for an Enigma (lowcap) solver. */
     kind: "enigma";
     /** Solver open fee: `hedgerFeeOpen × notional` (decimal string). */
     openSolverFee: string;
-    /**
-     * Solver close fee provisioned at open (decimal string). Because the holding
-     * time is unknown at open and an early close costs more, this is the
-     * worst-case `earlyRate × notional` from the market's close-fee schedule
-     * (falling back to the flat `hedgerFeeClose × notional` when no schedule is
-     * available).
-     */
-    closeSolverFee: string;
     /**
      * Expected settlement loss vs the dry-run estimate: side-aware
      * `max(0, adverse fill deviation × quantity)` (decimal string). `"0"` when
      * no usable estimate exists.
      */
     expectedSettlementLoss: string;
+    /**
+     * Static solver fee charged per instant open — a flat USD amount from the
+     * solver's `/info` config, independent of the notional (decimal string).
+     * `"0"` when the solver publishes none.
+     */
+    staticSolverFeeOpen: string;
 }
 /**
- * Fee breakdown for a **majors (Rasa)** instant open — platform legs only.
+ * Fee breakdown for a **majors (Rasa)** instant open — the platform open leg
+ * only.
  */
 export interface RasaInstantOpenFees extends BaseInstantOpenFees {
     /** Discriminant: these fees were priced for a Rasa (majors) solver. */
@@ -89,25 +150,39 @@ export interface RasaInstantOpenFees extends BaseInstantOpenFees {
  */
 export type GetInstantOpenFeesReturnType = EnigmaInstantOpenFees | RasaInstantOpenFees;
 /**
- * Preview every fee a new instant-open quote pays, separated by leg plus the
- * total — without signing or submitting anything.
+ * Preview every fee a new instant-open quote pays **at open**, separated by leg
+ * plus the total — without signing or submitting anything.
  *
  * Mirrors the exact resolution and math `prepareInstantOpenParams` uses, so
  * the preview equals what the open charges for the same inputs:
  *
- * - **Both kinds**: `platformOpenFee` + `platformCloseFee`
- *   (on-chain `getFeeForUser` rates × leveraged notional).
- * - **Lowcap (Enigma) only**: `openSolverFee` (`hedgerFeeOpen × notional`) +
- *   `closeSolverFee` (the worst-case close rate × notional — see
- *   {@link EnigmaInstantOpenFees.closeSolverFee}) and
- *   `expectedSettlementLoss` (dry-run estimate vs mark) — the legs the solver
- *   charges from the VA balance.
+ * - **Both kinds**: `platformOpenFee` (on-chain `getFeeForUser.openFee` ×
+ *   leveraged notional).
+ * - **Lowcap (Enigma) only**: `openSolverFee` (`hedgerFeeOpen × notional`),
+ *   `staticSolverFeeOpen` (flat USD from the solver's `/info` config,
+ *   size-independent) and `expectedSettlementLoss` (dry-run estimate vs mark)
+ *   — the legs the solver charges from the VA balance.
+ *
+ * Close fees (platform close, solver close, static close) are **not** part of
+ * this preview: they are charged at close from the position, priced by
+ * `getInstantCloseFees` in the close flow from the then-current notional and
+ * the position's real holding time.
+ *
+ * `totalFee` sums every open leg. It includes the settlement provision by
+ * default — the amount the user must fund even though the settlement leg is a
+ * provision rather than a fee the solver keeps; pass
+ * `includeSettlementInTotalFee: false` to sum the fee legs only.
  *
- * `totalFee` sums every leg, including the settlement provision — it is the
- * amount the user must fund even though the settlement leg is a provision
- * rather than a fee the solver keeps.
+ * With `fund` ({@link FullBalanceFunding}) instead of `initialMargin`, the
+ * preview runs the same probe-and-rescale sizing as the open — lot snap, cost
+ * invariant, slippage-bound settlement fallback included — so the reported
+ * legs and `quantity` are those of the trade the open will actually submit.
  *
  * @throws {SymmError} `SLIPPAGE_REQUIRED` on majors without `slippage`;
+ *   `AMBIGUOUS_FUNDING` / `INITIAL_MARGIN_REQUIRED` /
+ *   `FULL_BALANCE_UNSUPPORTED` for a broken funding one-of;
+ *   `QUOTE_CONSTRAINT_VIOLATED` when the full-balance sizing violates a
+ *   published market constraint;
  *   `INVALID_SLIPPAGE` / `INVALID_TRADE_PARAMETERS` /
  *   `RESOLVE_MARKET_NOT_FOUND` / `RESOLVE_MARK_PRICE_NOT_FOUND` for invalid or
  *   unresolvable inputs.
@@ -126,4 +201,5 @@ export type GetInstantOpenFeesReturnType = EnigmaInstantOpenFees | RasaInstantOp
  * ```
  */
 export declare function getInstantOpenFees(config: Config, parameters: GetInstantOpenFeesParameters): Promise<GetInstantOpenFeesReturnType>;
+export {};
 //# sourceMappingURL=get-instant-open-fees.d.ts.map

package/dist/solvers/instant-open/get-instant-open-fees/get-instant-open-fees.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-instant-open-fees.d.ts","sourceRoot":"","sources":["../../../../src/solvers/instant-open/get-instant-open-fees/get-instant-open-fees.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,KAAK,EAAE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACrF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2DAA2D,CAAC;AAS5F,OAAO,KAAK,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE3E;;;;GAIG;AACH,MAAM,MAAM,4BAA4B,GAAG,OAAO,CAChD,mBAAmB,GAAG;IACpB,wEAAwE;IACxE,iBAAiB,EAAE,OAAO,CAAC;IAC3B,uEAAuE;IACvE,MAAM,EAAE,qBAAqB,CAAC;IAC9B,kBAAkB;IAClB,YAAY,EAAE,YAAY,CAAC;IAC3B,0EAA0E;IAC1E,aAAa,EAAE,MAAM,CAAC;IACtB,uCAAuC;IACvC,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,6FAA6F;IAC7F,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,8FAA8F;IAC9F,QAAQ,CAAC,EAAE,UAAU,CAAC;IACtB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B,CACF,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,qFAAqF;IACrF,eAAe,EAAE,MAAM,CAAC;IACxB,4GAA4G;IAC5G,gBAAgB,EAAE,MAAM,CAAC;IACzB,yEAAyE;IACzE,QAAQ,EAAE,MAAM,CAAC;IACjB,2DAA2D;IAC3D,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,WAAW,qBAAsB,SAAQ,mBAAmB;IAChE,0EAA0E;IAC1E,IAAI,EAAE,QAAQ,CAAC;IACf,oEAAoE;IACpE,aAAa,EAAE,MAAM,CAAC;IACtB;;;;;;OAMG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,sBAAsB,EAAE,MAAM,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,mBAAoB,SAAQ,mBAAmB;IAC9D,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,MAAM,MAAM,4BAA4B,GAAG,qBAAqB,GAAG,mBAAmB,CAAC;AAEvF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,4BAA4B,GACvC,OAAO,CAAC,4BAA4B,CAAC,CA8IvC"}
+{"version":3,"file":"get-instant-open-fees.d.ts","sourceRoot":"","sources":["../../../../src/solvers/instant-open/get-instant-open-fees/get-instant-open-fees.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,KAAK,EAAE,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACrF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2DAA2D,CAAC;AAC5F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,qCAAqC,CAAC;AAC7F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAgBzE,OAAO,KAAK,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE3E;;GAEG;AACH,KAAK,gCAAgC,GAAG,mBAAmB,GAAG;IAC5D,wEAAwE;IACxE,iBAAiB,EAAE,OAAO,CAAC;IAC3B,uEAAuE;IACvE,MAAM,EAAE,qBAAqB,CAAC;IAC9B,kBAAkB;IAClB,YAAY,EAAE,YAAY,CAAC;IAC3B,uCAAuC;IACvC,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;OAKG;IACH,2BAA2B,CAAC,EAAE,OAAO,CAAC;IACtC,6FAA6F;IAC7F,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,8FAA8F;IAC9F,QAAQ,CAAC,EAAE,UAAU,CAAC;IACtB;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,iCAAiC,CAAC;IACvD;;;;;OAKG;IACH,UAAU,CAAC,EAAE,gBAAgB,CAAC;CAC/B,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,4BAA4B,GAAG,OAAO,CAChD,gCAAgC,GAAG;IACjC,sGAAsG;IACtG,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;OAGG;IACH,IAAI,CAAC,EAAE,kBAAkB,CAAC;CAC3B,CACF,CAAC;AAEF;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,uFAAuF;IACvF,WAAW,EAAE,gBAAgB,GAAG,cAAc,CAAC;IAC/C,qFAAqF;IACrF,eAAe,EAAE,MAAM,CAAC;IACxB,yEAAyE;IACzE,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,WAAW,qBAAsB,SAAQ,mBAAmB;IAChE,0EAA0E;IAC1E,IAAI,EAAE,QAAQ,CAAC;IACf,oEAAoE;IACpE,aAAa,EAAE,MAAM,CAAC;IACtB;;;;OAIG;IACH,sBAAsB,EAAE,MAAM,CAAC;IAC/B;;;;OAIG;IACH,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAoB,SAAQ,mBAAmB;IAC9D,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,MAAM,MAAM,4BAA4B,GAAG,qBAAqB,GAAG,mBAAmB,CAAC;AAEvF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,4BAA4B,GACvC,OAAO,CAAC,4BAA4B,CAAC,CAwPvC"}

package/dist/solvers/instant-open/get-instant-open-fees/get-instant-open-fees.js

@@ -1,115 +1,192 @@
 import { SymmError as e } from "../../../shared/errors/symm-error.js";
 import { calculateExpectedSettlementLoss as t, calculateSolverFees as n, calculateTradeParams as r, computePlatformFeeLegs as i } from "../shared/trade-math.js";
 import { assertValidSlippage as a, deriveAutoSlippage as o, fetchOpenEstimatePrice as s } from "../shared/open-estimate-guard.js";
-import { resolveMarkPrice as c } from "../../shared/resolvers/resolve-mark-price.js";
-import { resolveMarket as l } from "../../shared/resolvers/resolve-market.js";
-import { resolveFeeRates as u } from "../prepare-instant-open-params/resolvers/resolve-fee-rates.js";
-import { toDecimal as d } from "@symmio/utils/decimal";
+import { resolveInstantOpenSizing as c, validateInstantOpenBalanceFunding as l } from "../shared/resolve-instant-open-sizing.js";
+import { resolveFeeRates as u } from "../../shared/resolvers/resolve-fee-rates.js";
+import { resolveMarkPrice as d } from "../../shared/resolvers/resolve-mark-price.js";
+import { resolveMarket as f } from "../../shared/resolvers/resolve-market.js";
+import { resolveSolverInfo as p } from "../../shared/resolvers/resolve-solver-info.js";
+import { resolveLockedParams as m } from "../prepare-instant-open-params/resolvers/resolve-locked-params.js";
+import { toDecimal as h } from "@symmio/utils/decimal";
 //#region src/solvers/instant-open/get-instant-open-fees/get-instant-open-fees.ts
-async function f(f, p) {
-	p.slippage !== void 0 && a(p.slippage);
-	let m = f.getSolver({
-		chainId: p.chainId,
-		solverId: p.solverId
+async function g(g, _) {
+	_.slippage !== void 0 && a(_.slippage);
+	let v = g.getSolver({
+		chainId: _.chainId,
+		solverId: _.solverId
 	}).id === "enigma";
-	if (p.slippage === void 0 && !m) throw new e("validation", "SLIPPAGE_REQUIRED", "getInstantOpenFees: slippage is required on this solver — auto-derived slippage is lowcap-only.");
-	let h = await l(f, {
-		chainId: p.chainId,
-		solverId: p.solverId,
-		marketId: p.market.id,
-		marketName: p.market.name,
-		pricePrecision: p.market.pricePrecision,
-		quantityPrecision: p.market.quantityPrecision,
-		hedgerFeeOpen: p.market.hedgerFeeOpen,
-		hedgerFeeClose: p.market.hedgerFeeClose,
-		hedgerFeeCloseEarlyRate: p.market.hedgerFeeCloseEarlyRate,
-		hedgerFeeCloseEarlyThreshold: p.market.hedgerFeeCloseEarlyThreshold,
-		hedgerFeeCloseStandardThreshold: p.market.hedgerFeeCloseStandardThreshold,
-		includeHedgerFees: m
-	}), [g, _] = await Promise.all([c(f, {
-		chainId: p.chainId,
-		solverId: p.solverId,
-		marketName: h.name,
-		markPrice: p.markPrice
-	}), u(f, {
-		chainId: p.chainId,
-		subAccountAddress: p.subAccountAddress,
-		marketId: p.market.id,
-		feeRates: p.feeRates
-	})]), v = {
-		markPrice: g,
-		positionType: p.positionType,
-		userInput: p.initialMargin,
+	if (_.slippage === void 0 && !v) throw new e("validation", "SLIPPAGE_REQUIRED", "getInstantOpenFees: slippage is required on this solver — auto-derived slippage is lowcap-only.");
+	let y = _.fund !== void 0;
+	l({
+		..._,
+		isLowcap: v
+	});
+	let b = y || _.availableBalance !== void 0;
+	if (y && _.initialMargin !== void 0) throw new e("validation", "AMBIGUOUS_FUNDING", "getInstantOpenFees: pass exactly one of initialMargin or fund, not both.");
+	if (y && !v) throw new e("validation", "FULL_BALANCE_UNSUPPORTED", "getInstantOpenFees: full-balance funding is lowcap (Enigma) only — pass initialMargin on this solver.");
+	if (!y && _.initialMargin === void 0) throw new e("validation", "INITIAL_MARGIN_REQUIRED", "getInstantOpenFees: pass initialMargin, or fund: { mode: 'full-balance', balance } on a lowcap solver.");
+	let x = y ? _.fund.balance : _.initialMargin, S = _.includeSettlementInTotalFee ?? !0, C = await f(g, {
+		chainId: _.chainId,
+		solverId: _.solverId,
+		marketId: _.market.id,
+		marketName: _.market.name,
+		pricePrecision: _.market.pricePrecision,
+		quantityPrecision: _.market.quantityPrecision,
+		hedgerFeeOpen: _.market.hedgerFeeOpen,
+		hedgerFeeClose: _.market.hedgerFeeClose,
+		hedgerFeeCloseEarlyRate: _.market.hedgerFeeCloseEarlyRate,
+		hedgerFeeCloseEarlyThreshold: _.market.hedgerFeeCloseEarlyThreshold,
+		hedgerFeeCloseStandardThreshold: _.market.hedgerFeeCloseStandardThreshold,
+		includeHedgerFees: v,
+		includeQuoteConstraints: b,
+		minAcceptablePortionLf: _.market.minAcceptablePortionLf,
+		minAcceptableQuoteValue: _.market.minAcceptableQuoteValue,
+		maxNotionalValue: _.market.maxNotionalValue,
+		minNotionalValue: _.market.minNotionalValue,
+		maxQuantity: _.market.maxQuantity,
+		lotSize: _.market.lotSize
+	}), [w, T, E, D] = await Promise.all([
+		d(g, {
+			chainId: _.chainId,
+			solverId: _.solverId,
+			marketName: C.name,
+			markPrice: _.markPrice
+		}),
+		u(g, {
+			chainId: _.chainId,
+			subAccountAddress: _.subAccountAddress,
+			marketId: _.market.id,
+			feeRates: _.feeRates
+		}),
+		b ? m(g, {
+			chainId: _.chainId,
+			solverId: _.solverId,
+			marketName: C.name,
+			leverage: _.leverage,
+			lockedParamPercent: _.lockedParamPercent
+		}) : Promise.resolve(void 0),
+		v ? p(g, {
+			chainId: _.chainId,
+			solverId: _.solverId,
+			solverInfo: _.solverInfo
+		}) : Promise.resolve({
+			staticSolverFeeOpen: "0",
+			staticSolverFeeClose: "0"
+		})
+	]), O = {
+		markPrice: w,
+		positionType: _.positionType,
+		userInput: x,
 		inputField: "PRICE",
-		leverage: p.leverage,
-		pricePrecision: h.pricePrecision,
-		quantityPrecision: h.quantityPrecision
-	}, y = p.slippage, b = m ? p.estimatedOpenPrice : void 0;
-	if (y === void 0) {
+		leverage: _.leverage,
+		pricePrecision: C.pricePrecision,
+		quantityPrecision: C.quantityPrecision,
+		...E ? {
+			cvaPercent: E.cva,
+			lfPercent: E.lf,
+			partyAmmPercent: E.partyAmm,
+			partyBmmPercent: E.partyBmm
+		} : {}
+	}, k = _.slippage, A = v ? _.estimatedOpenPrice ?? void 0 : void 0, j = v && _.estimatedOpenPrice === void 0;
+	if (k === void 0) {
 		let t = r({
-			...v,
+			...O,
 			slippage: 0
 		});
 		if (!t) throw new e("validation", "INVALID_TRADE_PARAMETERS", "Invalid trade parameters: markPrice or initialMargin is zero/NaN.");
-		m && b === void 0 && (b = await s(f, {
-			chainId: p.chainId,
-			solverId: p.solverId,
-			symbolId: p.market.id,
-			positionType: p.positionType,
+		j && (j = !1, A = await s(g, {
+			chainId: _.chainId,
+			solverId: _.solverId,
+			symbolId: _.market.id,
+			positionType: _.positionType,
 			quantity: t.quantity,
-			markPrice: g
-		})), y = o({
-			markPrice: g,
-			expectedFillPrice: b,
-			positionType: p.positionType
+			markPrice: w
+		})), k = o({
+			markPrice: w,
+			expectedFillPrice: A,
+			positionType: _.positionType
 		});
 	}
-	let x = r({
-		...v,
-		slippage: y
+	let M = r({
+		...O,
+		slippage: k
 	});
-	if (!x) throw new e("validation", "INVALID_TRADE_PARAMETERS", "Invalid trade parameters: markPrice or initialMargin is zero/NaN.");
-	m && b === void 0 && (b = await s(f, {
-		chainId: p.chainId,
-		solverId: p.solverId,
-		symbolId: p.market.id,
-		positionType: p.positionType,
-		quantity: x.quantity,
-		markPrice: g
-	}));
-	let { platformOpenFee: S, platformCloseFee: C } = i(_, x.notional, x.notional);
-	if (!m) return {
+	if (!M) throw new e("validation", "INVALID_TRADE_PARAMETERS", "Invalid trade parameters: markPrice or initialMargin is zero/NaN.");
+	if (j && (A = await s(g, {
+		chainId: _.chainId,
+		solverId: _.solverId,
+		symbolId: _.market.id,
+		positionType: _.positionType,
+		quantity: M.quantity,
+		markPrice: w
+	})), b) {
+		let { trade: e, costs: t, fundingMode: n } = c({
+			trade: M,
+			isLowcap: v,
+			fund: _.fund,
+			availableBalance: _.availableBalance,
+			calculationInput: {
+				...O,
+				slippage: k
+			},
+			expectedFillPrice: A === "0" ? void 0 : A,
+			feeRates: T,
+			hedgerFeeOpen: C.hedgerFeeOpen,
+			staticSolverFeeOpen: D.staticSolverFeeOpen,
+			constraints: {
+				minAcceptablePortionLf: C.minAcceptablePortionLf,
+				minAcceptableQuoteValue: C.minAcceptableQuoteValue,
+				maxNotionalValue: C.maxNotionalValue,
+				minNotionalValue: C.minNotionalValue,
+				maxQuantity: C.maxQuantity,
+				lotSize: C.lotSize
+			}
+		});
+		return {
+			fundingMode: n,
+			kind: "enigma",
+			platformOpenFee: t.platformOpenFee,
+			notional: e.notional,
+			quantity: e.quantity,
+			openSolverFee: t.openSolverFee,
+			staticSolverFeeOpen: t.staticSolverFeeOpen,
+			expectedSettlementLoss: t.expectedSettlementLoss,
+			totalFee: h(t.platformOpenFee).plus(t.openSolverFee).plus(t.staticSolverFeeOpen).plus(S ? t.expectedSettlementLoss : "0").toString()
+		};
+	}
+	let { platformOpenFee: N } = i(T, M.notional, M.notional);
+	if (!v) return {
+		fundingMode: "initial-margin",
 		kind: "rasa",
-		platformOpenFee: S,
-		platformCloseFee: C,
-		notional: x.notional,
-		totalFee: d(S).plus(C).toString()
+		platformOpenFee: N,
+		notional: M.notional,
+		quantity: M.quantity,
+		totalFee: N
 	};
-	let { openSolverFee: w, closeSolverFee: T } = n({
-		notional: x.notional,
-		hedgerFeeOpen: h.hedgerFeeOpen,
-		hedgerFeeClose: h.hedgerFeeClose,
-		hedgerFeeCloseEarlyRate: h.hedgerFeeCloseEarlyRate,
-		hedgerFeeCloseEarlyThreshold: h.hedgerFeeCloseEarlyThreshold,
-		hedgerFeeCloseStandardThreshold: h.hedgerFeeCloseStandardThreshold
-	}), E = t({
-		positionType: p.positionType,
-		markPrice: g,
-		expectedFillPrice: b,
-		quantity: x.quantity
+	let { openSolverFee: P, staticSolverFeeOpen: F } = n({
+		notional: M.notional,
+		hedgerFeeOpen: C.hedgerFeeOpen,
+		hedgerFeeClose: void 0,
+		staticSolverFeeOpen: D.staticSolverFeeOpen
+	}), I = t({
+		positionType: _.positionType,
+		markPrice: w,
+		expectedFillPrice: A,
+		quantity: M.quantity
 	});
 	return {
+		fundingMode: "initial-margin",
 		kind: "enigma",
-		platformOpenFee: S,
-		platformCloseFee: C,
-		notional: x.notional,
-		openSolverFee: w,
-		closeSolverFee: T,
-		expectedSettlementLoss: E,
-		totalFee: d(S).plus(C).plus(w).plus(T).plus(E).toString()
+		platformOpenFee: N,
+		notional: M.notional,
+		quantity: M.quantity,
+		openSolverFee: P,
+		staticSolverFeeOpen: F,
+		expectedSettlementLoss: I,
+		totalFee: h(N).plus(P).plus(F).plus(S ? I : "0").toString()
 	};
 }
 //#endregion
-export { f as getInstantOpenFees };
+export { g as getInstantOpenFees };
 
 //# sourceMappingURL=get-instant-open-fees.js.map

package/dist/solvers/instant-open/get-instant-open-fees/get-instant-open-fees.js.map

@@ -1 +1 @@
-{"version":3,"file":"get-instant-open-fees.js","names":[],"sources":["../../../../src/solvers/instant-open/get-instant-open-fees/get-instant-open-fees.ts"],"sourcesContent":["import { toDecimal } from \"@symmio/utils/decimal\";\nimport type { Address } from \"viem\";\nimport type { Config } from \"../../../core/config\";\nimport { SymmError } from \"../../../shared/errors/symm-error\";\nimport type { Compute, ReadSolverParameter } from \"../../../shared/types/properties\";\nimport type { FeeForUser } from \"../../../symmio-contracts/symmio/actions/get-fee-for-user\";\nimport { resolveFeeRates, resolveMarket, resolveMarkPrice } from \"../prepare-instant-open-params/resolvers\";\nimport { assertValidSlippage, deriveAutoSlippage, fetchOpenEstimatePrice } from \"../shared/open-estimate-guard\";\nimport {\n  calculateExpectedSettlementLoss,\n  calculateSolverFees,\n  calculateTradeParams,\n  computePlatformFeeLegs,\n} from \"../shared/trade-math\";\nimport type { InstantOpenMarketData, PositionType } from \"../shared/types\";\n\n/**\n * Parameters for {@link getInstantOpenFees}. A subset of\n * `PrepareInstantOpenParameters` — the trade intent plus optional pre-fetched\n * data; every pre-filled optional field skips its network fetch.\n */\nexport type GetInstantOpenFeesParameters = Compute<\n  ReadSolverParameter & {\n    /** Sub-account / partyA address the platform fee rates are read for. */\n    subAccountAddress: Address;\n    /** Market identification + optional pre-fetched precision metadata. */\n    market: InstantOpenMarketData;\n    /** Trade side. */\n    positionType: PositionType;\n    /** Collateral (USD) the user enters as initial margin. Decimal string. */\n    initialMargin: string;\n    /** Position leverage (integer ≥ 1). */\n    leverage: number;\n    /**\n     * Slippage tolerance percent (e.g. `5` for 5%). **Required on majors\n     * (non-lowcap) solvers.** On a lowcap solver it may be omitted to\n     * auto-derive from the dry-run estimate plus 4% headroom — the same rule\n     * as `prepareInstantOpenParams`, so the preview prices what the open will\n     * actually charge.\n     */\n    slippage?: number;\n    /** Pre-fetched mark price as decimal string. When omitted, fetched via the price service. */\n    markPrice?: string;\n    /** Pre-fetched on-chain fee rates (matches `getFeeForUser` return). When omitted, fetched. */\n    feeRates?: FeeForUser;\n    /**\n     * Pre-fetched solver estimated open (fill) price as decimal string —\n     * **lowcap/Enigma only**; ignored on any other solver kind. When omitted\n     * on a lowcap solver, fetched via `GET /estimated-price`.\n     */\n    estimatedOpenPrice?: string;\n  }\n>;\n\n/**\n * Fee legs every solver kind charges on an instant open.\n */\nexport interface BaseInstantOpenFees {\n  /** Platform open fee: `getFeeForUser.openFee × notional / 1e18` (decimal string). */\n  platformOpenFee: string;\n  /** Platform close fee, provisioned at open: `getFeeForUser.closeFee × notional / 1e18` (decimal string). */\n  platformCloseFee: string;\n  /** Leveraged notional the fee rates were applied to (decimal string). */\n  notional: string;\n  /** Sum of every fee leg on this quote (decimal string). */\n  totalFee: string;\n}\n\n/**\n * Fee breakdown for a **lowcap (Enigma)** instant open. Extends the platform\n * legs with the solver fees and the settlement provision the solver charges\n * from the VA balance.\n */\nexport interface EnigmaInstantOpenFees extends BaseInstantOpenFees {\n  /** Discriminant: these fees were priced for an Enigma (lowcap) solver. */\n  kind: \"enigma\";\n  /** Solver open fee: `hedgerFeeOpen × notional` (decimal string). */\n  openSolverFee: string;\n  /**\n   * Solver close fee provisioned at open (decimal string). Because the holding\n   * time is unknown at open and an early close costs more, this is the\n   * worst-case `earlyRate × notional` from the market's close-fee schedule\n   * (falling back to the flat `hedgerFeeClose × notional` when no schedule is\n   * available).\n   */\n  closeSolverFee: string;\n  /**\n   * Expected settlement loss vs the dry-run estimate: side-aware\n   * `max(0, adverse fill deviation × quantity)` (decimal string). `\"0\"` when\n   * no usable estimate exists.\n   */\n  expectedSettlementLoss: string;\n}\n\n/**\n * Fee breakdown for a **majors (Rasa)** instant open — platform legs only.\n */\nexport interface RasaInstantOpenFees extends BaseInstantOpenFees {\n  /** Discriminant: these fees were priced for a Rasa (majors) solver. */\n  kind: \"rasa\";\n}\n\n/**\n * Return type of {@link getInstantOpenFees}. Narrow on `kind` to reach the\n * lowcap-only legs.\n */\nexport type GetInstantOpenFeesReturnType = EnigmaInstantOpenFees | RasaInstantOpenFees;\n\n/**\n * Preview every fee a new instant-open quote pays, separated by leg plus the\n * total — without signing or submitting anything.\n *\n * Mirrors the exact resolution and math `prepareInstantOpenParams` uses, so\n * the preview equals what the open charges for the same inputs:\n *\n * - **Both kinds**: `platformOpenFee` + `platformCloseFee`\n *   (on-chain `getFeeForUser` rates × leveraged notional).\n * - **Lowcap (Enigma) only**: `openSolverFee` (`hedgerFeeOpen × notional`) +\n *   `closeSolverFee` (the worst-case close rate × notional — see\n *   {@link EnigmaInstantOpenFees.closeSolverFee}) and\n *   `expectedSettlementLoss` (dry-run estimate vs mark) — the legs the solver\n *   charges from the VA balance.\n *\n * `totalFee` sums every leg, including the settlement provision — it is the\n * amount the user must fund even though the settlement leg is a provision\n * rather than a fee the solver keeps.\n *\n * @throws {SymmError} `SLIPPAGE_REQUIRED` on majors without `slippage`;\n *   `INVALID_SLIPPAGE` / `INVALID_TRADE_PARAMETERS` /\n *   `RESOLVE_MARKET_NOT_FOUND` / `RESOLVE_MARK_PRICE_NOT_FOUND` for invalid or\n *   unresolvable inputs.\n *\n * @example\n * ```ts\n * const fees = await getInstantOpenFees(config, {\n *   subAccountAddress,\n *   market: { id: 1 },\n *   positionType: PositionType.LONG,\n *   initialMargin: \"100\",\n *   leverage: 5,\n * });\n * if (fees.kind === \"enigma\") console.log(fees.openSolverFee, fees.expectedSettlementLoss);\n * console.log(fees.totalFee);\n * ```\n */\nexport async function getInstantOpenFees(\n  config: Config,\n  parameters: GetInstantOpenFeesParameters,\n): Promise<GetInstantOpenFeesReturnType> {\n  if (parameters.slippage !== undefined) assertValidSlippage(parameters.slippage);\n\n  /** Estimate-driven legs exist only on lowcap (Enigma) solvers — a majors preview is platform legs only. */\n  const isLowcap = config.getSolver({ chainId: parameters.chainId, solverId: parameters.solverId }).id === \"enigma\";\n  if (parameters.slippage === undefined && !isLowcap) {\n    throw new SymmError(\n      \"validation\",\n      \"SLIPPAGE_REQUIRED\",\n      \"getInstantOpenFees: slippage is required on this solver — auto-derived slippage is lowcap-only.\",\n    );\n  }\n\n  const market = await resolveMarket(config, {\n    chainId: parameters.chainId,\n    solverId: parameters.solverId,\n    marketId: parameters.market.id,\n    marketName: parameters.market.name,\n    pricePrecision: parameters.market.pricePrecision,\n    quantityPrecision: parameters.market.quantityPrecision,\n    hedgerFeeOpen: parameters.market.hedgerFeeOpen,\n    hedgerFeeClose: parameters.market.hedgerFeeClose,\n    hedgerFeeCloseEarlyRate: parameters.market.hedgerFeeCloseEarlyRate,\n    hedgerFeeCloseEarlyThreshold: parameters.market.hedgerFeeCloseEarlyThreshold,\n    hedgerFeeCloseStandardThreshold: parameters.market.hedgerFeeCloseStandardThreshold,\n    includeHedgerFees: isLowcap,\n  });\n  const [markPrice, feeRates] = await Promise.all([\n    resolveMarkPrice(config, {\n      chainId: parameters.chainId,\n      solverId: parameters.solverId,\n      marketName: market.name,\n      markPrice: parameters.markPrice,\n    }),\n    resolveFeeRates(config, {\n      chainId: parameters.chainId,\n      subAccountAddress: parameters.subAccountAddress,\n      marketId: parameters.market.id,\n      feeRates: parameters.feeRates,\n    }),\n  ]);\n\n  const calculationInput = {\n    markPrice,\n    positionType: parameters.positionType,\n    userInput: parameters.initialMargin,\n    inputField: \"PRICE\" as const,\n    leverage: parameters.leverage,\n    pricePrecision: market.pricePrecision,\n    quantityPrecision: market.quantityPrecision,\n  };\n\n  let slippage = parameters.slippage;\n  let expectedFillPrice = isLowcap ? parameters.estimatedOpenPrice : undefined;\n  if (slippage === undefined) {\n    const sized = calculateTradeParams({ ...calculationInput, slippage: 0 });\n    if (!sized) {\n      throw new SymmError(\n        \"validation\",\n        \"INVALID_TRADE_PARAMETERS\",\n        \"Invalid trade parameters: markPrice or initialMargin is zero/NaN.\",\n      );\n    }\n    if (isLowcap && expectedFillPrice === undefined) {\n      expectedFillPrice = await fetchOpenEstimatePrice(config, {\n        chainId: parameters.chainId,\n        solverId: parameters.solverId,\n        symbolId: parameters.market.id,\n        positionType: parameters.positionType,\n        quantity: sized.quantity,\n        markPrice,\n      });\n    }\n    slippage = deriveAutoSlippage({ markPrice, expectedFillPrice, positionType: parameters.positionType });\n  }\n\n  const tradeCalc = calculateTradeParams({ ...calculationInput, slippage });\n  if (!tradeCalc) {\n    throw new SymmError(\n      \"validation\",\n      \"INVALID_TRADE_PARAMETERS\",\n      \"Invalid trade parameters: markPrice or initialMargin is zero/NaN.\",\n    );\n  }\n\n  if (isLowcap && expectedFillPrice === undefined) {\n    expectedFillPrice = await fetchOpenEstimatePrice(config, {\n      chainId: parameters.chainId,\n      solverId: parameters.solverId,\n      symbolId: parameters.market.id,\n      positionType: parameters.positionType,\n      quantity: tradeCalc.quantity,\n      markPrice,\n    });\n  }\n\n  const { platformOpenFee, platformCloseFee } = computePlatformFeeLegs(\n    feeRates,\n    tradeCalc.notional,\n    tradeCalc.notional,\n  );\n\n  if (!isLowcap) {\n    return {\n      kind: \"rasa\",\n      platformOpenFee,\n      platformCloseFee,\n      notional: tradeCalc.notional,\n      totalFee: toDecimal(platformOpenFee).plus(platformCloseFee).toString(),\n    };\n  }\n\n  const { openSolverFee, closeSolverFee } = calculateSolverFees({\n    notional: tradeCalc.notional,\n    hedgerFeeOpen: market.hedgerFeeOpen,\n    hedgerFeeClose: market.hedgerFeeClose,\n    hedgerFeeCloseEarlyRate: market.hedgerFeeCloseEarlyRate,\n    hedgerFeeCloseEarlyThreshold: market.hedgerFeeCloseEarlyThreshold,\n    hedgerFeeCloseStandardThreshold: market.hedgerFeeCloseStandardThreshold,\n  });\n  const expectedSettlementLoss = calculateExpectedSettlementLoss({\n    positionType: parameters.positionType,\n    markPrice,\n    expectedFillPrice,\n    quantity: tradeCalc.quantity,\n  });\n\n  return {\n    kind: \"enigma\",\n    platformOpenFee,\n    platformCloseFee,\n    notional: tradeCalc.notional,\n    openSolverFee,\n    closeSolverFee,\n    expectedSettlementLoss,\n    totalFee: toDecimal(platformOpenFee)\n      .plus(platformCloseFee)\n      .plus(openSolverFee)\n      .plus(closeSolverFee)\n      .plus(expectedSettlementLoss)\n      .toString(),\n  };\n}\n"],"mappings":";;;;;;;;AAiJA,eAAsB,EACpB,GACA,GACuC;CACvC,AAAI,EAAW,aAAa,KAAA,KAAW,EAAoB,EAAW,QAAQ;CAG9E,IAAM,IAAW,EAAO,UAAU;EAAE,SAAS,EAAW;EAAS,UAAU,EAAW;CAAS,CAAC,EAAE,OAAO;CACzG,IAAI,EAAW,aAAa,KAAA,KAAa,CAAC,GACxC,MAAM,IAAI,EACR,cACA,qBACA,iGACF;CAGF,IAAM,IAAS,MAAM,EAAc,GAAQ;EACzC,SAAS,EAAW;EACpB,UAAU,EAAW;EACrB,UAAU,EAAW,OAAO;EAC5B,YAAY,EAAW,OAAO;EAC9B,gBAAgB,EAAW,OAAO;EAClC,mBAAmB,EAAW,OAAO;EACrC,eAAe,EAAW,OAAO;EACjC,gBAAgB,EAAW,OAAO;EAClC,yBAAyB,EAAW,OAAO;EAC3C,8BAA8B,EAAW,OAAO;EAChD,iCAAiC,EAAW,OAAO;EACnD,mBAAmB;CACrB,CAAC,GACK,CAAC,GAAW,KAAY,MAAM,QAAQ,IAAI,CAC9C,EAAiB,GAAQ;EACvB,SAAS,EAAW;EACpB,UAAU,EAAW;EACrB,YAAY,EAAO;EACnB,WAAW,EAAW;CACxB,CAAC,GACD,EAAgB,GAAQ;EACtB,SAAS,EAAW;EACpB,mBAAmB,EAAW;EAC9B,UAAU,EAAW,OAAO;EAC5B,UAAU,EAAW;CACvB,CAAC,CACH,CAAC,GAEK,IAAmB;EACvB;EACA,cAAc,EAAW;EACzB,WAAW,EAAW;EACtB,YAAY;EACZ,UAAU,EAAW;EACrB,gBAAgB,EAAO;EACvB,mBAAmB,EAAO;CAC5B,GAEI,IAAW,EAAW,UACtB,IAAoB,IAAW,EAAW,qBAAqB,KAAA;CACnE,IAAI,MAAa,KAAA,GAAW;EAC1B,IAAM,IAAQ,EAAqB;GAAE,GAAG;GAAkB,UAAU;EAAE,CAAC;EACvE,IAAI,CAAC,GACH,MAAM,IAAI,EACR,cACA,4BACA,mEACF;EAYF,AAVI,KAAY,MAAsB,KAAA,MACpC,IAAoB,MAAM,EAAuB,GAAQ;GACvD,SAAS,EAAW;GACpB,UAAU,EAAW;GACrB,UAAU,EAAW,OAAO;GAC5B,cAAc,EAAW;GACzB,UAAU,EAAM;GAChB;EACF,CAAC,IAEH,IAAW,EAAmB;GAAE;GAAW;GAAmB,cAAc,EAAW;EAAa,CAAC;CACvG;CAEA,IAAM,IAAY,EAAqB;EAAE,GAAG;EAAkB;CAAS,CAAC;CACxE,IAAI,CAAC,GACH,MAAM,IAAI,EACR,cACA,4BACA,mEACF;CAGF,AAAI,KAAY,MAAsB,KAAA,MACpC,IAAoB,MAAM,EAAuB,GAAQ;EACvD,SAAS,EAAW;EACpB,UAAU,EAAW;EACrB,UAAU,EAAW,OAAO;EAC5B,cAAc,EAAW;EACzB,UAAU,EAAU;EACpB;CACF,CAAC;CAGH,IAAM,EAAE,oBAAiB,wBAAqB,EAC5C,GACA,EAAU,UACV,EAAU,QACZ;CAEA,IAAI,CAAC,GACH,OAAO;EACL,MAAM;EACN;EACA;EACA,UAAU,EAAU;EACpB,UAAU,EAAU,CAAe,EAAE,KAAK,CAAgB,EAAE,SAAS;CACvE;CAGF,IAAM,EAAE,kBAAe,sBAAmB,EAAoB;EAC5D,UAAU,EAAU;EACpB,eAAe,EAAO;EACtB,gBAAgB,EAAO;EACvB,yBAAyB,EAAO;EAChC,8BAA8B,EAAO;EACrC,iCAAiC,EAAO;CAC1C,CAAC,GACK,IAAyB,EAAgC;EAC7D,cAAc,EAAW;EACzB;EACA;EACA,UAAU,EAAU;CACtB,CAAC;CAED,OAAO;EACL,MAAM;EACN;EACA;EACA,UAAU,EAAU;EACpB;EACA;EACA;EACA,UAAU,EAAU,CAAe,EAChC,KAAK,CAAgB,EACrB,KAAK,CAAa,EAClB,KAAK,CAAc,EACnB,KAAK,CAAsB,EAC3B,SAAS;CACd;AACF"}
+{"version":3,"file":"get-instant-open-fees.js","names":[],"sources":["../../../../src/solvers/instant-open/get-instant-open-fees/get-instant-open-fees.ts"],"sourcesContent":["import { toDecimal } from \"@symmio/utils/decimal\";\nimport type { Address } from \"viem\";\nimport type { Config } from \"../../../core/config\";\nimport { SymmError } from \"../../../shared/errors/symm-error\";\nimport type { Compute, ReadSolverParameter } from \"../../../shared/types/properties\";\nimport type { FeeForUser } from \"../../../symmio-contracts/symmio/actions/get-fee-for-user\";\nimport type { EnigmaSolverInfo } from \"../../get-solver-info\";\nimport type { ApiLockedParamsBySymbolIdResponse } from \"../../types/generated/enigma-solver\";\nimport type { FullBalanceFunding } from \"../prepare-instant-open-params\";\nimport {\n  resolveFeeRates,\n  resolveLockedParams,\n  resolveMarket,\n  resolveMarkPrice,\n  resolveSolverInfo,\n} from \"../prepare-instant-open-params/resolvers\";\nimport { assertValidSlippage, deriveAutoSlippage, fetchOpenEstimatePrice } from \"../shared/open-estimate-guard\";\nimport { resolveInstantOpenSizing, validateInstantOpenBalanceFunding } from \"../shared/resolve-instant-open-sizing\";\nimport {\n  calculateExpectedSettlementLoss,\n  calculateSolverFees,\n  calculateTradeParams,\n  computePlatformFeeLegs,\n} from \"../shared/trade-math\";\nimport type { InstantOpenMarketData, PositionType } from \"../shared/types\";\n\n/**\n * Fields shared by every {@link GetInstantOpenFeesParameters} funding mode.\n */\ntype BaseGetInstantOpenFeesParameters = ReadSolverParameter & {\n  /** Sub-account / partyA address the platform fee rates are read for. */\n  subAccountAddress: Address;\n  /** Market identification + optional pre-fetched precision metadata. */\n  market: InstantOpenMarketData;\n  /** Trade side. */\n  positionType: PositionType;\n  /** Position leverage (integer ≥ 1). */\n  leverage: number;\n  /**\n   * Slippage tolerance percent (e.g. `5` for 5%). **Required on majors\n   * (non-lowcap) solvers.** On a lowcap solver it may be omitted to\n   * auto-derive from the dry-run estimate plus 4% headroom — the same rule\n   * as `prepareInstantOpenParams`, so the preview prices what the open will\n   * actually charge.\n   */\n  slippage?: number;\n  /**\n   * Whether `totalFee` includes the `expectedSettlementLoss` provision.\n   * Defaults to `true` — the provision is part of what the open funds, even\n   * though it is a provision rather than a fee the solver keeps. Pass `false`\n   * to report fee legs only; the provision stays available as its own field.\n   */\n  includeSettlementInTotalFee?: boolean;\n  /** Pre-fetched mark price as decimal string. When omitted, fetched via the price service. */\n  markPrice?: string;\n  /** Pre-fetched on-chain fee rates (matches `getFeeForUser` return). When omitted, fetched. */\n  feeRates?: FeeForUser;\n  /**\n   * Pre-fetched solver estimated open (fill) price as decimal string —\n   * **lowcap/Enigma only**; ignored on any other solver kind. When omitted\n   * on a lowcap solver, fetched via `GET /estimated-price`. Pass `null` when\n   * an estimate was attempted but unavailable to skip fetching and use the fallback.\n   */\n  estimatedOpenPrice?: string | null;\n  /**\n   * Pre-fetched solver locked params (matches `getLockedParams` return).\n   * Consulted for explicit or automatic full-balance sizing, which needs the\n   * locked-param percents; when omitted there, fetched via `getLockedParams`.\n   */\n  lockedParamPercent?: ApiLockedParamsBySymbolIdResponse;\n  /**\n   * Pre-fetched solver static fees (matches `getSolverInfo` return) —\n   * **lowcap/Enigma only**; ignored on any other solver kind. When omitted on\n   * a lowcap solver, fetched via `getSolverInfo` (fail-soft: an unreachable\n   * `/info` prices the static open leg at `\"0\"`).\n   */\n  solverInfo?: EnigmaSolverInfo;\n};\n\n/**\n * Parameters for {@link getInstantOpenFees}. A subset of\n * `PrepareInstantOpenParameters` — the trade intent plus optional pre-fetched\n * data; every pre-filled optional field skips its network fetch.\n *\n * The funding source mirrors `prepareInstantOpenParams`: pass a typed\n * `initialMargin`, **or** `fund` ({@link FullBalanceFunding}, lowcap only) to\n * preview a full-balance open — the preview then runs the same\n * probe-and-rescale sizing as the open, so its legs and `quantity` equal what\n * the open charges. Provide exactly one; passing both, or neither, throws.\n * With `initialMargin`, `availableBalance` opts into automatic full-balance sizing\n * only when the typed position's required funding exceeds the raw balance.\n * The typed initialMargin itself must not exceed availableBalance.\n */\nexport type GetInstantOpenFeesParameters = Compute<\n  BaseGetInstantOpenFeesParameters & {\n    /** Collateral (USD) the user enters as initial margin. Decimal string. Provide this **or** `fund`. */\n    initialMargin?: string;\n    /**\n     * Raw available collateral (USD decimal string). With initialMargin, previews the\n     * same automatic full-balance fallback as prepareInstantOpenParams. Lowcap only;\n     * must be positive and finite. initialMargin above this balance throws. Cannot accompany fund.\n     */\n    availableBalance?: string;\n    /**\n     * Preview a full-balance open — lowcap (Enigma) only. Provide this **or**\n     * `initialMargin`. See {@link FullBalanceFunding}.\n     */\n    fund?: FullBalanceFunding;\n  }\n>;\n\n/**\n * Fee legs every solver kind charges **at open**. Close fees are charged at\n * close from the position — preview them in the close flow with\n * `getInstantCloseFees`, where the notional and holding time are real.\n */\nexport interface BaseInstantOpenFees {\n  /** Effective sizing mode, including automatic fallback from a typed initial margin. */\n  fundingMode: \"initial-margin\" | \"full-balance\";\n  /** Platform open fee: `getFeeForUser.openFee × notional / 1e18` (decimal string). */\n  platformOpenFee: string;\n  /** Leveraged notional the fee rates were applied to (decimal string). */\n  notional: string;\n  /**\n   * Leveraged base-asset quantity the legs were computed on (decimal string) —\n   * in full-balance mode this is the rescaled, lot-snapped size the open will\n   * actually submit. Feed this to TP/SL and constraint previews instead of\n   * re-deriving from the typed margin.\n   */\n  quantity: string;\n  /**\n   * Sum of every leg the open charges now (decimal string). Includes the\n   * settlement provision by default; pass `includeSettlementInTotalFee: false`\n   * to sum the fee legs only.\n   */\n  totalFee: string;\n}\n\n/**\n * Fee breakdown for a **lowcap (Enigma)** instant open. Extends the platform\n * leg with the solver open legs and the settlement provision the solver\n * charges from the VA balance.\n */\nexport interface EnigmaInstantOpenFees extends BaseInstantOpenFees {\n  /** Discriminant: these fees were priced for an Enigma (lowcap) solver. */\n  kind: \"enigma\";\n  /** Solver open fee: `hedgerFeeOpen × notional` (decimal string). */\n  openSolverFee: string;\n  /**\n   * Expected settlement loss vs the dry-run estimate: side-aware\n   * `max(0, adverse fill deviation × quantity)` (decimal string). `\"0\"` when\n   * no usable estimate exists.\n   */\n  expectedSettlementLoss: string;\n  /**\n   * Static solver fee charged per instant open — a flat USD amount from the\n   * solver's `/info` config, independent of the notional (decimal string).\n   * `\"0\"` when the solver publishes none.\n   */\n  staticSolverFeeOpen: string;\n}\n\n/**\n * Fee breakdown for a **majors (Rasa)** instant open — the platform open leg\n * only.\n */\nexport interface RasaInstantOpenFees extends BaseInstantOpenFees {\n  /** Discriminant: these fees were priced for a Rasa (majors) solver. */\n  kind: \"rasa\";\n}\n\n/**\n * Return type of {@link getInstantOpenFees}. Narrow on `kind` to reach the\n * lowcap-only legs.\n */\nexport type GetInstantOpenFeesReturnType = EnigmaInstantOpenFees | RasaInstantOpenFees;\n\n/**\n * Preview every fee a new instant-open quote pays **at open**, separated by leg\n * plus the total — without signing or submitting anything.\n *\n * Mirrors the exact resolution and math `prepareInstantOpenParams` uses, so\n * the preview equals what the open charges for the same inputs:\n *\n * - **Both kinds**: `platformOpenFee` (on-chain `getFeeForUser.openFee` ×\n *   leveraged notional).\n * - **Lowcap (Enigma) only**: `openSolverFee` (`hedgerFeeOpen × notional`),\n *   `staticSolverFeeOpen` (flat USD from the solver's `/info` config,\n *   size-independent) and `expectedSettlementLoss` (dry-run estimate vs mark)\n *   — the legs the solver charges from the VA balance.\n *\n * Close fees (platform close, solver close, static close) are **not** part of\n * this preview: they are charged at close from the position, priced by\n * `getInstantCloseFees` in the close flow from the then-current notional and\n * the position's real holding time.\n *\n * `totalFee` sums every open leg. It includes the settlement provision by\n * default — the amount the user must fund even though the settlement leg is a\n * provision rather than a fee the solver keeps; pass\n * `includeSettlementInTotalFee: false` to sum the fee legs only.\n *\n * With `fund` ({@link FullBalanceFunding}) instead of `initialMargin`, the\n * preview runs the same probe-and-rescale sizing as the open — lot snap, cost\n * invariant, slippage-bound settlement fallback included — so the reported\n * legs and `quantity` are those of the trade the open will actually submit.\n *\n * @throws {SymmError} `SLIPPAGE_REQUIRED` on majors without `slippage`;\n *   `AMBIGUOUS_FUNDING` / `INITIAL_MARGIN_REQUIRED` /\n *   `FULL_BALANCE_UNSUPPORTED` for a broken funding one-of;\n *   `QUOTE_CONSTRAINT_VIOLATED` when the full-balance sizing violates a\n *   published market constraint;\n *   `INVALID_SLIPPAGE` / `INVALID_TRADE_PARAMETERS` /\n *   `RESOLVE_MARKET_NOT_FOUND` / `RESOLVE_MARK_PRICE_NOT_FOUND` for invalid or\n *   unresolvable inputs.\n *\n * @example\n * ```ts\n * const fees = await getInstantOpenFees(config, {\n *   subAccountAddress,\n *   market: { id: 1 },\n *   positionType: PositionType.LONG,\n *   initialMargin: \"100\",\n *   leverage: 5,\n * });\n * if (fees.kind === \"enigma\") console.log(fees.openSolverFee, fees.expectedSettlementLoss);\n * console.log(fees.totalFee);\n * ```\n */\nexport async function getInstantOpenFees(\n  config: Config,\n  parameters: GetInstantOpenFeesParameters,\n): Promise<GetInstantOpenFeesReturnType> {\n  if (parameters.slippage !== undefined) assertValidSlippage(parameters.slippage);\n\n  /** Estimate-driven legs exist only on lowcap (Enigma) solvers — a majors preview is the platform leg only. */\n  const isLowcap = config.getSolver({ chainId: parameters.chainId, solverId: parameters.solverId }).id === \"enigma\";\n  if (parameters.slippage === undefined && !isLowcap) {\n    throw new SymmError(\n      \"validation\",\n      \"SLIPPAGE_REQUIRED\",\n      \"getInstantOpenFees: slippage is required on this solver — auto-derived slippage is lowcap-only.\",\n    );\n  }\n\n  // Same one-of funding contract as `prepareInstantOpenParams`, so a preview\n  // can always be expressed for the exact open it mirrors.\n  const isFullBalance = parameters.fund !== undefined;\n  validateInstantOpenBalanceFunding({ ...parameters, isLowcap });\n  const canSizeFullBalance = isFullBalance || parameters.availableBalance !== undefined;\n  if (isFullBalance && parameters.initialMargin !== undefined) {\n    throw new SymmError(\n      \"validation\",\n      \"AMBIGUOUS_FUNDING\",\n      \"getInstantOpenFees: pass exactly one of initialMargin or fund, not both.\",\n    );\n  }\n  if (isFullBalance && !isLowcap) {\n    throw new SymmError(\n      \"validation\",\n      \"FULL_BALANCE_UNSUPPORTED\",\n      \"getInstantOpenFees: full-balance funding is lowcap (Enigma) only — pass initialMargin on this solver.\",\n    );\n  }\n  if (!isFullBalance && parameters.initialMargin === undefined) {\n    throw new SymmError(\n      \"validation\",\n      \"INITIAL_MARGIN_REQUIRED\",\n      \"getInstantOpenFees: pass initialMargin, or fund: { mode: 'full-balance', balance } on a lowcap solver.\",\n    );\n  }\n  const initialMargin = isFullBalance ? parameters.fund!.balance : parameters.initialMargin!;\n  const includeSettlementInTotalFee = parameters.includeSettlementInTotalFee ?? true;\n\n  const market = await resolveMarket(config, {\n    chainId: parameters.chainId,\n    solverId: parameters.solverId,\n    marketId: parameters.market.id,\n    marketName: parameters.market.name,\n    pricePrecision: parameters.market.pricePrecision,\n    quantityPrecision: parameters.market.quantityPrecision,\n    // The close-side prefills only serve the resolver's short-circuit (skip the\n    // markets fetch when the caller pre-fetched the row) — the open cost model\n    // uses `hedgerFeeOpen` alone; close fees are priced by `getInstantCloseFees`.\n    hedgerFeeOpen: parameters.market.hedgerFeeOpen,\n    hedgerFeeClose: parameters.market.hedgerFeeClose,\n    hedgerFeeCloseEarlyRate: parameters.market.hedgerFeeCloseEarlyRate,\n    hedgerFeeCloseEarlyThreshold: parameters.market.hedgerFeeCloseEarlyThreshold,\n    hedgerFeeCloseStandardThreshold: parameters.market.hedgerFeeCloseStandardThreshold,\n    includeHedgerFees: isLowcap,\n    /** Explicit or automatic full-balance sizing needs the lot grid and published floors. */\n    includeQuoteConstraints: canSizeFullBalance,\n    minAcceptablePortionLf: parameters.market.minAcceptablePortionLf,\n    minAcceptableQuoteValue: parameters.market.minAcceptableQuoteValue,\n    maxNotionalValue: parameters.market.maxNotionalValue,\n    minNotionalValue: parameters.market.minNotionalValue,\n    maxQuantity: parameters.market.maxQuantity,\n    lotSize: parameters.market.lotSize,\n  });\n  const [markPrice, feeRates, lockedParams, staticFees] = await Promise.all([\n    resolveMarkPrice(config, {\n      chainId: parameters.chainId,\n      solverId: parameters.solverId,\n      marketName: market.name,\n      markPrice: parameters.markPrice,\n    }),\n    resolveFeeRates(config, {\n      chainId: parameters.chainId,\n      subAccountAddress: parameters.subAccountAddress,\n      marketId: parameters.market.id,\n      feeRates: parameters.feeRates,\n    }),\n    // Full-balance sizing needs the locked-param percents — the locks dominate\n    // the margin the balance must cover, including the automatic fallback check.\n    canSizeFullBalance\n      ? resolveLockedParams(config, {\n          chainId: parameters.chainId,\n          solverId: parameters.solverId,\n          marketName: market.name,\n          leverage: parameters.leverage,\n          lockedParamPercent: parameters.lockedParamPercent,\n        })\n      : Promise.resolve(undefined),\n    // The static open fee is a lowcap leg — majors previews never fetch it.\n    isLowcap\n      ? resolveSolverInfo(config, {\n          chainId: parameters.chainId,\n          solverId: parameters.solverId,\n          solverInfo: parameters.solverInfo,\n        })\n      : Promise.resolve({ staticSolverFeeOpen: \"0\", staticSolverFeeClose: \"0\" }),\n  ]);\n\n  const calculationInput = {\n    markPrice,\n    positionType: parameters.positionType,\n    userInput: initialMargin,\n    inputField: \"PRICE\" as const,\n    leverage: parameters.leverage,\n    pricePrecision: market.pricePrecision,\n    quantityPrecision: market.quantityPrecision,\n    ...(lockedParams\n      ? {\n          cvaPercent: lockedParams.cva,\n          lfPercent: lockedParams.lf,\n          partyAmmPercent: lockedParams.partyAmm,\n          partyBmmPercent: lockedParams.partyBmm,\n        }\n      : {}),\n  };\n\n  let slippage = parameters.slippage;\n  let expectedFillPrice = isLowcap ? (parameters.estimatedOpenPrice ?? undefined) : undefined;\n  let needsEstimate = isLowcap && parameters.estimatedOpenPrice === undefined;\n  if (slippage === undefined) {\n    const sized = calculateTradeParams({ ...calculationInput, slippage: 0 });\n    if (!sized) {\n      throw new SymmError(\n        \"validation\",\n        \"INVALID_TRADE_PARAMETERS\",\n        \"Invalid trade parameters: markPrice or initialMargin is zero/NaN.\",\n      );\n    }\n    if (needsEstimate) {\n      needsEstimate = false;\n      expectedFillPrice = await fetchOpenEstimatePrice(config, {\n        chainId: parameters.chainId,\n        solverId: parameters.solverId,\n        symbolId: parameters.market.id,\n        positionType: parameters.positionType,\n        quantity: sized.quantity,\n        markPrice,\n      });\n    }\n    slippage = deriveAutoSlippage({ markPrice, expectedFillPrice, positionType: parameters.positionType });\n  }\n\n  const tradeCalc = calculateTradeParams({ ...calculationInput, slippage });\n  if (!tradeCalc) {\n    throw new SymmError(\n      \"validation\",\n      \"INVALID_TRADE_PARAMETERS\",\n      \"Invalid trade parameters: markPrice or initialMargin is zero/NaN.\",\n    );\n  }\n\n  if (needsEstimate) {\n    expectedFillPrice = await fetchOpenEstimatePrice(config, {\n      chainId: parameters.chainId,\n      solverId: parameters.solverId,\n      symbolId: parameters.market.id,\n      positionType: parameters.positionType,\n      quantity: tradeCalc.quantity,\n      markPrice,\n    });\n  }\n\n  // Full-balance preview: run the exact sizing the open runs — probe, linear\n  // rescale, lot snap, cost invariant — and report the legs of the trade that\n  // will actually be submitted.\n  if (canSizeFullBalance) {\n    const { trade, costs, fundingMode } = resolveInstantOpenSizing({\n      trade: tradeCalc,\n      isLowcap,\n      fund: parameters.fund,\n      availableBalance: parameters.availableBalance,\n      calculationInput: { ...calculationInput, slippage },\n      // Preserve the legacy zero sentinel for callers; prefer null for unavailable estimates.\n      // Full-balance sizing provisions settlement at the price bound when no estimate exists.\n      expectedFillPrice: expectedFillPrice === \"0\" ? undefined : expectedFillPrice,\n      feeRates,\n      hedgerFeeOpen: market.hedgerFeeOpen,\n      staticSolverFeeOpen: staticFees.staticSolverFeeOpen,\n      constraints: {\n        minAcceptablePortionLf: market.minAcceptablePortionLf,\n        minAcceptableQuoteValue: market.minAcceptableQuoteValue,\n        maxNotionalValue: market.maxNotionalValue,\n        minNotionalValue: market.minNotionalValue,\n        maxQuantity: market.maxQuantity,\n        lotSize: market.lotSize,\n      },\n    });\n    return {\n      fundingMode,\n      kind: \"enigma\",\n      platformOpenFee: costs.platformOpenFee,\n      notional: trade.notional,\n      quantity: trade.quantity,\n      openSolverFee: costs.openSolverFee,\n      staticSolverFeeOpen: costs.staticSolverFeeOpen,\n      expectedSettlementLoss: costs.expectedSettlementLoss,\n      totalFee: toDecimal(costs.platformOpenFee)\n        .plus(costs.openSolverFee)\n        .plus(costs.staticSolverFeeOpen)\n        .plus(includeSettlementInTotalFee ? costs.expectedSettlementLoss : \"0\")\n        .toString(),\n    };\n  }\n\n  const { platformOpenFee } = computePlatformFeeLegs(feeRates, tradeCalc.notional, tradeCalc.notional);\n\n  if (!isLowcap) {\n    return {\n      fundingMode: \"initial-margin\",\n      kind: \"rasa\",\n      platformOpenFee,\n      notional: tradeCalc.notional,\n      quantity: tradeCalc.quantity,\n      totalFee: platformOpenFee,\n    };\n  }\n\n  const { openSolverFee, staticSolverFeeOpen } = calculateSolverFees({\n    notional: tradeCalc.notional,\n    hedgerFeeOpen: market.hedgerFeeOpen,\n    hedgerFeeClose: undefined,\n    staticSolverFeeOpen: staticFees.staticSolverFeeOpen,\n  });\n  const expectedSettlementLoss = calculateExpectedSettlementLoss({\n    positionType: parameters.positionType,\n    markPrice,\n    expectedFillPrice,\n    quantity: tradeCalc.quantity,\n  });\n\n  return {\n    fundingMode: \"initial-margin\",\n    kind: \"enigma\",\n    platformOpenFee,\n    notional: tradeCalc.notional,\n    quantity: tradeCalc.quantity,\n    openSolverFee,\n    staticSolverFeeOpen,\n    expectedSettlementLoss,\n    totalFee: toDecimal(platformOpenFee)\n      .plus(openSolverFee)\n      .plus(staticSolverFeeOpen)\n      .plus(includeSettlementInTotalFee ? expectedSettlementLoss : \"0\")\n      .toString(),\n  };\n}\n"],"mappings":"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"}

package/dist/solvers/instant-open/get-instant-open-fees/query.d.ts

@@ -14,8 +14,9 @@ export type GetInstantOpenFeesOptions = Compute<GetInstantOpenFeesParameters & Q
 export type GetInstantOpenFeesQueryOptions = SymmioQueryOptions<GetInstantOpenFeesData, Error, GetInstantOpenFeesData, GetInstantOpenFeesQueryKey>;
 /**
  * Build TanStack Query options for {@link getInstantOpenFees}. Disabled until
- * `initialMargin` is non-empty, so the fee preview does not fire on an empty
- * amount input.
+ * a funding source exists — a non-empty `initialMargin`, or `fund` with a
+ * non-empty balance — so the fee preview does not fire on an empty amount
+ * input.
  *
  * @example
  * ```ts

package/dist/solvers/instant-open/get-instant-open-fees/query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../../src/solvers/instant-open/get-instant-open-fees/query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACpF,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAEtF,OAAO,EAEL,KAAK,4BAA4B,EACjC,KAAK,4BAA4B,EAClC,MAAM,yBAAyB,CAAC;AAEjC,yEAAyE;AACzE,MAAM,MAAM,sBAAsB,GAAG,4BAA4B,CAAC;AAElE,+EAA+E;AAC/E,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,OAAO,CAAC,4BAA4B,GAAG,kBAAkB,CAAC,4DAE7G;AAED,qEAAqE;AACrE,MAAM,MAAM,0BAA0B,GAAG,UAAU,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAEvF,kEAAkE;AAClE,MAAM,MAAM,yBAAyB,GAAG,OAAO,CAC7C,4BAA4B,GAC1B,cAAc,CAAC,sBAAsB,EAAE,KAAK,EAAE,sBAAsB,EAAE,0BAA0B,CAAC,CACpG,CAAC;AAEF,iFAAiF;AACjF,MAAM,MAAM,8BAA8B,GAAG,kBAAkB,CAC7D,sBAAsB,EACtB,KAAK,EACL,sBAAsB,EACtB,0BAA0B,CAC3B,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,yBAAyB,GACjC,8BAA8B,CAuBhC"}
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../../src/solvers/instant-open/get-instant-open-fees/query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACpF,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAEtF,OAAO,EAEL,KAAK,4BAA4B,EACjC,KAAK,4BAA4B,EAClC,MAAM,yBAAyB,CAAC;AAEjC,yEAAyE;AACzE,MAAM,MAAM,sBAAsB,GAAG,4BAA4B,CAAC;AAElE,+EAA+E;AAC/E,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,OAAO,CAAC,4BAA4B,GAAG,kBAAkB,CAAC,4DAE7G;AAED,qEAAqE;AACrE,MAAM,MAAM,0BAA0B,GAAG,UAAU,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAEvF,kEAAkE;AAClE,MAAM,MAAM,yBAAyB,GAAG,OAAO,CAC7C,4BAA4B,GAC1B,cAAc,CAAC,sBAAsB,EAAE,KAAK,EAAE,sBAAsB,EAAE,0BAA0B,CAAC,CACpG,CAAC;AAEF,iFAAiF;AACjF,MAAM,MAAM,8BAA8B,GAAG,kBAAkB,CAC7D,sBAAsB,EACtB,KAAK,EACL,sBAAsB,EACtB,0BAA0B,CAC3B,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,yBAAyB,GACjC,8BAA8B,CAahC"}