@symmio/trading-core 0.1.0

package/dist/solvers/instant-open/shared/hedger-api.js

@@ -0,0 +1,19 @@
+import { SymmApiError as e, SymmError as t } from "../../../shared/errors/symm-error.js";
+import { postInstantTradeInstantOpen as n } from "../../types/generated/enigma-solver.js";
+import { isAxiosError as r } from "axios";
+//#region src/solvers/instant-open/shared/hedger-api.ts
+async function i(i, a) {
+	let { solver: o } = i.getChainConfig(a.chainId);
+	try {
+		return (await n(a.request, { baseURL: o.url })).data;
+	} catch (n) {
+		throw n instanceof t ? n : r(n) ? e.fromAxios(n, {
+			code: "SEND_INSTANT_OPEN_FAILED",
+			baseURL: o.url
+		}) : new t("api", "SEND_INSTANT_OPEN_FAILED", `Failed to send instant open: ${n instanceof Error ? n.message : String(n)}`, { cause: n instanceof Error ? n : void 0 });
+	}
+}
+//#endregion
+export { i as sendInstantOpen };
+
+//# sourceMappingURL=hedger-api.js.map

package/dist/solvers/instant-open/shared/hedger-api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hedger-api.js","names":[],"sources":["../../../../src/solvers/instant-open/shared/hedger-api.ts"],"sourcesContent":["import { isAxiosError } from \"axios\";\nimport type { Config } from \"../../../core/config\";\nimport { SymmApiError, SymmError } from \"../../../shared/errors/symm-error\";\nimport type { ChainIdParameter, Compute } from \"../../../shared/types/properties\";\nimport {\n  postInstantTradeInstantOpen,\n  type ApiPostInstantOpenResponse,\n  type ApiV2InstantOpenRequest,\n} from \"../../types/generated/enigma-solver\";\n\n/**\n * Response shape from the hedger's `/instant_trade/instant_open` endpoint.\n *\n * Re-exported from the orval-generated client so consumers can read the raw\n * response without importing the generated module directly.\n */\nexport type SendInstantOpenReturnType = ApiPostInstantOpenResponse;\n\n/**\n * Parameters for {@link sendInstantOpen}.\n */\nexport type SendInstantOpenParameters = Compute<\n  ChainIdParameter & {\n    /** Pre-signed addMargin + sendQuote payloads (the orval `ApiV2InstantOpenRequest` shape). */\n    request: ApiV2InstantOpenRequest;\n  }\n>;\n\n/**\n * Submit a v2 instant open request to the chain's hedger.\n *\n * Wraps the orval-generated `postInstantTradeInstantOpen` with the chain's\n * solver/hedger base URL and SDK error wrapping.\n *\n * @throws {SymmApiError} when the hedger request fails.\n * @throws {SymmError} when the chain is unsupported.\n */\nexport async function sendInstantOpen(\n  config: Config,\n  parameters: SendInstantOpenParameters,\n): Promise<SendInstantOpenReturnType> {\n  const { solver } = config.getChainConfig(parameters.chainId);\n  try {\n    const response = await postInstantTradeInstantOpen(parameters.request, { baseURL: solver.url });\n    return response.data;\n  } catch (err) {\n    if (err instanceof SymmError) throw err;\n\n    if (isAxiosError(err)) {\n      throw SymmApiError.fromAxios(err, {\n        code: \"SEND_INSTANT_OPEN_FAILED\",\n        baseURL: solver.url,\n      });\n    }\n\n    throw new SymmError(\n      \"api\",\n      \"SEND_INSTANT_OPEN_FAILED\",\n      `Failed to send instant open: ${err instanceof Error ? err.message : String(err)}`,\n      { cause: err instanceof Error ? err : undefined },\n    );\n  }\n}\n"],"mappings":";;;;AAqCA,eAAsB,EACpB,GACA,GACoC;CACpC,IAAM,EAAE,cAAW,EAAO,eAAe,EAAW,OAAO;CAC3D,IAAI;EAEF,QAAO,MADgB,EAA4B,EAAW,SAAS,EAAE,SAAS,EAAO,IAAI,CAAC,GAC9E;CAClB,SAAS,GAAK;EAUZ,MATI,aAAe,IAAiB,IAEhC,EAAa,CAAG,IACZ,EAAa,UAAU,GAAK;GAChC,MAAM;GACN,SAAS,EAAO;EAClB,CAAC,IAGG,IAAI,EACR,OACA,4BACA,gCAAgC,aAAe,QAAQ,EAAI,UAAU,OAAO,CAAG,KAC/E,EAAE,OAAO,aAAe,QAAQ,IAAM,KAAA,EAAU,CAClD;CACF;AACF"}

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

@@ -0,0 +1,9 @@
+export * from './calldata';
+export * from './eip712';
+export * from './hedger-api';
+export * from './operations';
+export * from './quote-constraints';
+export * from './selectors';
+export * from './trade-math';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/solvers/instant-open/shared/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,SAAS,CAAC"}

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

@@ -0,0 +1,67 @@
+import { Address, Hex } from 'viem';
+import { Config, SymmioWalletClient } from '../../../core/config';
+import { InstantOperationPayload, SignedOperation, SignedOperationPayload } from './types';
+/**
+ * Generate a random 32-byte hex salt.
+ *
+ * Uses `globalThis.crypto.getRandomValues`. Available in modern Node (≥19) and
+ * every browser. Caller can pass an explicit `salt` to `buildSignedOperation`
+ * for deterministic tests.
+ */
+export declare function generateSalt(): Hex;
+/**
+ * Parameters for {@link buildSignedOperation}.
+ */
+export interface BuildSignedOperationParameters {
+    /** Session-key signer address. */
+    signer: Address;
+    /** Contract to call (account-layer for addMargin, symmio diamond for sendQuote). */
+    target: Address;
+    /** ABI-encoded calldata for the `target` call. */
+    callData: Hex;
+    /** Sub-account / partyA address (the account whose authority the op runs under). */
+    signerAccount: Address;
+    /** Unix-seconds deadline. */
+    deadline: bigint;
+    /** Operation nonce. Defaults to `0n` (single-use). */
+    nonce?: bigint;
+    /** Override the random salt. Defaults to a fresh `generateSalt()` result. */
+    salt?: Hex;
+}
+/**
+ * Build an unsigned {@link SignedOperation} struct.
+ *
+ * `flexFields` is always empty and `maxUses` is always `1n` for lowcap flows.
+ * Pass `salt` to make the result deterministic in tests; otherwise a random
+ * 32-byte salt is generated.
+ */
+export declare function buildSignedOperation(parameters: BuildSignedOperationParameters): SignedOperation;
+/**
+ * Serialize a {@link SignedOperation} to the wire-format expected by the hedger
+ * REST API.
+ *
+ * `bigint` fields convert to `number` via `Number()` to match the orval-typed
+ * `Eip712SignedOperationJSON` schema. All values used in lowcap flows
+ * (`maxUses=1`, `nonce=0`, `deadline≈unix seconds`) fit safely in JS `number`.
+ */
+export declare function formatSignedOperationPayload(operation: SignedOperation): SignedOperationPayload;
+/**
+ * Parameters for {@link signAndFormatInstantOperation}.
+ */
+export interface SignAndFormatInstantOperationParameters {
+    /** The operation to sign. */
+    operation: SignedOperation;
+    /** Optional chain id; defaults to the config's `defaultChainId`. */
+    chainId?: number;
+    /** Resolved wallet client whose hoisted account performs the EIP-712 signing. */
+    walletClient: SymmioWalletClient;
+}
+/**
+ * EIP-712 sign a {@link SignedOperation} and format it as the API payload
+ * `{ signedOperation, signature }`.
+ *
+ * Domain is resolved from the chain config (`instantLayerEip712Domain` + the
+ * chain's `instantLayerAddress` as `verifyingContract`).
+ */
+export declare function signAndFormatInstantOperation(config: Config, parameters: SignAndFormatInstantOperationParameters): Promise<InstantOperationPayload>;
+//# sourceMappingURL=operations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["../../../../src/solvers/instant-open/shared/operations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AACzC,OAAO,KAAK,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAEvE,OAAO,KAAK,EAAE,uBAAuB,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAEhG;;;;;;GAMG;AACH,wBAAgB,YAAY,IAAI,GAAG,CAMlC;AAED;;GAEG;AACH,MAAM,WAAW,8BAA8B;IAC7C,kCAAkC;IAClC,MAAM,EAAE,OAAO,CAAC;IAChB,oFAAoF;IACpF,MAAM,EAAE,OAAO,CAAC;IAChB,kDAAkD;IAClD,QAAQ,EAAE,GAAG,CAAC;IACd,oFAAoF;IACpF,aAAa,EAAE,OAAO,CAAC;IACvB,6BAA6B;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,sDAAsD;IACtD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6EAA6E;IAC7E,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,8BAA8B,GAAG,eAAe,CAiBhG;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,eAAe,GAAG,sBAAsB,CAkB/F;AAED;;GAEG;AACH,MAAM,WAAW,uCAAuC;IACtD,6BAA6B;IAC7B,SAAS,EAAE,eAAe,CAAC;IAC3B,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iFAAiF;IACjF,YAAY,EAAE,kBAAkB,CAAC;CAClC;AAED;;;;;;GAMG;AACH,wBAAsB,6BAA6B,CACjD,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,uCAAuC,GAClD,OAAO,CAAC,uBAAuB,CAAC,CAOlC"}

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

