@symmio/trading-core 3.1.0 → 3.2.0

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

@@ -5,26 +5,15 @@ function n(t) {
 	return ["getInstantOpenFees", e(t)];
 }
 function r(e, r) {
+	let { query: i, ...a } = r, o = r.fund === void 0 ? (r.initialMargin?.length ?? 0) > 0 : r.fund.balance.length > 0;
 	return {
-		...r.query,
+		...i,
 		queryKey: n({
 			...r,
 			configKey: e.getChainConfigKey(r.chainId)
 		}),
-		enabled: (r.query?.enabled ?? !0) && r.initialMargin.length > 0,
-		queryFn: () => t(e, {
-			chainId: r.chainId,
-			solverId: r.solverId,
-			subAccountAddress: r.subAccountAddress,
-			market: r.market,
-			positionType: r.positionType,
-			initialMargin: r.initialMargin,
-			leverage: r.leverage,
-			slippage: r.slippage,
-			markPrice: r.markPrice,
-			feeRates: r.feeRates,
-			estimatedOpenPrice: r.estimatedOpenPrice
-		})
+		enabled: (r.query?.enabled ?? !0) && o,
+		queryFn: () => t(e, a)
 	};
 }
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"query.js","names":[],"sources":["../../../../src/solvers/instant-open/get-instant-open-fees/query.ts"],"sourcesContent":["import type { Config } from \"../../../core/config\";\nimport type { Compute, ConfigKeyParameter } from \"../../../shared/types/properties\";\nimport type { QueryParameter, SymmioQueryOptions } from \"../../../shared/types/query\";\nimport { filterQueryOptions } from \"../../../shared/utils/query\";\nimport {\n  getInstantOpenFees,\n  type GetInstantOpenFeesParameters,\n  type GetInstantOpenFeesReturnType,\n} from \"./get-instant-open-fees\";\n\n/** Data resolved by the {@link getInstantOpenFeesQueryOptions} query. */\nexport type GetInstantOpenFeesData = GetInstantOpenFeesReturnType;\n\n/** Build the TanStack Query key for {@link getInstantOpenFeesQueryOptions}. */\nexport function getInstantOpenFeesQueryKey(options: Compute<GetInstantOpenFeesParameters & ConfigKeyParameter>) {\n  return [\"getInstantOpenFees\", filterQueryOptions(options)] as const;\n}\n\n/** Query-key type produced by {@link getInstantOpenFeesQueryKey}. */\nexport type GetInstantOpenFeesQueryKey = ReturnType<typeof getInstantOpenFeesQueryKey>;\n\n/** Options accepted by {@link getInstantOpenFeesQueryOptions}. */\nexport type GetInstantOpenFeesOptions = Compute<\n  GetInstantOpenFeesParameters &\n    QueryParameter<GetInstantOpenFeesData, Error, GetInstantOpenFeesData, GetInstantOpenFeesQueryKey>\n>;\n\n/** TanStack Query options returned by {@link getInstantOpenFeesQueryOptions}. */\nexport type GetInstantOpenFeesQueryOptions = SymmioQueryOptions<\n  GetInstantOpenFeesData,\n  Error,\n  GetInstantOpenFeesData,\n  GetInstantOpenFeesQueryKey\n>;\n\n/**\n * Build TanStack Query options for {@link getInstantOpenFees}. Disabled until\n * `initialMargin` is non-empty, so the fee preview does not fire on an empty\n * amount input.\n *\n * @example\n * ```ts\n * useQuery(\n *   getInstantOpenFeesQueryOptions(config, {\n *     subAccountAddress,\n *     market: { id: 1 },\n *     positionType,\n *     initialMargin,\n *     leverage: 5,\n *   }),\n * );\n * ```\n */\nexport function getInstantOpenFeesQueryOptions(\n  config: Config,\n  options: GetInstantOpenFeesOptions,\n): GetInstantOpenFeesQueryOptions {\n  return {\n    ...options.query,\n    queryKey: getInstantOpenFeesQueryKey({\n      ...options,\n      configKey: config.getChainConfigKey(options.chainId),\n    }),\n    enabled: (options.query?.enabled ?? true) && options.initialMargin.length > 0,\n    queryFn: () =>\n      getInstantOpenFees(config, {\n        chainId: options.chainId,\n        solverId: options.solverId,\n        subAccountAddress: options.subAccountAddress,\n        market: options.market,\n        positionType: options.positionType,\n        initialMargin: options.initialMargin,\n        leverage: options.leverage,\n        slippage: options.slippage,\n        markPrice: options.markPrice,\n        feeRates: options.feeRates,\n        estimatedOpenPrice: options.estimatedOpenPrice,\n      }),\n  };\n}\n"],"mappings":";;;AAcA,SAAgB,EAA2B,GAAqE;CAC9G,OAAO,CAAC,sBAAsB,EAAmB,CAAO,CAAC;AAC3D;AAqCA,SAAgB,EACd,GACA,GACgC;CAChC,OAAO;EACL,GAAG,EAAQ;EACX,UAAU,EAA2B;GACnC,GAAG;GACH,WAAW,EAAO,kBAAkB,EAAQ,OAAO;EACrD,CAAC;EACD,UAAU,EAAQ,OAAO,WAAW,OAAS,EAAQ,cAAc,SAAS;EAC5E,eACE,EAAmB,GAAQ;GACzB,SAAS,EAAQ;GACjB,UAAU,EAAQ;GAClB,mBAAmB,EAAQ;GAC3B,QAAQ,EAAQ;GAChB,cAAc,EAAQ;GACtB,eAAe,EAAQ;GACvB,UAAU,EAAQ;GAClB,UAAU,EAAQ;GAClB,WAAW,EAAQ;GACnB,UAAU,EAAQ;GAClB,oBAAoB,EAAQ;EAC9B,CAAC;CACL;AACF"}
+{"version":3,"file":"query.js","names":[],"sources":["../../../../src/solvers/instant-open/get-instant-open-fees/query.ts"],"sourcesContent":["import type { Config } from \"../../../core/config\";\nimport type { Compute, ConfigKeyParameter } from \"../../../shared/types/properties\";\nimport type { QueryParameter, SymmioQueryOptions } from \"../../../shared/types/query\";\nimport { filterQueryOptions } from \"../../../shared/utils/query\";\nimport {\n  getInstantOpenFees,\n  type GetInstantOpenFeesParameters,\n  type GetInstantOpenFeesReturnType,\n} from \"./get-instant-open-fees\";\n\n/** Data resolved by the {@link getInstantOpenFeesQueryOptions} query. */\nexport type GetInstantOpenFeesData = GetInstantOpenFeesReturnType;\n\n/** Build the TanStack Query key for {@link getInstantOpenFeesQueryOptions}. */\nexport function getInstantOpenFeesQueryKey(options: Compute<GetInstantOpenFeesParameters & ConfigKeyParameter>) {\n  return [\"getInstantOpenFees\", filterQueryOptions(options)] as const;\n}\n\n/** Query-key type produced by {@link getInstantOpenFeesQueryKey}. */\nexport type GetInstantOpenFeesQueryKey = ReturnType<typeof getInstantOpenFeesQueryKey>;\n\n/** Options accepted by {@link getInstantOpenFeesQueryOptions}. */\nexport type GetInstantOpenFeesOptions = Compute<\n  GetInstantOpenFeesParameters &\n    QueryParameter<GetInstantOpenFeesData, Error, GetInstantOpenFeesData, GetInstantOpenFeesQueryKey>\n>;\n\n/** TanStack Query options returned by {@link getInstantOpenFeesQueryOptions}. */\nexport type GetInstantOpenFeesQueryOptions = SymmioQueryOptions<\n  GetInstantOpenFeesData,\n  Error,\n  GetInstantOpenFeesData,\n  GetInstantOpenFeesQueryKey\n>;\n\n/**\n * Build TanStack Query options for {@link getInstantOpenFees}. Disabled until\n * a funding source exists — a non-empty `initialMargin`, or `fund` with a\n * non-empty balance — so the fee preview does not fire on an empty amount\n * input.\n *\n * @example\n * ```ts\n * useQuery(\n *   getInstantOpenFeesQueryOptions(config, {\n *     subAccountAddress,\n *     market: { id: 1 },\n *     positionType,\n *     initialMargin,\n *     leverage: 5,\n *   }),\n * );\n * ```\n */\nexport function getInstantOpenFeesQueryOptions(\n  config: Config,\n  options: GetInstantOpenFeesOptions,\n): GetInstantOpenFeesQueryOptions {\n  const { query, ...parameters } = options;\n  const hasFunding =\n    options.fund !== undefined ? options.fund.balance.length > 0 : (options.initialMargin?.length ?? 0) > 0;\n  return {\n    ...query,\n    queryKey: getInstantOpenFeesQueryKey({\n      ...options,\n      configKey: config.getChainConfigKey(options.chainId),\n    }),\n    enabled: (options.query?.enabled ?? true) && hasFunding,\n    queryFn: () => getInstantOpenFees(config, parameters),\n  };\n}\n"],"mappings":";;;AAcA,SAAgB,EAA2B,GAAqE;CAC9G,OAAO,CAAC,sBAAsB,EAAmB,CAAO,CAAC;AAC3D;AAsCA,SAAgB,EACd,GACA,GACgC;CAChC,IAAM,EAAE,UAAO,GAAG,MAAe,GAC3B,IACJ,EAAQ,SAAS,KAAA,KAA+C,EAAQ,eAAe,UAAU,KAAK,IAAzE,EAAQ,KAAK,QAAQ,SAAS;CAC7D,OAAO;EACL,GAAG;EACH,UAAU,EAA2B;GACnC,GAAG;GACH,WAAW,EAAO,kBAAkB,EAAQ,OAAO;EACrD,CAAC;EACD,UAAU,EAAQ,OAAO,WAAW,OAAS;EAC7C,eAAe,EAAmB,GAAQ,CAAU;CACtD;AACF"}