@@ -0,0 +1,60 @@
+import { getInstantLayerEip712Domain as e, signSignedOperation as t } from "./eip712.js";
+//#region src/solvers/instant-open/shared/operations.ts
+function n() {
+	let e = new Uint8Array(32);
+	globalThis.crypto.getRandomValues(e);
+	let t = "0x";
+	for (let n of e) t += n.toString(16).padStart(2, "0");
+	return t;
+}
+function r(e) {
+	return {
+		signer: e.signer,
+		target: e.target,
+		callData: e.callData,
+		signerAccount: {
+			addr: e.signerAccount,
+			isPartyB: !1
+		},
+		flexFields: [],
+		maxUses: 1n,
+		replayAttackHeader: {
+			nonce: e.nonce ?? 0n,
+			deadline: e.deadline,
+			salt: e.salt ?? n()
+		}
+	};
+}
+function i(e) {
+	return {
+		signer: e.signer,
+		target: e.target,
+		callData: e.callData,
+		signerAccount: {
+			addr: e.signerAccount.addr,
+			isPartyB: e.signerAccount.isPartyB
+		},
+		flexFields: e.flexFields.map((e) => ({
+			offset: Number(e.offset),
+			length: Number(e.length),
+			authorizedFlexFiller: e.authorizedFlexFiller
+		})),
+		maxUses: Number(e.maxUses),
+		replayAttackHeader: {
+			nonce: Number(e.replayAttackHeader.nonce),
+			deadline: Number(e.replayAttackHeader.deadline),
+			salt: e.replayAttackHeader.salt
+		}
+	};
+}
+async function a(n, r) {
+	let a = e(n, { chainId: r.chainId }), o = await t(r.operation, a, r.walletClient);
+	return {
+		signedOperation: i(r.operation),
+		signature: o
+	};
+}
+//#endregion
+export { r as buildSignedOperation, i as formatSignedOperationPayload, n as generateSalt, a as signAndFormatInstantOperation };
+
+//# sourceMappingURL=operations.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"operations.js","names":[],"sources":["../../../../src/solvers/instant-open/shared/operations.ts"],"sourcesContent":["import type { Address, Hex } from \"viem\";\nimport type { Config, SymmioWalletClient } from \"../../../core/config\";\nimport { getInstantLayerEip712Domain, signSignedOperation } from \"./eip712\";\nimport type { InstantOperationPayload, SignedOperation, SignedOperationPayload } from \"./types\";\n\n/**\n * Generate a random 32-byte hex salt.\n *\n * Uses `globalThis.crypto.getRandomValues`. Available in modern Node (≥19) and\n * every browser. Caller can pass an explicit `salt` to `buildSignedOperation`\n * for deterministic tests.\n */\nexport function generateSalt(): Hex {\n  const bytes = new Uint8Array(32);\n  globalThis.crypto.getRandomValues(bytes);\n  let hex = \"0x\";\n  for (const b of bytes) hex += b.toString(16).padStart(2, \"0\");\n  return hex as Hex;\n}\n\n/**\n * Parameters for {@link buildSignedOperation}.\n */\nexport interface BuildSignedOperationParameters {\n  /** Session-key signer address. */\n  signer: Address;\n  /** Contract to call (account-layer for addMargin, symmio diamond for sendQuote). */\n  target: Address;\n  /** ABI-encoded calldata for the `target` call. */\n  callData: Hex;\n  /** Sub-account / partyA address (the account whose authority the op runs under). */\n  signerAccount: Address;\n  /** Unix-seconds deadline. */\n  deadline: bigint;\n  /** Operation nonce. Defaults to `0n` (single-use). */\n  nonce?: bigint;\n  /** Override the random salt. Defaults to a fresh `generateSalt()` result. */\n  salt?: Hex;\n}\n\n/**\n * Build an unsigned {@link SignedOperation} struct.\n *\n * `flexFields` is always empty and `maxUses` is always `1n` for lowcap flows.\n * Pass `salt` to make the result deterministic in tests; otherwise a random\n * 32-byte salt is generated.\n */\nexport function buildSignedOperation(parameters: BuildSignedOperationParameters): SignedOperation {\n  return {\n    signer: parameters.signer,\n    target: parameters.target,\n    callData: parameters.callData,\n    signerAccount: {\n      addr: parameters.signerAccount,\n      isPartyB: false,\n    },\n    flexFields: [],\n    maxUses: 1n,\n    replayAttackHeader: {\n      nonce: parameters.nonce ?? 0n,\n      deadline: parameters.deadline,\n      salt: parameters.salt ?? generateSalt(),\n    },\n  };\n}\n\n/**\n * Serialize a {@link SignedOperation} to the wire-format expected by the hedger\n * REST API.\n *\n * `bigint` fields convert to `number` via `Number()` to match the orval-typed\n * `Eip712SignedOperationJSON` schema. All values used in lowcap flows\n * (`maxUses=1`, `nonce=0`, `deadline≈unix seconds`) fit safely in JS `number`.\n */\nexport function formatSignedOperationPayload(operation: SignedOperation): SignedOperationPayload {\n  return {\n    signer: operation.signer,\n    target: operation.target,\n    callData: operation.callData,\n    signerAccount: { addr: operation.signerAccount.addr, isPartyB: operation.signerAccount.isPartyB },\n    flexFields: operation.flexFields.map((f) => ({\n      offset: Number(f.offset),\n      length: Number(f.length),\n      authorizedFlexFiller: f.authorizedFlexFiller,\n    })),\n    maxUses: Number(operation.maxUses),\n    replayAttackHeader: {\n      nonce: Number(operation.replayAttackHeader.nonce),\n      deadline: Number(operation.replayAttackHeader.deadline),\n      salt: operation.replayAttackHeader.salt,\n    },\n  };\n}\n\n/**\n * Parameters for {@link signAndFormatInstantOperation}.\n */\nexport interface SignAndFormatInstantOperationParameters {\n  /** The operation to sign. */\n  operation: SignedOperation;\n  /** Optional chain id; defaults to the config's `defaultChainId`. */\n  chainId?: number;\n  /** Resolved wallet client whose hoisted account performs the EIP-712 signing. */\n  walletClient: SymmioWalletClient;\n}\n\n/**\n * EIP-712 sign a {@link SignedOperation} and format it as the API payload\n * `{ signedOperation, signature }`.\n *\n * Domain is resolved from the chain config (`instantLayerEip712Domain` + the\n * chain's `instantLayerAddress` as `verifyingContract`).\n */\nexport async function signAndFormatInstantOperation(\n  config: Config,\n  parameters: SignAndFormatInstantOperationParameters,\n): Promise<InstantOperationPayload> {\n  const domain = getInstantLayerEip712Domain(config, { chainId: parameters.chainId });\n  const signature = await signSignedOperation(parameters.operation, domain, parameters.walletClient);\n  return {\n    signedOperation: formatSignedOperationPayload(parameters.operation),\n    signature,\n  };\n}\n"],"mappings":";;AAYA,SAAgB,IAAoB;CAClC,IAAM,IAAQ,IAAI,WAAW,EAAE;CAC/B,WAAW,OAAO,gBAAgB,CAAK;CACvC,IAAI,IAAM;CACV,KAAK,IAAM,KAAK,GAAO,KAAO,EAAE,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG;CAC5D,OAAO;AACT;AA6BA,SAAgB,EAAqB,GAA6D;CAChG,OAAO;EACL,QAAQ,EAAW;EACnB,QAAQ,EAAW;EACnB,UAAU,EAAW;EACrB,eAAe;GACb,MAAM,EAAW;GACjB,UAAU;EACZ;EACA,YAAY,CAAC;EACb,SAAS;EACT,oBAAoB;GAClB,OAAO,EAAW,SAAS;GAC3B,UAAU,EAAW;GACrB,MAAM,EAAW,QAAQ,EAAa;EACxC;CACF;AACF;AAUA,SAAgB,EAA6B,GAAoD;CAC/F,OAAO;EACL,QAAQ,EAAU;EAClB,QAAQ,EAAU;EAClB,UAAU,EAAU;EACpB,eAAe;GAAE,MAAM,EAAU,cAAc;GAAM,UAAU,EAAU,cAAc;EAAS;EAChG,YAAY,EAAU,WAAW,KAAK,OAAO;GAC3C,QAAQ,OAAO,EAAE,MAAM;GACvB,QAAQ,OAAO,EAAE,MAAM;GACvB,sBAAsB,EAAE;EAC1B,EAAE;EACF,SAAS,OAAO,EAAU,OAAO;EACjC,oBAAoB;GAClB,OAAO,OAAO,EAAU,mBAAmB,KAAK;GAChD,UAAU,OAAO,EAAU,mBAAmB,QAAQ;GACtD,MAAM,EAAU,mBAAmB;EACrC;CACF;AACF;AAqBA,eAAsB,EACpB,GACA,GACkC;CAClC,IAAM,IAAS,EAA4B,GAAQ,EAAE,SAAS,EAAW,QAAQ,CAAC,GAC5E,IAAY,MAAM,EAAoB,EAAW,WAAW,GAAQ,EAAW,YAAY;CACjG,OAAO;EACL,iBAAiB,EAA6B,EAAW,SAAS;EAClE;CACF;AACF"}

package/dist/solvers/instant-open/shared/quote-constraints.d.ts

@@ -0,0 +1,138 @@
+import { PositionType } from '../../../symmio-contracts/symmio/types';
+import { MarketNotionalCap } from '../../notional-cap/types';
+import { SymbolContractSymbol } from '../../types/generated/enigma-solver';
+/**
+ * One reason a candidate instant-open quote violates the market's published
+ * quote constraints. Returned in a list by
+ * {@link validateInstantOpenAgainstMarket} so UIs can render the full set of
+ * problems in one pass instead of fixing-and-resubmitting.
+ *
+ * All numeric fields are decimal strings (no rounding hop) so callers can
+ * format them however they like.
+ */
+export type QuoteConstraintViolation = {
+    kind: "LF_PORTION_TOO_LOW";
+    /** Market's `min_acceptable_portion_lf` (decimal fraction, e.g. `"0.1"`). */
+    minPortion: string;
+    /** Actual `lf / (cva + lf + partyAmm)` for the supplied locked margins. */
+    actualPortion: string;
+} | {
+    kind: "QUOTE_VALUE_TOO_LOW";
+    /** Market's `min_acceptable_quote_value`. */
+    minQuoteValue: string;
+    /** Total locked margin `cva + lf + partyAmm` from {@link calculateTradeParams}. */
+    actualQuoteValue: string;
+} | {
+    kind: "NOTIONAL_TOO_HIGH";
+    /** Market's `max_notional_value`. */
+    maxNotional: string;
+    /** `markPrice × quantity`. */
+    actualNotional: string;
+} | {
+    kind: "NOTIONAL_TOO_LOW";
+    /** Market's `min_notional_value`. */
+    minNotional: string;
+    /** `markPrice × quantity`. */
+    actualNotional: string;
+} | {
+    kind: "QUANTITY_TOO_HIGH";
+    /** Market's `max_quantity`. */
+    maxQuantity: string;
+    /** Final leveraged quantity. */
+    actualQuantity: string;
+} | {
+    kind: "QUANTITY_BELOW_LOT_SIZE";
+    /** Market's `lot_size` — the smallest tradable quantity. */
+    lotSize: string;
+    /** Final leveraged quantity. */
+    actualQuantity: string;
+} | {
+    kind: "QUANTITY_NOT_LOT_MULTIPLE";
+    /** Market's `lot_size` — quantity must be an integer multiple of this step. */
+    lotSize: string;
+    /** Final leveraged quantity. */
+    actualQuantity: string;
+} | {
+    kind: "CAP_REACHED";
+    /** Side the trade was on. */
+    side: PositionType;
+    /** Available liquidity on that side, dollars (decimal string). */
+    available: string;
+    /** Requested notional, dollars (decimal string). */
+    actualNotional: string;
+};
+/**
+ * Inputs to {@link validateInstantOpenAgainstMarket}.
+ *
+ * All numeric fields are decimal strings (matching the shape that
+ * `calculateTradeParams` returns) so callers don't need to convert to wei
+ * before validating. `market` comes from `getMarkets` (`/contract-symbols`);
+ * `cva` / `lf` / `partyAmm` / `quantity` come straight off
+ * {@link calculateTradeParams}.
+ */
+export interface ValidateInstantOpenAgainstMarketParameters {
+    /** Market metadata carrying the constraint fields. */
+    market: SymbolContractSymbol;
+    /** Final leveraged quote quantity (decimal string, e.g. `"1.25"`). */
+    quantity: string;
+    /** Current mark price (decimal string) — used for the notional bounds. */
+    markPrice: string;
+    /** CVA locked margin from {@link calculateTradeParams} (decimal string). */
+    cva: string;
+    /** LF locked margin from {@link calculateTradeParams} (decimal string). */
+    lf: string;
+    /** PartyA maintenance margin from {@link calculateTradeParams} (decimal string). */
+    partyAmm: string;
+    /**
+     * Optional solver-side liquidity cap for the market. When provided alongside
+     * {@link positionType}, the validator rejects trades whose notional exceeds
+     * the chosen side's available liquidity (`CAP_REACHED`). When the cap carries
+     * a non-null `error`, the check is skipped.
+     */
+    notionalCap?: MarketNotionalCap;
+    /** Side of the candidate trade — required for the {@link notionalCap} check. */
+    positionType?: PositionType;
+}
+/** Result of {@link validateInstantOpenAgainstMarket}. */
+export interface ValidateInstantOpenAgainstMarketReturnType {
+    /** `true` when no violations fired. */
+    ok: boolean;
+    /** Every violation the candidate quote hit; empty when `ok` is `true`. */
+    violations: QuoteConstraintViolation[];
+}
+/**
+ * Check a candidate instant-open quote against the market's published quote
+ * constraints. Each constraint is independent and skipped when the market
+ * doesn't publish that field, so a partial constraint set (e.g. a market
+ * without `max_quantity`) still validates the rest.
+ *
+ * Constraints (each maps to a {@link QuoteConstraintViolation}):
+ * - **`min_acceptable_portion_lf`** — `lf / (cva + lf + partyAmm)` must be at
+ *   least the published minimum.
+ * - **`min_acceptable_quote_value`** — the locked-margin sum
+ *   `cva + lf + partyAmm` must clear the floor.
+ * - **`max_notional_value`** — `markPrice × quantity` must be at most the cap.
+ * - **`min_notional_value`** — `markPrice × quantity` must clear the floor.
+ * - **`max_quantity`** — `quantity` must be at most the cap.
+ * - **`lot_size`** — `quantity` must be at least `lot_size` and an integer
+ *   multiple of it (e.g. lot_size `0.2` allows 0.2, 0.4, 0.6, … but not 0.3).
+ *
+ * @example
+ * ```ts
+ * const trade = calculateTradeParams({ ... });
+ * if (!trade) return;
+ * const { ok, violations } = validateInstantOpenAgainstMarket({
+ *   market,
+ *   quantity: trade.quantity,
+ *   markPrice,
+ *   cva: trade.cva,
+ *   lf: trade.lf,
+ *   partyAmm: trade.partyAmm,
+ * });
+ * if (!ok) {
+ *   // render `violations` to the user; don't call `instantOpen`.
+ * }
+ * ```
+ */
+export declare function validateInstantOpenAgainstMarket(parameters: ValidateInstantOpenAgainstMarketParameters): ValidateInstantOpenAgainstMarketReturnType;
+//# sourceMappingURL=quote-constraints.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"quote-constraints.d.ts","sourceRoot":"","sources":["../../../../src/solvers/instant-open/shared/quote-constraints.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wCAAwC,CAAC;AAE3E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAEhF;;;;;;;;GAQG;AACH,MAAM,MAAM,wBAAwB,GAChC;IACE,IAAI,EAAE,oBAAoB,CAAC;IAC3B,6EAA6E;IAC7E,UAAU,EAAE,MAAM,CAAC;IACnB,2EAA2E;IAC3E,aAAa,EAAE,MAAM,CAAC;CACvB,GACD;IACE,IAAI,EAAE,qBAAqB,CAAC;IAC5B,6CAA6C;IAC7C,aAAa,EAAE,MAAM,CAAC;IACtB,mFAAmF;IACnF,gBAAgB,EAAE,MAAM,CAAC;CAC1B,GACD;IACE,IAAI,EAAE,mBAAmB,CAAC;IAC1B,qCAAqC;IACrC,WAAW,EAAE,MAAM,CAAC;IACpB,8BAA8B;IAC9B,cAAc,EAAE,MAAM,CAAC;CACxB,GACD;IACE,IAAI,EAAE,kBAAkB,CAAC;IACzB,qCAAqC;IACrC,WAAW,EAAE,MAAM,CAAC;IACpB,8BAA8B;IAC9B,cAAc,EAAE,MAAM,CAAC;CACxB,GACD;IACE,IAAI,EAAE,mBAAmB,CAAC;IAC1B,+BAA+B;IAC/B,WAAW,EAAE,MAAM,CAAC;IACpB,gCAAgC;IAChC,cAAc,EAAE,MAAM,CAAC;CACxB,GACD;IACE,IAAI,EAAE,yBAAyB,CAAC;IAChC,4DAA4D;IAC5D,OAAO,EAAE,MAAM,CAAC;IAChB,gCAAgC;IAChC,cAAc,EAAE,MAAM,CAAC;CACxB,GACD;IACE,IAAI,EAAE,2BAA2B,CAAC;IAClC,+EAA+E;IAC/E,OAAO,EAAE,MAAM,CAAC;IAChB,gCAAgC;IAChC,cAAc,EAAE,MAAM,CAAC;CACxB,GACD;IACE,IAAI,EAAE,aAAa,CAAC;IACpB,6BAA6B;IAC7B,IAAI,EAAE,YAAY,CAAC;IACnB,kEAAkE;IAClE,SAAS,EAAE,MAAM,CAAC;IAClB,oDAAoD;IACpD,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAEN;;;;;;;;GAQG;AACH,MAAM,WAAW,0CAA0C;IACzD,sDAAsD;IACtD,MAAM,EAAE,oBAAoB,CAAC;IAC7B,sEAAsE;IACtE,QAAQ,EAAE,MAAM,CAAC;IACjB,0EAA0E;IAC1E,SAAS,EAAE,MAAM,CAAC;IAClB,4EAA4E;IAC5E,GAAG,EAAE,MAAM,CAAC;IACZ,2EAA2E;IAC3E,EAAE,EAAE,MAAM,CAAC;IACX,oFAAoF;IACpF,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,iBAAiB,CAAC;IAChC,gFAAgF;IAChF,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B;AAED,0DAA0D;AAC1D,MAAM,WAAW,0CAA0C;IACzD,uCAAuC;IACvC,EAAE,EAAE,OAAO,CAAC;IACZ,0EAA0E;IAC1E,UAAU,EAAE,wBAAwB,EAAE,CAAC;CACxC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,gCAAgC,CAC9C,UAAU,EAAE,0CAA0C,GACrD,0CAA0C,CA8G5C"}