package/dist/solvers/instant-open/prepare-instant-open-params/index.d.ts

@@ -1,3 +1,4 @@
 export * from './prepare-instant-open-params.js';
+export * from './query.js';
 export * from './resolvers/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/solvers/instant-open/prepare-instant-open-params/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/solvers/instant-open/prepare-instant-open-params/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/solvers/instant-open/prepare-instant-open-params/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC"}

package/dist/solvers/instant-open/prepare-instant-open-params/prepare-instant-open-params.d.ts

@@ -2,6 +2,7 @@ import { Address, Hex } from 'viem';
 import { Config } from '../../../core/config/index.js';
 import { Compute, WriteSolverParameter } 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 { InstantOpenParameters } from '../instant-open/types.js';
 import { InstantOpenMarketData, PositionType } from '../shared/types.js';
@@ -12,15 +13,38 @@ import { InstantOpenMarketData, PositionType } from '../shared/types.js';
  * intent). Optional = anything derivable from solver / price-service / on-chain
  * reads. Pre-fill an optional field to skip its fetch.
  */
-export type PrepareInstantOpenParameters = Compute<WriteSolverParameter & {
+/**
+ * Full-balance funding for a lowcap (Enigma) open — deploy the **entire**
+ * selected collateral into the position's Virtual Account instead of typing an
+ * initial margin.
+ *
+ * With a typed `initialMargin` the SubAccount keeps back whatever the position
+ * did not need (locks + open fees + settlement), so a user who deposited `$100`
+ * and hit "Max" saw a smaller spendable figure and left dust behind. In this
+ * mode the whole balance moves to the VA and the SDK sizes the quantity **down**
+ * so its locks + open fees + worst-case settlement fit inside it — nothing is
+ * stranded and the figure the user deployed is the figure they picked. (Close
+ * fees are charged at close from the position, so they are not sized in here.)
+ *
+ * Lowcap (Enigma) only: it relies on the per-position VA and the solver-fee /
+ * settlement legs a majors (cross-margin) open does not have.
+ */
+export interface FullBalanceFunding {
+    /** Discriminant selecting the full-balance sizing path. */
+    mode: "full-balance";
+    /** The entire collateral to move into the VA, as a USD decimal string. */
+    balance: string;
+}
+/**
+ * Fields shared by every {@link PrepareInstantOpenParameters} funding mode.
+ */
+type PrepareInstantOpenBaseParameters = WriteSolverParameter & {
     /** Sub-account / partyA address. */
     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;
     /**
@@ -36,11 +60,12 @@ export type PrepareInstantOpenParameters = Compute<WriteSolverParameter & {
     /**
      * 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`. Feeds the
-     * settlement-loss provision, the slippage gate, and (when `slippage` is
+     * 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.
+     * Feeds the settlement-loss provision, the slippage gate, and (when `slippage` is
      * omitted) the auto-slippage derivation.
      */
-    estimatedOpenPrice?: string;
+    estimatedOpenPrice?: string | null;
     /**
      * Pre-fetched solver locked params (matches `getLockedParams` return —
      * `ApiLockedParamsBySymbolIdResponse`). When supplied with all four
@@ -52,6 +77,14 @@ export type PrepareInstantOpenParameters = Compute<WriteSolverParameter & {
      * `FeeForUser`). When omitted, fetched via `getFeeForUser`.
      */
     feeRates?: FeeForUser;
+    /**
+     * 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 both static legs at `"0"`). The flat USD legs ride the
+     * `addMargin` transfer like the rate-based solver fees.
+     */
+    solverInfo?: EnigmaSolverInfo;
     /** Forwarded to {@link InstantOpenParameters}. */
     uuid?: string;
     /** Forwarded to {@link InstantOpenParameters}. */
@@ -60,7 +93,38 @@ export type PrepareInstantOpenParameters = Compute<WriteSolverParameter & {
     sendQuoteSalt?: Hex;
     /** Forwarded to {@link InstantOpenParameters}. */
     deadline?: bigint;
+};
+/**
+ * Parameters for {@link prepareInstantOpenParams} and `instantOpenAuto`.
+ *
+ * The funding source is a choice: pass a typed `initialMargin` (the classic
+ * path, works on every solver), **or** `fund` with {@link FullBalanceFunding} to
+ * deploy the whole balance on a lowcap (Enigma) solver. Provide **exactly one** —
+ * passing both, or neither, throws. (Both are typed optional so the params
+ * spread cleanly through wrapper flows; the one-of rule is enforced at runtime.)
+ */
+export type PrepareInstantOpenParameters = Compute<PrepareInstantOpenBaseParameters & {
+    /** Collateral (USD) the user enters as initial margin. Decimal string. Provide this **or** `fund`. */
+    initialMargin?: string;
+    /**
+     * Raw available collateral (USD decimal string). With initialMargin, automatically
+     * use full-balance sizing when required funding exceeds this amount. Lowcap only;
+     * must be positive and finite. initialMargin above this balance throws.
+     * Omit to preserve typed sizing. Cannot accompany fund.
+     */
+    availableBalance?: string;
+    /**
+     * Deploy the entire collateral and size the quantity to fit it — lowcap
+     * (Enigma) only. Provide this **or** `initialMargin`. See
+     * {@link FullBalanceFunding}.
+     */
+    fund?: FullBalanceFunding;
 }>;
+/** Prepared order parameters plus the effective funding mode. Pass directly to instantOpen. */
+export type PrepareInstantOpenParamsReturnType = InstantOpenParameters & {
+    /** Effective sizing mode, including automatic fallback from a typed initial margin. */
+    fundingMode: "initial-margin" | "full-balance";
+};
 /**
  * Resolve every input the {@link InstantOpenParameters} primitive needs from a
  * minimal parameter set.
@@ -70,6 +134,29 @@ export type PrepareInstantOpenParameters = Compute<WriteSolverParameter & {
  * unchanged: `slippage` required, no estimate fetch, margin = locks +
  * platform fee.
  *
+ * Funding is a discriminated choice (see {@link PrepareInstantOpenParameters}):
+ * a typed `initialMargin`, or `fund` ({@link FullBalanceFunding}, lowcap only)
+ * to deploy the whole balance. In full-balance mode the balance is used as a
+ * sizing probe: since the addMargin amount is linear in the sizing input at a
+ * fixed fill price, one probe gives the exact factor that shrinks the quantity
+ * so its locks + fees + settlement fit the balance, and the transfer then funds
+ * the whole balance (any remainder rides as free VA margin). The sized
+ * quantity is snapped down to the market's lot grid, re-checked so its costs
+ * never exceed the balance (precision rounding can overshoot the linear
+ * factor), and validated against the market's published quote constraints;
+ * when no fill estimate is available the settlement leg is provisioned at the
+ * slippage bound instead of zero — a full-balance open leaves nothing behind
+ * to absorb an optimistic estimate.
+ *
+ * Pass `availableBalance` with `initialMargin` to automatically select full-balance
+ * sizing when the typed position's required funding exceeds the raw balance.
+ * An initialMargin above availableBalance throws before sizing. Otherwise, funding
+ * equality preserves typed sizing. The returned `fundingMode` reports the choice.
+ *
+ * @param config - SDK configuration used to resolve market and account inputs.
+ * @param parameters - Trade intent, optional balance budget, and prefetched inputs.
+ * @returns Prepared order parameters and the effective funding mode.
+ *
  * Steps:
  * 1. Validate the user's `slippage` ({@link assertValidSlippage}). On a
  *    lowcap solver it may be omitted and is auto-derived: dry-run the
@@ -87,18 +174,27 @@ export type PrepareInstantOpenParameters = Compute<WriteSolverParameter & {
  *    auto-slippage estimate when one exists).
  * 5. Run {@link computePlatformFee}, {@link calculateSolverFees}, and
  *    {@link calculateExpectedSettlementLoss}, then {@link calculateMargin} to
- *    derive the `addMargin` amount — the solver charges its fees and the
- *    open-price settlement from the VA, so the transfer funds
- *    `locks + platformFee + openSolverFee + closeSolverFee +
- *    expectedSettlementLoss`.
+ *    derive the `addMargin` amount. The open funds only the **open-side** legs
+ *    plus the open-price settlement from the VA, so the transfer funds
+ *    `locks + platformOpenFee + openSolverFee + staticSolverFeeOpen +
+ *    expectedSettlementLoss` (the static open leg is a flat USD amount from the
+ *    solver's `/info` config). The close-side legs (platform close, solver
+ *    close, static close) are **charged at close** from the position — the
+ *    contract collects them at close execution — so they are not pre-funded
+ *    here; pre-funding them would strand collateral in the VA. In full-balance
+ *    mode the quantity is rescaled to fit the balance — the static open leg is
+ *    carved off the budget before the linear solve — and the `addMargin` amount
+ *    is the whole balance instead.
  * 6. Convert all final values to 18-decimal-wei `bigint`.
  *
  * @throws {SymmError} `INVALID_SLIPPAGE` / `SLIPPAGE_REQUIRED` /
- *   `SLIPPAGE_EXCEEDED` /
+ *   `SLIPPAGE_EXCEEDED` / `AMBIGUOUS_FUNDING` / `FULL_BALANCE_UNSUPPORTED` /
+ *   `INITIAL_MARGIN_REQUIRED` / `QUOTE_CONSTRAINT_VIOLATED` /
  *   `RESOLVE_MARKET_NOT_FOUND` /
  *   `RESOLVE_MARKET_METADATA_INCOMPLETE` /
  *   `RESOLVE_MARK_PRICE_NOT_FOUND` / `INVALID_TRADE_PARAMETERS` /
  *   `INVALID_SOLVER_FEE_CAP` for invalid inputs or an out-of-tolerance fill.
  */
-export declare function prepareInstantOpenParams(config: Config, parameters: PrepareInstantOpenParameters): Promise<InstantOpenParameters>;
+export declare function prepareInstantOpenParams(config: Config, parameters: PrepareInstantOpenParameters): Promise<PrepareInstantOpenParamsReturnType>;
+export {};
 //# sourceMappingURL=prepare-instant-open-params.d.ts.map

package/dist/solvers/instant-open/prepare-instant-open-params/prepare-instant-open-params.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prepare-instant-open-params.d.ts","sourceRoot":"","sources":["../../../../src/solvers/instant-open/prepare-instant-open-params/prepare-instant-open-params.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AACzC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,KAAK,EAAE,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AAEtF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2DAA2D,CAAC;AAC5F,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,qCAAqC,CAAC;AAC7F,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAgBnE,OAAO,EAAE,KAAK,qBAAqB,EAAE,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AA+BhF;;;;;;GAMG;AACH,MAAM,MAAM,4BAA4B,GAAG,OAAO,CAChD,oBAAoB,GAAG;IACrB,oCAAoC;IACpC,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,gGAAgG;IAChG,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;OAMG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,iCAAiC,CAAC;IACvD;;;OAGG;IACH,QAAQ,CAAC,EAAE,UAAU,CAAC;IACtB,kDAAkD;IAClD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kDAAkD;IAClD,aAAa,CAAC,EAAE,GAAG,CAAC;IACpB,kDAAkD;IAClD,aAAa,CAAC,EAAE,GAAG,CAAC;IACpB,kDAAkD;IAClD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CACF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,4BAA4B,GACvC,OAAO,CAAC,qBAAqB,CAAC,CAiOhC"}
+{"version":3,"file":"prepare-instant-open-params.d.ts","sourceRoot":"","sources":["../../../../src/solvers/instant-open/prepare-instant-open-params/prepare-instant-open-params.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,KAAK,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,MAAM,CAAC;AAC1D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,KAAK,EAAE,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AAEtF,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,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AASnE,OAAO,EAAE,KAAK,qBAAqB,EAAE,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AA+BhF;;;;;;GAMG;AACH;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,kBAAkB;IACjC,2DAA2D;IAC3D,IAAI,EAAE,cAAc,CAAC;IACrB,0EAA0E;IAC1E,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,KAAK,gCAAgC,GAAG,oBAAoB,GAAG;IAC7D,oCAAoC;IACpC,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,gGAAgG;IAChG,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;;OAOG;IACH,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,iCAAiC,CAAC;IACvD;;;OAGG;IACH,QAAQ,CAAC,EAAE,UAAU,CAAC;IACtB;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,kDAAkD;IAClD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,kDAAkD;IAClD,aAAa,CAAC,EAAE,GAAG,CAAC;IACpB,kDAAkD;IAClD,aAAa,CAAC,EAAE,GAAG,CAAC;IACpB,kDAAkD;IAClD,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,4BAA4B,GAAG,OAAO,CAChD,gCAAgC,GAAG;IACjC,sGAAsG;IACtG,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,IAAI,CAAC,EAAE,kBAAkB,CAAC;CAC3B,CACF,CAAC;AAEF,+FAA+F;AAC/F,MAAM,MAAM,kCAAkC,GAAG,qBAAqB,GAAG;IACvE,uFAAuF;IACvF,WAAW,EAAE,gBAAgB,GAAG,cAAc,CAAC;CAChD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqEG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,4BAA4B,GACvC,OAAO,CAAC,kCAAkC,CAAC,CA+Q7C"}

package/dist/solvers/instant-open/prepare-instant-open-params/prepare-instant-open-params.js

@@ -1,175 +1,195 @@
 import { SymmError as e } from "../../../shared/errors/symm-error.js";
-import { calculateExpectedSettlementLoss as t, calculateMargin as n, calculateSolverFees as r, calculateTradeParams as i, computePlatformFee as a, toWeiBigInt as o } from "../shared/trade-math.js";
-import { decimalPriceToWei as s } from "../../../shared/utils/price.js";
-import { assertOpenEstimateWithinSlippage as c, assertValidSlippage as l, deriveAutoSlippage as u, fetchOpenEstimatePrice as d } from "../shared/open-estimate-guard.js";
-import { resolveMarkPrice as f } from "../../shared/resolvers/resolve-mark-price.js";
-import { resolveMarket as p } from "../../shared/resolvers/resolve-market.js";
-import { resolveFeeRates as m } from "./resolvers/resolve-fee-rates.js";
-import { resolveLockedParams as h } from "./resolvers/resolve-locked-params.js";
+import { calculateTradeParams as t, toWeiBigInt as n } from "../shared/trade-math.js";
+import { decimalPriceToWei as r } from "../../../shared/utils/price.js";
+import { assertOpenEstimateWithinSlippage as i, assertValidSlippage as a, deriveAutoSlippage as o, fetchOpenEstimatePrice as s } from "../shared/open-estimate-guard.js";
+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 "./resolvers/resolve-locked-params.js";
+import { parseUnits as h } from "viem";
+import { RoundingMode as g, toDecimal as _ } from "@symmio/utils/decimal";
 //#region src/solvers/instant-open/prepare-instant-open-params/prepare-instant-open-params.ts
-var g = "0.01";
-function _(t, n) {
-	let r = s(n ?? g);
-	if (r === void 0) throw new e("validation", "INVALID_SOLVER_FEE_CAP", `prepareInstantOpenParams: market ${t} "${n}" is not a valid decimal ratio.`);
-	return r;
+var v = "0.01";
+function y(t, n) {
+	let i = r(n ?? v);
+	if (i === void 0) throw new e("validation", "INVALID_SOLVER_FEE_CAP", `prepareInstantOpenParams: market ${t} "${n}" is not a valid decimal ratio.`);
+	return i;
 }
-async function v(s, g) {
-	g.slippage !== void 0 && l(g.slippage);
-	let v = s.getSolver({
-		chainId: g.chainId,
-		solverId: g.solverId
+async function b(r, v) {
+	v.slippage !== void 0 && a(v.slippage);
+	let b = r.getSolver({
+		chainId: v.chainId,
+		solverId: v.solverId
 	}).id === "enigma";
-	if (g.slippage === void 0 && !v) throw new e("validation", "SLIPPAGE_REQUIRED", "prepareInstantOpenParams: slippage is required on this solver — auto-derived slippage is lowcap-only.");
-	let y = s.getChainConfig(g.chainId).contractsVersion === "0.8.6", b = await p(s, {
-		chainId: g.chainId,
-		solverId: g.solverId,
-		marketId: g.market.id,
-		marketName: g.market.name,
-		pricePrecision: g.market.pricePrecision,
-		quantityPrecision: g.market.quantityPrecision,
-		minOpenSolverFeeCap: g.market.minOpenSolverFeeCap,
-		minCloseSolverFeeCap: g.market.minCloseSolverFeeCap,
-		includeSolverFeeCaps: y,
-		hedgerFeeOpen: g.market.hedgerFeeOpen,
-		hedgerFeeClose: g.market.hedgerFeeClose,
-		hedgerFeeCloseEarlyRate: g.market.hedgerFeeCloseEarlyRate,
-		hedgerFeeCloseEarlyThreshold: g.market.hedgerFeeCloseEarlyThreshold,
-		hedgerFeeCloseStandardThreshold: g.market.hedgerFeeCloseStandardThreshold,
-		includeHedgerFees: v
-	}), [x, S, C] = await Promise.all([
-		f(s, {
-			chainId: g.chainId,
-			solverId: g.solverId,
-			marketName: b.name,
-			markPrice: g.markPrice
+	if (v.slippage === void 0 && !b) throw new e("validation", "SLIPPAGE_REQUIRED", "prepareInstantOpenParams: slippage is required on this solver — auto-derived slippage is lowcap-only.");
+	let x = v.fund !== void 0;
+	l({
+		...v,
+		isLowcap: b
+	});
+	let S = x || v.availableBalance !== void 0;
+	if (x && v.initialMargin !== void 0) throw new e("validation", "AMBIGUOUS_FUNDING", "prepareInstantOpenParams: pass exactly one of initialMargin or fund, not both.");
+	if (x && !b) throw new e("validation", "FULL_BALANCE_UNSUPPORTED", "prepareInstantOpenParams: full-balance funding is lowcap (Enigma) only — pass initialMargin on this solver.");
+	if (!x && v.initialMargin === void 0) throw new e("validation", "INITIAL_MARGIN_REQUIRED", "prepareInstantOpenParams: pass initialMargin, or fund: { mode: 'full-balance', balance } on a lowcap solver.");
+	let C = x ? v.fund.balance : v.initialMargin, w = r.getChainConfig(v.chainId).contractsVersion === "0.8.6", T = await f(r, {
+		chainId: v.chainId,
+		solverId: v.solverId,
+		marketId: v.market.id,
+		marketName: v.market.name,
+		pricePrecision: v.market.pricePrecision,
+		quantityPrecision: v.market.quantityPrecision,
+		minOpenSolverFeeCap: v.market.minOpenSolverFeeCap,
+		minCloseSolverFeeCap: v.market.minCloseSolverFeeCap,
+		includeSolverFeeCaps: w,
+		hedgerFeeOpen: v.market.hedgerFeeOpen,
+		hedgerFeeClose: v.market.hedgerFeeClose,
+		hedgerFeeCloseEarlyRate: v.market.hedgerFeeCloseEarlyRate,
+		hedgerFeeCloseEarlyThreshold: v.market.hedgerFeeCloseEarlyThreshold,
+		hedgerFeeCloseStandardThreshold: v.market.hedgerFeeCloseStandardThreshold,
+		includeHedgerFees: b,
+		includeQuoteConstraints: S,
+		minAcceptablePortionLf: v.market.minAcceptablePortionLf,
+		minAcceptableQuoteValue: v.market.minAcceptableQuoteValue,
+		maxNotionalValue: v.market.maxNotionalValue,
+		minNotionalValue: v.market.minNotionalValue,
+		maxQuantity: v.market.maxQuantity,
+		lotSize: v.market.lotSize
+	}), [E, D, O, k] = await Promise.all([
+		d(r, {
+			chainId: v.chainId,
+			solverId: v.solverId,
+			marketName: T.name,
+			markPrice: v.markPrice
+		}),
+		m(r, {
+			chainId: v.chainId,
+			solverId: v.solverId,
+			marketName: T.name,
+			leverage: v.leverage,
+			lockedParamPercent: v.lockedParamPercent
 		}),
-		h(s, {
-			chainId: g.chainId,
-			solverId: g.solverId,
-			marketName: b.name,
-			leverage: g.leverage,
-			lockedParamPercent: g.lockedParamPercent
+		u(r, {
+			chainId: v.chainId,
+			subAccountAddress: v.subAccountAddress,
+			marketId: v.market.id,
+			feeRates: v.feeRates
 		}),
-		m(s, {
-			chainId: g.chainId,
-			subAccountAddress: g.subAccountAddress,
-			marketId: g.market.id,
-			feeRates: g.feeRates
+		b ? p(r, {
+			chainId: v.chainId,
+			solverId: v.solverId,
+			solverInfo: v.solverInfo
+		}) : Promise.resolve({
+			staticSolverFeeOpen: "0",
+			staticSolverFeeClose: "0"
 		})
-	]), w = {
-		markPrice: x,
-		positionType: g.positionType,
-		userInput: g.initialMargin,
+	]), A = {
+		markPrice: E,
+		positionType: v.positionType,
+		userInput: C,
 		inputField: "PRICE",
-		leverage: g.leverage,
-		pricePrecision: b.pricePrecision,
-		quantityPrecision: b.quantityPrecision,
-		cvaPercent: S.cva,
-		lfPercent: S.lf,
-		partyAmmPercent: S.partyAmm,
-		partyBmmPercent: S.partyBmm
-	}, T = g.slippage, E = v ? g.estimatedOpenPrice : void 0;
-	if (T === void 0) {
-		let t = i({
-			...w,
+		leverage: v.leverage,
+		pricePrecision: T.pricePrecision,
+		quantityPrecision: T.quantityPrecision,
+		cvaPercent: D.cva,
+		lfPercent: D.lf,
+		partyAmmPercent: D.partyAmm,
+		partyBmmPercent: D.partyBmm
+	}, j = v.slippage, M = b ? v.estimatedOpenPrice ?? void 0 : void 0, N = b && v.estimatedOpenPrice === void 0;
+	if (j === void 0) {
+		let n = t({
+			...A,
 			slippage: 0
 		});
-		if (!t) throw new e("validation", "INVALID_TRADE_PARAMETERS", "Invalid trade parameters: markPrice or initialMargin is zero/NaN.");
-		v && E === void 0 && (E = await d(s, {
-			chainId: g.chainId,
-			solverId: g.solverId,
-			symbolId: g.market.id,
-			positionType: g.positionType,
-			quantity: t.quantity,
-			markPrice: x
-		})), T = u({
-			markPrice: x,
-			expectedFillPrice: E,
-			positionType: g.positionType
+		if (!n) throw new e("validation", "INVALID_TRADE_PARAMETERS", "Invalid trade parameters: markPrice or initialMargin is zero/NaN.");
+		N && (N = !1, M = await s(r, {
+			chainId: v.chainId,
+			solverId: v.solverId,
+			symbolId: v.market.id,
+			positionType: v.positionType,
+			quantity: n.quantity,
+			markPrice: E
+		})), j = o({
+			markPrice: E,
+			expectedFillPrice: M,
+			positionType: v.positionType
 		});
 	}
-	let D = i({
-		...w,
-		slippage: T
+	let P = t({
+		...A,
+		slippage: j
 	});
-	if (!D) throw new e("validation", "INVALID_TRADE_PARAMETERS", "Invalid trade parameters: markPrice or initialMargin is zero/NaN.");
-	v && E === void 0 && (E = await d(s, {
-		chainId: g.chainId,
-		solverId: g.solverId,
-		symbolId: g.market.id,
-		positionType: g.positionType,
-		quantity: D.quantity,
-		markPrice: x
-	})), E !== void 0 && await c(s, {
-		chainId: g.chainId,
-		solverId: g.solverId,
-		symbolId: g.market.id,
-		positionType: g.positionType,
-		quantity: D.quantity,
-		markPrice: x,
-		slippage: T,
-		expectedFillPrice: E
+	if (!P) throw new e("validation", "INVALID_TRADE_PARAMETERS", "Invalid trade parameters: markPrice or initialMargin is zero/NaN.");
+	N && (M = await s(r, {
+		chainId: v.chainId,
+		solverId: v.solverId,
+		symbolId: v.market.id,
+		positionType: v.positionType,
+		quantity: P.quantity,
+		markPrice: E
+	})), M !== void 0 && await i(r, {
+		chainId: v.chainId,
+		solverId: v.solverId,
+		symbolId: v.market.id,
+		positionType: v.positionType,
+		quantity: P.quantity,
+		markPrice: E,
+		slippage: j,
+		expectedFillPrice: M
 	});
-	let O = a(C, D.notional, D.notional), { openSolverFee: k, closeSolverFee: A } = v ? r({
-		notional: D.notional,
-		hedgerFeeOpen: b.hedgerFeeOpen,
-		hedgerFeeClose: b.hedgerFeeClose,
-		hedgerFeeCloseEarlyRate: b.hedgerFeeCloseEarlyRate,
-		hedgerFeeCloseEarlyThreshold: b.hedgerFeeCloseEarlyThreshold,
-		hedgerFeeCloseStandardThreshold: b.hedgerFeeCloseStandardThreshold
-	}) : {
-		openSolverFee: "0",
-		closeSolverFee: "0"
-	}, j = t({
-		positionType: g.positionType,
-		markPrice: x,
-		expectedFillPrice: E,
-		quantity: D.quantity
-	}), M = n({
-		positionType: g.positionType,
-		markPrice: x,
-		quantityBasic: D.quantityBasic,
-		cva: D.cva,
-		lf: D.lf,
-		partyAmm: D.partyAmm,
-		openSolverFee: k,
-		closeSolverFee: A,
-		expectedSettlementLoss: j,
-		shortFundingBufferPercent: +!!v,
-		cvaPercent: S.cva,
-		lfPercent: S.lf,
-		partyAmmPercent: S.partyAmm,
-		platformFee: O
+	let { trade: F, marginAmount: I, fundingMode: L } = c({
+		trade: P,
+		calculationInput: {
+			...A,
+			slippage: j
+		},
+		isLowcap: b,
+		fund: v.fund,
+		availableBalance: v.availableBalance,
+		expectedFillPrice: M,
+		feeRates: O,
+		hedgerFeeOpen: T.hedgerFeeOpen,
+		staticSolverFeeOpen: k.staticSolverFeeOpen,
+		constraints: {
+			minAcceptablePortionLf: T.minAcceptablePortionLf,
+			minAcceptableQuoteValue: T.minAcceptableQuoteValue,
+			maxNotionalValue: T.maxNotionalValue,
+			minNotionalValue: T.minNotionalValue,
+			maxQuantity: T.maxQuantity,
+			lotSize: T.lotSize
+		}
 	});
 	return {
-		chainId: g.chainId,
-		solverId: g.solverId,
-		from: g.from,
-		subAccountAddress: g.subAccountAddress,
-		marketId: g.market.id,
-		positionType: g.positionType,
+		fundingMode: L,
+		chainId: v.chainId,
+		solverId: v.solverId,
+		from: v.from,
+		subAccountAddress: v.subAccountAddress,
+		marketId: v.market.id,
+		positionType: v.positionType,
 		order: {
-			price: o(D.requestedOpenPrice),
-			quantity: o(D.quantity)
+			price: n(F.requestedOpenPrice),
+			quantity: n(F.quantity)
 		},
 		lockedParam: {
-			cva: o(D.cva),
-			lf: o(D.lf),
-			partyAmm: o(D.partyAmm),
-			partyBmm: o(D.partyBmm)
+			cva: n(F.cva),
+			lf: n(F.lf),
+			partyAmm: n(F.partyAmm),
+			partyBmm: n(F.partyBmm)
 		},
-		margin: { amount: o(M) },
-		...y ? { solverFeeCaps: {
-			openRateCap: _("minOpenSolverFeeCap", b.minOpenSolverFeeCap),
-			closeRateCap: _("minCloseSolverFeeCap", b.minCloseSolverFeeCap)
+		margin: { amount: h(_(I).toFixed(18, g.ROUND_DOWN), 18) },
+		...w ? { solverFeeCaps: {
+			openRateCap: y("minOpenSolverFeeCap", T.minOpenSolverFeeCap),
+			closeRateCap: y("minCloseSolverFeeCap", T.minCloseSolverFeeCap)
 		} } : {},
-		uuid: g.uuid,
-		addMarginSalt: g.addMarginSalt,
-		sendQuoteSalt: g.sendQuoteSalt,
-		deadline: g.deadline
+		uuid: v.uuid,
+		addMarginSalt: v.addMarginSalt,
+		sendQuoteSalt: v.sendQuoteSalt,
+		deadline: v.deadline
 	};
 }
 //#endregion
-export { v as prepareInstantOpenParams };
+export { b as prepareInstantOpenParams };
 
 //# sourceMappingURL=prepare-instant-open-params.js.map