package/dist/solvers/instant-open/shared/quote-constraints.js

@@ -0,0 +1,82 @@
+import { checkNotionalCap as e } from "../../notional-cap/check-notional-cap.js";
+import { toDecimal as t } from "@symmio/utils/decimal";
+//#region src/solvers/instant-open/shared/quote-constraints.ts
+function n(n) {
+	let { market: r, quantity: i, markPrice: a, cva: o, lf: s, partyAmm: c, notionalCap: l, positionType: u } = n, d = [], f = t(o), p = t(s), m = t(c), h = f.plus(p).plus(m), g = r.min_acceptable_portion_lf;
+	if (g && !h.isZero() && !h.isNaN()) {
+		let e = p.div(h), n = t(g);
+		e.lt(n) && d.push({
+			kind: "LF_PORTION_TOO_LOW",
+			minPortion: n.toString(),
+			actualPortion: e.toString()
+		});
+	}
+	let _ = r.min_acceptable_quote_value;
+	if (_) {
+		let e = t(_);
+		h.lt(e) && d.push({
+			kind: "QUOTE_VALUE_TOO_LOW",
+			minQuoteValue: e.toString(),
+			actualQuoteValue: h.toString()
+		});
+	}
+	let v = t(a).times(i);
+	if (r.max_notional_value !== void 0) {
+		let e = t(r.max_notional_value);
+		v.gt(e) && d.push({
+			kind: "NOTIONAL_TOO_HIGH",
+			maxNotional: e.toString(),
+			actualNotional: v.toString()
+		});
+	}
+	if (r.min_notional_value) {
+		let e = t(r.min_notional_value);
+		v.lt(e) && d.push({
+			kind: "NOTIONAL_TOO_LOW",
+			minNotional: e.toString(),
+			actualNotional: v.toString()
+		});
+	}
+	let y = t(i);
+	if (r.max_quantity) {
+		let e = t(r.max_quantity);
+		y.gt(e) && d.push({
+			kind: "QUANTITY_TOO_HIGH",
+			maxQuantity: e.toString(),
+			actualQuantity: y.toString()
+		});
+	}
+	if (r.lot_size) {
+		let e = t(r.lot_size);
+		e.gt(0) && !e.isNaN() && (y.lt(e) ? d.push({
+			kind: "QUANTITY_BELOW_LOT_SIZE",
+			lotSize: e.toString(),
+			actualQuantity: y.toString()
+		}) : y.mod(e).isZero() || d.push({
+			kind: "QUANTITY_NOT_LOT_MULTIPLE",
+			lotSize: e.toString(),
+			actualQuantity: y.toString()
+		}));
+	}
+	if (l && u !== void 0) {
+		let t = e({
+			positionType: u,
+			notional: v.toString(),
+			cap: l
+		});
+		t.ok || d.push({
+			kind: "CAP_REACHED",
+			side: t.side,
+			available: String(t.available),
+			actualNotional: t.requestedNotional
+		});
+	}
+	return {
+		ok: d.length === 0,
+		violations: d
+	};
+}
+//#endregion
+export { n as validateInstantOpenAgainstMarket };
+
+//# sourceMappingURL=quote-constraints.js.map

package/dist/solvers/instant-open/shared/quote-constraints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"quote-constraints.js","names":[],"sources":["../../../../src/solvers/instant-open/shared/quote-constraints.ts"],"sourcesContent":["import { toDecimal } from \"@symmio/utils/decimal\";\nimport type { PositionType } from \"../../../symmio-contracts/symmio/types\";\nimport { checkNotionalCap } from \"../../notional-cap/check-notional-cap\";\nimport type { MarketNotionalCap } from \"../../notional-cap/types\";\nimport type { SymbolContractSymbol } from \"../../types/generated/enigma-solver\";\n\n/**\n * One reason a candidate instant-open quote violates the market's published\n * quote constraints. Returned in a list by\n * {@link validateInstantOpenAgainstMarket} so UIs can render the full set of\n * problems in one pass instead of fixing-and-resubmitting.\n *\n * All numeric fields are decimal strings (no rounding hop) so callers can\n * format them however they like.\n */\nexport type QuoteConstraintViolation =\n  | {\n      kind: \"LF_PORTION_TOO_LOW\";\n      /** Market's `min_acceptable_portion_lf` (decimal fraction, e.g. `\"0.1\"`). */\n      minPortion: string;\n      /** Actual `lf / (cva + lf + partyAmm)` for the supplied locked margins. */\n      actualPortion: string;\n    }\n  | {\n      kind: \"QUOTE_VALUE_TOO_LOW\";\n      /** Market's `min_acceptable_quote_value`. */\n      minQuoteValue: string;\n      /** Total locked margin `cva + lf + partyAmm` from {@link calculateTradeParams}. */\n      actualQuoteValue: string;\n    }\n  | {\n      kind: \"NOTIONAL_TOO_HIGH\";\n      /** Market's `max_notional_value`. */\n      maxNotional: string;\n      /** `markPrice × quantity`. */\n      actualNotional: string;\n    }\n  | {\n      kind: \"NOTIONAL_TOO_LOW\";\n      /** Market's `min_notional_value`. */\n      minNotional: string;\n      /** `markPrice × quantity`. */\n      actualNotional: string;\n    }\n  | {\n      kind: \"QUANTITY_TOO_HIGH\";\n      /** Market's `max_quantity`. */\n      maxQuantity: string;\n      /** Final leveraged quantity. */\n      actualQuantity: string;\n    }\n  | {\n      kind: \"QUANTITY_BELOW_LOT_SIZE\";\n      /** Market's `lot_size` — the smallest tradable quantity. */\n      lotSize: string;\n      /** Final leveraged quantity. */\n      actualQuantity: string;\n    }\n  | {\n      kind: \"QUANTITY_NOT_LOT_MULTIPLE\";\n      /** Market's `lot_size` — quantity must be an integer multiple of this step. */\n      lotSize: string;\n      /** Final leveraged quantity. */\n      actualQuantity: string;\n    }\n  | {\n      kind: \"CAP_REACHED\";\n      /** Side the trade was on. */\n      side: PositionType;\n      /** Available liquidity on that side, dollars (decimal string). */\n      available: string;\n      /** Requested notional, dollars (decimal string). */\n      actualNotional: string;\n    };\n\n/**\n * Inputs to {@link validateInstantOpenAgainstMarket}.\n *\n * All numeric fields are decimal strings (matching the shape that\n * `calculateTradeParams` returns) so callers don't need to convert to wei\n * before validating. `market` comes from `getMarkets` (`/contract-symbols`);\n * `cva` / `lf` / `partyAmm` / `quantity` come straight off\n * {@link calculateTradeParams}.\n */\nexport interface ValidateInstantOpenAgainstMarketParameters {\n  /** Market metadata carrying the constraint fields. */\n  market: SymbolContractSymbol;\n  /** Final leveraged quote quantity (decimal string, e.g. `\"1.25\"`). */\n  quantity: string;\n  /** Current mark price (decimal string) — used for the notional bounds. */\n  markPrice: string;\n  /** CVA locked margin from {@link calculateTradeParams} (decimal string). */\n  cva: string;\n  /** LF locked margin from {@link calculateTradeParams} (decimal string). */\n  lf: string;\n  /** PartyA maintenance margin from {@link calculateTradeParams} (decimal string). */\n  partyAmm: string;\n  /**\n   * Optional solver-side liquidity cap for the market. When provided alongside\n   * {@link positionType}, the validator rejects trades whose notional exceeds\n   * the chosen side's available liquidity (`CAP_REACHED`). When the cap carries\n   * a non-null `error`, the check is skipped.\n   */\n  notionalCap?: MarketNotionalCap;\n  /** Side of the candidate trade — required for the {@link notionalCap} check. */\n  positionType?: PositionType;\n}\n\n/** Result of {@link validateInstantOpenAgainstMarket}. */\nexport interface ValidateInstantOpenAgainstMarketReturnType {\n  /** `true` when no violations fired. */\n  ok: boolean;\n  /** Every violation the candidate quote hit; empty when `ok` is `true`. */\n  violations: QuoteConstraintViolation[];\n}\n\n/**\n * Check a candidate instant-open quote against the market's published quote\n * constraints. Each constraint is independent and skipped when the market\n * doesn't publish that field, so a partial constraint set (e.g. a market\n * without `max_quantity`) still validates the rest.\n *\n * Constraints (each maps to a {@link QuoteConstraintViolation}):\n * - **`min_acceptable_portion_lf`** — `lf / (cva + lf + partyAmm)` must be at\n *   least the published minimum.\n * - **`min_acceptable_quote_value`** — the locked-margin sum\n *   `cva + lf + partyAmm` must clear the floor.\n * - **`max_notional_value`** — `markPrice × quantity` must be at most the cap.\n * - **`min_notional_value`** — `markPrice × quantity` must clear the floor.\n * - **`max_quantity`** — `quantity` must be at most the cap.\n * - **`lot_size`** — `quantity` must be at least `lot_size` and an integer\n *   multiple of it (e.g. lot_size `0.2` allows 0.2, 0.4, 0.6, … but not 0.3).\n *\n * @example\n * ```ts\n * const trade = calculateTradeParams({ ... });\n * if (!trade) return;\n * const { ok, violations } = validateInstantOpenAgainstMarket({\n *   market,\n *   quantity: trade.quantity,\n *   markPrice,\n *   cva: trade.cva,\n *   lf: trade.lf,\n *   partyAmm: trade.partyAmm,\n * });\n * if (!ok) {\n *   // render `violations` to the user; don't call `instantOpen`.\n * }\n * ```\n */\nexport function validateInstantOpenAgainstMarket(\n  parameters: ValidateInstantOpenAgainstMarketParameters,\n): ValidateInstantOpenAgainstMarketReturnType {\n  const { market, quantity, markPrice, cva, lf, partyAmm, notionalCap, positionType } = parameters;\n  const violations: QuoteConstraintViolation[] = [];\n\n  const cvaDec = toDecimal(cva);\n  const lfDec = toDecimal(lf);\n  const partyAmmDec = toDecimal(partyAmm);\n  const lockedSum = cvaDec.plus(lfDec).plus(partyAmmDec);\n\n  // 1. LF portion = lf / (cva + lf + partyAmm).\n  const minPortionStr = market.min_acceptable_portion_lf;\n  if (minPortionStr && !lockedSum.isZero() && !lockedSum.isNaN()) {\n    const actualPortion = lfDec.div(lockedSum);\n    const minPortion = toDecimal(minPortionStr);\n    if (actualPortion.lt(minPortion)) {\n      violations.push({\n        kind: \"LF_PORTION_TOO_LOW\",\n        minPortion: minPortion.toString(),\n        actualPortion: actualPortion.toString(),\n      });\n    }\n  }\n\n  // 2. min_acceptable_quote_value — compare against locked-margin sum.\n  const minQuoteValueStr = market.min_acceptable_quote_value;\n  if (minQuoteValueStr) {\n    const minQuoteValue = toDecimal(minQuoteValueStr);\n    if (lockedSum.lt(minQuoteValue)) {\n      violations.push({\n        kind: \"QUOTE_VALUE_TOO_LOW\",\n        minQuoteValue: minQuoteValue.toString(),\n        actualQuoteValue: lockedSum.toString(),\n      });\n    }\n  }\n\n  // 3 & 4. Notional bounds use markPrice × quantity.\n  const notional = toDecimal(markPrice).times(quantity);\n  if (market.max_notional_value !== undefined) {\n    const maxNotional = toDecimal(market.max_notional_value);\n    if (notional.gt(maxNotional)) {\n      violations.push({\n        kind: \"NOTIONAL_TOO_HIGH\",\n        maxNotional: maxNotional.toString(),\n        actualNotional: notional.toString(),\n      });\n    }\n  }\n  if (market.min_notional_value) {\n    const minNotional = toDecimal(market.min_notional_value);\n    if (notional.lt(minNotional)) {\n      violations.push({\n        kind: \"NOTIONAL_TOO_LOW\",\n        minNotional: minNotional.toString(),\n        actualNotional: notional.toString(),\n      });\n    }\n  }\n\n  // 5. max_quantity.\n  const actualQuantity = toDecimal(quantity);\n  if (market.max_quantity) {\n    const maxQuantity = toDecimal(market.max_quantity);\n    if (actualQuantity.gt(maxQuantity)) {\n      violations.push({\n        kind: \"QUANTITY_TOO_HIGH\",\n        maxQuantity: maxQuantity.toString(),\n        actualQuantity: actualQuantity.toString(),\n      });\n    }\n  }\n\n  // 6. lot_size — quantity must be ≥ lot_size AND an exact integer multiple.\n  // Skip the multiple-of check when below the minimum so the user sees one\n  // clear error at a time.\n  if (market.lot_size) {\n    const lotSize = toDecimal(market.lot_size);\n    if (lotSize.gt(0) && !lotSize.isNaN()) {\n      if (actualQuantity.lt(lotSize)) {\n        violations.push({\n          kind: \"QUANTITY_BELOW_LOT_SIZE\",\n          lotSize: lotSize.toString(),\n          actualQuantity: actualQuantity.toString(),\n        });\n      } else if (!actualQuantity.mod(lotSize).isZero()) {\n        violations.push({\n          kind: \"QUANTITY_NOT_LOT_MULTIPLE\",\n          lotSize: lotSize.toString(),\n          actualQuantity: actualQuantity.toString(),\n        });\n      }\n    }\n  }\n\n  // 7. Solver-side available liquidity for the chosen side. Delegates to\n  // {@link checkNotionalCap} so the rule stays consistent with the standalone\n  // pre-trade check.\n  if (notionalCap && positionType !== undefined) {\n    const result = checkNotionalCap({ positionType, notional: notional.toString(), cap: notionalCap });\n    if (!result.ok) {\n      violations.push({\n        kind: \"CAP_REACHED\",\n        side: result.side,\n        available: String(result.available),\n        actualNotional: result.requestedNotional,\n      });\n    }\n  }\n\n  return { ok: violations.length === 0, violations };\n}\n"],"mappings":";;;AAsJA,SAAgB,EACd,GAC4C;CAC5C,IAAM,EAAE,WAAQ,aAAU,cAAW,QAAK,OAAI,aAAU,gBAAa,oBAAiB,GAChF,IAAyC,CAAC,GAE1C,IAAS,EAAU,CAAG,GACtB,IAAQ,EAAU,CAAE,GACpB,IAAc,EAAU,CAAQ,GAChC,IAAY,EAAO,KAAK,CAAK,EAAE,KAAK,CAAW,GAG/C,IAAgB,EAAO;CAC7B,IAAI,KAAiB,CAAC,EAAU,OAAO,KAAK,CAAC,EAAU,MAAM,GAAG;EAC9D,IAAM,IAAgB,EAAM,IAAI,CAAS,GACnC,IAAa,EAAU,CAAa;EAC1C,AAAI,EAAc,GAAG,CAAU,KAC7B,EAAW,KAAK;GACd,MAAM;GACN,YAAY,EAAW,SAAS;GAChC,eAAe,EAAc,SAAS;EACxC,CAAC;CAEL;CAGA,IAAM,IAAmB,EAAO;CAChC,IAAI,GAAkB;EACpB,IAAM,IAAgB,EAAU,CAAgB;EAChD,AAAI,EAAU,GAAG,CAAa,KAC5B,EAAW,KAAK;GACd,MAAM;GACN,eAAe,EAAc,SAAS;GACtC,kBAAkB,EAAU,SAAS;EACvC,CAAC;CAEL;CAGA,IAAM,IAAW,EAAU,CAAS,EAAE,MAAM,CAAQ;CACpD,IAAI,EAAO,uBAAuB,KAAA,GAAW;EAC3C,IAAM,IAAc,EAAU,EAAO,kBAAkB;EACvD,AAAI,EAAS,GAAG,CAAW,KACzB,EAAW,KAAK;GACd,MAAM;GACN,aAAa,EAAY,SAAS;GAClC,gBAAgB,EAAS,SAAS;EACpC,CAAC;CAEL;CACA,IAAI,EAAO,oBAAoB;EAC7B,IAAM,IAAc,EAAU,EAAO,kBAAkB;EACvD,AAAI,EAAS,GAAG,CAAW,KACzB,EAAW,KAAK;GACd,MAAM;GACN,aAAa,EAAY,SAAS;GAClC,gBAAgB,EAAS,SAAS;EACpC,CAAC;CAEL;CAGA,IAAM,IAAiB,EAAU,CAAQ;CACzC,IAAI,EAAO,cAAc;EACvB,IAAM,IAAc,EAAU,EAAO,YAAY;EACjD,AAAI,EAAe,GAAG,CAAW,KAC/B,EAAW,KAAK;GACd,MAAM;GACN,aAAa,EAAY,SAAS;GAClC,gBAAgB,EAAe,SAAS;EAC1C,CAAC;CAEL;CAKA,IAAI,EAAO,UAAU;EACnB,IAAM,IAAU,EAAU,EAAO,QAAQ;EACzC,AAAI,EAAQ,GAAG,CAAC,KAAK,CAAC,EAAQ,MAAM,MAC9B,EAAe,GAAG,CAAO,IAC3B,EAAW,KAAK;GACd,MAAM;GACN,SAAS,EAAQ,SAAS;GAC1B,gBAAgB,EAAe,SAAS;EAC1C,CAAC,IACS,EAAe,IAAI,CAAO,EAAE,OAAO,KAC7C,EAAW,KAAK;GACd,MAAM;GACN,SAAS,EAAQ,SAAS;GAC1B,gBAAgB,EAAe,SAAS;EAC1C,CAAC;CAGP;CAKA,IAAI,KAAe,MAAiB,KAAA,GAAW;EAC7C,IAAM,IAAS,EAAiB;GAAE;GAAc,UAAU,EAAS,SAAS;GAAG,KAAK;EAAY,CAAC;EACjG,AAAK,EAAO,MACV,EAAW,KAAK;GACd,MAAM;GACN,MAAM,EAAO;GACb,WAAW,OAAO,EAAO,SAAS;GAClC,gBAAgB,EAAO;EACzB,CAAC;CAEL;CAEA,OAAO;EAAE,IAAI,EAAW,WAAW;EAAG;CAAW;AACnD"}

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

@@ -0,0 +1,35 @@
+import { Hex } from 'viem';
+/**
+ * 4-byte function selector for `AccountLayer.addMarginToNextVA(...)`.
+ *
+ * Computed once from the ABI fragment so it stays in sync if the function
+ * signature changes in a future ABI version.
+ */
+export declare const ADD_MARGIN_TO_NEXT_VA_SELECTOR: Hex;
+/**
+ * 4-byte function selector for `Symmio.sendQuoteWithAffiliateAndData(...)`.
+ */
+export declare const SEND_QUOTE_WITH_AFFILIATE_AND_DATA_SELECTOR: Hex;
+/**
+ * 4-byte function selector for `Symmio.requestToClosePosition(...)`.
+ */
+export declare const REQUEST_TO_CLOSE_POSITION_SELECTOR: Hex;
+/**
+ * The full set of selectors a session key needs delegation for in order to
+ * sign the InstantLayer v2 trade lifecycle on behalf of a sub-account: open
+ * (`sendQuoteWithAffiliateAndData`), close (`requestToClosePosition`), and
+ * margin top-up (`addMarginToNextVA`). Pass to `grantDelegation` in one
+ * transaction.
+ *
+ * @example
+ * ```ts
+ * grantDelegation(config, {
+ *   account: { addr: subAccountAddress, isPartyB: false },
+ *   delegatedSigner: sessionKeyAddress,
+ *   selectors: INSTANT_TRADE_REQUIRED_SELECTORS,
+ *   expiryTimestamp,
+ * });
+ * ```
+ */
+export declare const INSTANT_TRADE_REQUIRED_SELECTORS: readonly [`0x${string}`, `0x${string}`, `0x${string}`];
+//# sourceMappingURL=selectors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.d.ts","sourceRoot":"","sources":["../../../../src/solvers/instant-open/shared/selectors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkD,KAAK,GAAG,EAAE,MAAM,MAAM,CAAC;AAUhF;;;;;GAKG;AACH,eAAO,MAAM,8BAA8B,EAAE,GAAkE,CAAC;AAEhH;;GAEG;AACH,eAAO,MAAM,2CAA2C,EAAE,GAGzD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kCAAkC,EAAE,GAAiE,CAAC;AAEnH;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,gCAAgC,wDAInC,CAAC"}

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

@@ -0,0 +1,18 @@
+import { accountLayerAbi as e } from "../../../symmio-contracts/abi/v0.8.5/account-layer.js";
+import { symmioAbi as t } from "../../../symmio-contracts/abi/v0.8.5/symmio.js";
+import { toFunctionSelector as n } from "viem";
+//#region src/solvers/instant-open/shared/selectors.ts
+function r(e, t) {
+	let r = e.find((e) => e.type === "function" && e.name === t);
+	if (!r) throw Error(`Selector lookup failed: "${t}" not in ABI.`);
+	return n(r);
+}
+var i = r(e, "addMarginToNextVA"), a = r(t, "sendQuoteWithAffiliateAndData"), o = r(t, "requestToClosePosition"), s = [
+	i,
+	a,
+	o
+];
+//#endregion
+export { i as ADD_MARGIN_TO_NEXT_VA_SELECTOR, s as INSTANT_TRADE_REQUIRED_SELECTORS, o as REQUEST_TO_CLOSE_POSITION_SELECTOR, a as SEND_QUOTE_WITH_AFFILIATE_AND_DATA_SELECTOR };
+
+//# sourceMappingURL=selectors.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.js","names":[],"sources":["../../../../src/solvers/instant-open/shared/selectors.ts"],"sourcesContent":["import { toFunctionSelector, type Abi, type AbiFunction, type Hex } from \"viem\";\nimport { accountLayerAbi } from \"../../../symmio-contracts/abi/v0.8.5/account-layer\";\nimport { symmioAbi } from \"../../../symmio-contracts/abi/v0.8.5/symmio\";\n\nfunction selectorFromAbi(abi: Abi, name: string): Hex {\n  const fragment = abi.find((item) => item.type === \"function\" && item.name === name) as AbiFunction | undefined;\n  if (!fragment) throw new Error(`Selector lookup failed: \"${name}\" not in ABI.`);\n  return toFunctionSelector(fragment);\n}\n\n/**\n * 4-byte function selector for `AccountLayer.addMarginToNextVA(...)`.\n *\n * Computed once from the ABI fragment so it stays in sync if the function\n * signature changes in a future ABI version.\n */\nexport const ADD_MARGIN_TO_NEXT_VA_SELECTOR: Hex = selectorFromAbi(accountLayerAbi as Abi, \"addMarginToNextVA\");\n\n/**\n * 4-byte function selector for `Symmio.sendQuoteWithAffiliateAndData(...)`.\n */\nexport const SEND_QUOTE_WITH_AFFILIATE_AND_DATA_SELECTOR: Hex = selectorFromAbi(\n  symmioAbi as Abi,\n  \"sendQuoteWithAffiliateAndData\",\n);\n\n/**\n * 4-byte function selector for `Symmio.requestToClosePosition(...)`.\n */\nexport const REQUEST_TO_CLOSE_POSITION_SELECTOR: Hex = selectorFromAbi(symmioAbi as Abi, \"requestToClosePosition\");\n\n/**\n * The full set of selectors a session key needs delegation for in order to\n * sign the InstantLayer v2 trade lifecycle on behalf of a sub-account: open\n * (`sendQuoteWithAffiliateAndData`), close (`requestToClosePosition`), and\n * margin top-up (`addMarginToNextVA`). Pass to `grantDelegation` in one\n * transaction.\n *\n * @example\n * ```ts\n * grantDelegation(config, {\n *   account: { addr: subAccountAddress, isPartyB: false },\n *   delegatedSigner: sessionKeyAddress,\n *   selectors: INSTANT_TRADE_REQUIRED_SELECTORS,\n *   expiryTimestamp,\n * });\n * ```\n */\nexport const INSTANT_TRADE_REQUIRED_SELECTORS = [\n  ADD_MARGIN_TO_NEXT_VA_SELECTOR,\n  SEND_QUOTE_WITH_AFFILIATE_AND_DATA_SELECTOR,\n  REQUEST_TO_CLOSE_POSITION_SELECTOR,\n] as const;\n"],"mappings":";;;;AAIA,SAAS,EAAgB,GAAU,GAAmB;CACpD,IAAM,IAAW,EAAI,MAAM,MAAS,EAAK,SAAS,cAAc,EAAK,SAAS,CAAI;CAClF,IAAI,CAAC,GAAU,MAAU,MAAM,4BAA4B,EAAK,cAAc;CAC9E,OAAO,EAAmB,CAAQ;AACpC;AAQA,IAAa,IAAsC,EAAgB,GAAwB,mBAAmB,GAKjG,IAAmD,EAC9D,GACA,+BACF,GAKa,IAA0C,EAAgB,GAAkB,wBAAwB,GAmBpG,IAAmC;CAC9C;CACA;CACA;AACF"}

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

@@ -0,0 +1,145 @@
+import { PositionType } from './types';
+/**
+ * Unix-seconds remaining for a MARKET-order deadline (5 minutes).
+ */
+export declare const MARKET_ORDER_DEADLINE_SECONDS = 300n;
+/**
+ * Compute a unix-seconds `deadline` for a MARKET order.
+ *
+ * @param now - Optional override for `Math.floor(Date.now() / 1000)`. Useful for tests.
+ */
+export declare function getMarketOrderDeadline(now?: bigint): bigint;
+/**
+ * Parameters for {@link calculateTradeParams}.
+ */
+export interface CalculateTradeParamsParameters {
+    /** Mark price as decimal string (e.g. `"50123.45"`). */
+    markPrice: string;
+    /** Slippage percent (e.g. `5` for 5%). */
+    slippage: number;
+    /** Position side: `"LONG"` or `"SHORT"`. */
+    positionType: PositionType;
+    /** User input as decimal string. Interpreted as collateral when `inputField === "PRICE"`. */
+    userInput: string;
+    /** Input mode. `"PRICE"` = userInput is USD collateral; `"TOKEN"` = userInput is base token amount. */
+    inputField: "PRICE" | "TOKEN";
+    /** Position leverage (integer ≥ 1). */
+    leverage: number;
+    /** Price precision (decimals). */
+    pricePrecision: number;
+    /** Quantity precision (decimals). */
+    quantityPrecision: number;
+    /** Solver locked-param percentages (e.g. `"0.02"` for 2%). */
+    cvaPercent?: string;
+    /** Solver locked-param percentages (e.g. `"0.01"` for 1%). */
+    lfPercent?: string;
+    /** Solver locked-param percentages. */
+    partyAmmPercent?: string;
+    /** Solver locked-param percentages. */
+    partyBmmPercent?: string;
+}
+/**
+ * Return type of {@link calculateTradeParams}.
+ *
+ * All values are decimal strings. Convert to 18-decimal `bigint` with
+ * `parseEther(...).toFixed(0)` (or {@link toWeiBigInt}) before passing to a
+ * contract call.
+ */
+export interface CalculateTradeParamsReturnType {
+    /** Open price with slippage applied, trimmed to `pricePrecision`. */
+    requestedOpenPrice: string;
+    /** Base quantity (no leverage), trimmed to `quantityPrecision`. */
+    quantityBasic: string;
+    /** Leveraged quantity (`quantityBasic × leverage`), trimmed to `quantityPrecision`. */
+    quantity: string;
+    /** Base notional (`quantityBasic × requestedOpenPrice`). */
+    notionalBasic: string;
+    /** Leveraged notional (`notionalBasic × leverage`). */
+    notional: string;
+    /** CVA locked margin (`notionalBasic × cvaPercent / 100`). */
+    cva: string;
+    /** LF locked margin (`notionalBasic × lfPercent / 100`). */
+    lf: string;
+    /** PartyA maintenance margin. */
+    partyAmm: string;
+    /** PartyB maintenance margin. */
+    partyBmm: string;
+}
+/**
+ * Pure trade-parameters calculator for lowcap MARKET orders.
+ *
+ * Steps:
+ * 1. `requestedOpenPrice = markPrice × (1 ± slippage/100)` trimmed to `pricePrecision`.
+ * 2. `quantityBasic = userInput / requestedOpenPrice` (when `inputField === "PRICE"`) or
+ *    `userInput` (when `inputField === "TOKEN"`) trimmed to `quantityPrecision`.
+ * 3. `notionalBasic = quantityBasic × requestedOpenPrice`.
+ * 4. `cva / lf / partyAmm / partyBmm = notionalBasic × percent / 100`.
+ * 5. `quantity = quantityBasic × leverage` trimmed to `quantityPrecision`.
+ * 6. `notional = notionalBasic × leverage`.
+ *
+ * @returns `null` when `markPrice` is zero/NaN or `userInput` is invalid.
+ */
+export declare function calculateTradeParams(parameters: CalculateTradeParamsParameters): CalculateTradeParamsReturnType | null;
+/**
+ * Parameters for {@link calculateMargin}.
+ */
+export interface CalculateMarginParameters {
+    /** Position side. */
+    positionType: PositionType;
+    /** Mark price (decimal string). */
+    markPrice: string;
+    /** Base quantity from {@link calculateTradeParams}. */
+    quantityBasic: string;
+    /** CVA from {@link calculateTradeParams}. */
+    cva: string;
+    /** LF from {@link calculateTradeParams}. */
+    lf: string;
+    /** PartyA maintenance margin from {@link calculateTradeParams}. */
+    partyAmm: string;
+    /** Solver locked-param percents (passed when recomputing for SHORT). */
+    cvaPercent?: string;
+    /** Solver locked-param percents. */
+    lfPercent?: string;
+    /** Solver locked-param percents. */
+    partyAmmPercent?: string;
+    /** On-chain platform fee as decimal string (from {@link computePlatformFee}). */
+    platformFee: string;
+}
+/**
+ * Compute the `addMargin` amount for lowcap isolation.
+ *
+ * - **LONG**: `margin = cva + lf + partyAmm + platformFee`.
+ * - **SHORT**: recompute the locked values at `markPrice`,
+ *   then sum + `platformFee`.
+ *
+ * @returns Margin as decimal string.
+ */
+export declare function calculateMargin(parameters: CalculateMarginParameters): string;
+/**
+ * On-chain `getFeeForUser` result, in 18-decimal fixed-point.
+ */
+export interface ComputePlatformFeeRates {
+    /** Open fee rate as 18-decimal `bigint`. */
+    openFee: bigint;
+    /** Close fee rate as 18-decimal `bigint`. */
+    closeFee: bigint;
+}
+/**
+ * Compute the total platform fee for an open + close round trip.
+ *
+ * `(openFee × initialNotional + closeFee × closeNotional) / 1e18`.
+ *
+ * @param rates - Fee rates from `getFeeForUser`.
+ * @param initialNotional - Notional at open, decimal string.
+ * @param closeNotional - Notional at close, decimal string.
+ * @returns Total fee as decimal string.
+ */
+export declare function computePlatformFee(rates: ComputePlatformFeeRates, initialNotional: string, closeNotional: string): string;
+/**
+ * Convert a decimal string to an 18-decimal-fixed-point `bigint`.
+ *
+ * Wrapper over `parseEther` from `@symmio/utils/decimal` that returns
+ * the wei value as `bigint` (truncated, no rounding) suitable for contract calls.
+ */
+export declare function toWeiBigInt(value: string): bigint;
+//# sourceMappingURL=trade-math.d.ts.map