@symmio/trading-core 1.1.0 → 3.0.0

package/dist/solvers/shared/resolvers/resolve-mark-price.d.ts

@@ -1,20 +1,32 @@
+import { SolverId } from '../../../core/chains/types.js';
 import { Config } from '../../../core/config/index.js';
 /**
  * Parameters for {@link resolveMarkPrice}.
  */
 export interface ResolveMarkPriceParameters {
     chainId?: number;
+    /**
+     * Solver the trade targets. Its configured price provider supplies the mark.
+     * **Must match the solver the trade is sent to** — the resolved price is
+     * signed into the EIP-712 payload. Defaults to the chain's `defaultSolverId`.
+     */
+    solverId?: SolverId;
     marketName: string;
     markPrice?: string;
 }
 /**
- * Resolve a mark price for `marketName`. Returns the caller-supplied value
- * when present; otherwise fetches the Enigma price service.
+ * Resolve a mark price for `marketName`. Returns the caller-supplied value when
+ * present; otherwise reads the price provider configured for the resolved solver
+ * — Enigma's lowcap service for lowcap solvers, Binance USD-M Futures for
+ * majors.
  *
- * Shared by the instant-open and instant-close wizards.
+ * Shared by the instant-open and instant-close wizards, so the resolved value is
+ * signed into an EIP-712 operation. Getting the provider wrong here is a wrong
+ * price on-chain, not a display bug — which is why `solverId` must reach this
+ * function and must match the solver the trade is sent to.
  *
- * @throws {SymmError} `RESOLVE_MARK_PRICE_NOT_FOUND` when the price service
- *   omits the requested name from its response.
+ * @throws {SymmError} `RESOLVE_MARK_PRICE_NOT_FOUND` when the provider omits the
+ *   requested name from its response.
  */
 export declare function resolveMarkPrice(config: Config, parameters: ResolveMarkPriceParameters): Promise<string>;
 //# sourceMappingURL=resolve-mark-price.d.ts.map

package/dist/solvers/shared/resolvers/resolve-mark-price.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-mark-price.d.ts","sourceRoot":"","sources":["../../../../src/solvers/shared/resolvers/resolve-mark-price.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAInD;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,0BAA0B,GAAG,OAAO,CAAC,MAAM,CAAC,CAgB9G"}
+{"version":3,"file":"resolve-mark-price.d.ts","sourceRoot":"","sources":["../../../../src/solvers/shared/resolvers/resolve-mark-price.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAKnD;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,0BAA0B,GAAG,OAAO,CAAC,MAAM,CAAC,CA4B9G"}

package/dist/solvers/shared/resolvers/resolve-mark-price.js

@@ -1,16 +1,23 @@
 import { SymmError as e } from "../../../shared/errors/symm-error.js";
-import { getEnigmaPriceServicePricesByNames as t } from "../../../price-service/enigma/prices-by-names/get-enigma-price-service-prices-by-names.js";
+import { resolvePriceService as t } from "../../../price-service/resolve-price-service.js";
+import { getMarkPrices as n } from "../../../price-service/get-mark-prices/get-mark-prices.js";
 //#region src/solvers/shared/resolvers/resolve-mark-price.ts
-async function n(n, r) {
-	if (r.markPrice !== void 0) return r.markPrice;
-	let i = (await t(n, {
-		chainId: r.chainId,
-		names: [r.marketName]
-	}))[r.marketName];
-	if (!i) throw new e("api", "RESOLVE_MARK_PRICE_NOT_FOUND", `Mark price not returned by Enigma price service for market "${r.marketName}".`);
-	return String(i.markPrice);
+async function r(r, i) {
+	if (i.markPrice !== void 0) return i.markPrice;
+	let a = {
+		chainId: i.chainId,
+		solverId: i.solverId
+	}, o = i.marketName, s = await n(r, {
+		...a,
+		names: [o]
+	}), c = s.find((e) => e.name === o) ?? s.find((e) => e.name.toUpperCase() === o.toUpperCase());
+	if (!c) {
+		let { type: n } = t(r, a);
+		throw new e("api", "RESOLVE_MARK_PRICE_NOT_FOUND", `Mark price not returned by the "${n}" price service for market "${o}".${n === "binance" && o.includes("::") ? ` "${o}" looks like a lowcap market name; Binance USD-M Futures serves plain symbols such as "BTCUSDT".` : ""}`);
+	}
+	return c.markPrice;
 }
 //#endregion
-export { n as resolveMarkPrice };
+export { r as resolveMarkPrice };
 
 //# sourceMappingURL=resolve-mark-price.js.map

package/dist/solvers/shared/resolvers/resolve-mark-price.js.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-mark-price.js","names":[],"sources":["../../../../src/solvers/shared/resolvers/resolve-mark-price.ts"],"sourcesContent":["import type { Config } from \"../../../core/config\";\nimport { getEnigmaPriceServicePricesByNames } from \"../../../price-service/enigma/prices-by-names/get-enigma-price-service-prices-by-names\";\nimport { SymmError } from \"../../../shared/errors/symm-error\";\n\n/**\n * Parameters for {@link resolveMarkPrice}.\n */\nexport interface ResolveMarkPriceParameters {\n  chainId?: number;\n  marketName: string;\n  markPrice?: string;\n}\n\n/**\n * Resolve a mark price for `marketName`. Returns the caller-supplied value\n * when present; otherwise fetches the Enigma price service.\n *\n * Shared by the instant-open and instant-close wizards.\n *\n * @throws {SymmError} `RESOLVE_MARK_PRICE_NOT_FOUND` when the price service\n *   omits the requested name from its response.\n */\nexport async function resolveMarkPrice(config: Config, parameters: ResolveMarkPriceParameters): Promise<string> {\n  if (parameters.markPrice !== undefined) return parameters.markPrice;\n\n  const prices = await getEnigmaPriceServicePricesByNames(config, {\n    chainId: parameters.chainId,\n    names: [parameters.marketName],\n  });\n  const entry = prices[parameters.marketName];\n  if (!entry) {\n    throw new SymmError(\n      \"api\",\n      \"RESOLVE_MARK_PRICE_NOT_FOUND\",\n      `Mark price not returned by Enigma price service for market \"${parameters.marketName}\".`,\n    );\n  }\n  return String(entry.markPrice);\n}\n"],"mappings":";;;AAsBA,eAAsB,EAAiB,GAAgB,GAAyD;CAC9G,IAAI,EAAW,cAAc,KAAA,GAAW,OAAO,EAAW;CAM1D,IAAM,KAAQ,MAJO,EAAmC,GAAQ;EAC9D,SAAS,EAAW;EACpB,OAAO,CAAC,EAAW,UAAU;CAC/B,CAAC,GACoB,EAAW;CAChC,IAAI,CAAC,GACH,MAAM,IAAI,EACR,OACA,gCACA,+DAA+D,EAAW,WAAW,GACvF;CAEF,OAAO,OAAO,EAAM,SAAS;AAC/B"}
+{"version":3,"file":"resolve-mark-price.js","names":[],"sources":["../../../../src/solvers/shared/resolvers/resolve-mark-price.ts"],"sourcesContent":["import type { SolverId } from \"../../../core/chains/types\";\nimport type { Config } from \"../../../core/config\";\nimport { getMarkPrices } from \"../../../price-service/get-mark-prices/get-mark-prices\";\nimport { resolvePriceService } from \"../../../price-service/resolve-price-service\";\nimport { SymmError } from \"../../../shared/errors/symm-error\";\n\n/**\n * Parameters for {@link resolveMarkPrice}.\n */\nexport interface ResolveMarkPriceParameters {\n  chainId?: number;\n  /**\n   * Solver the trade targets. Its configured price provider supplies the mark.\n   * **Must match the solver the trade is sent to** — the resolved price is\n   * signed into the EIP-712 payload. Defaults to the chain's `defaultSolverId`.\n   */\n  solverId?: SolverId;\n  marketName: string;\n  markPrice?: string;\n}\n\n/**\n * Resolve a mark price for `marketName`. Returns the caller-supplied value when\n * present; otherwise reads the price provider configured for the resolved solver\n * — Enigma's lowcap service for lowcap solvers, Binance USD-M Futures for\n * majors.\n *\n * Shared by the instant-open and instant-close wizards, so the resolved value is\n * signed into an EIP-712 operation. Getting the provider wrong here is a wrong\n * price on-chain, not a display bug — which is why `solverId` must reach this\n * function and must match the solver the trade is sent to.\n *\n * @throws {SymmError} `RESOLVE_MARK_PRICE_NOT_FOUND` when the provider omits the\n *   requested name from its response.\n */\nexport async function resolveMarkPrice(config: Config, parameters: ResolveMarkPriceParameters): Promise<string> {\n  if (parameters.markPrice !== undefined) return parameters.markPrice;\n\n  const target = { chainId: parameters.chainId, solverId: parameters.solverId };\n  const wanted = parameters.marketName;\n  const ticks = await getMarkPrices(config, { ...target, names: [wanted] });\n\n  // Exact match first so the caller's spelling wins; the case-insensitive pass\n  // only covers a provider that canonicalizes casing differently.\n  const tick =\n    ticks.find((entry) => entry.name === wanted) ??\n    ticks.find((entry) => entry.name.toUpperCase() === wanted.toUpperCase());\n\n  if (!tick) {\n    const { type } = resolvePriceService(config, target);\n    // The single most likely failure while majors migrate onto Binance: a lowcap\n    // market name sent to a provider that only serves plain exchange symbols.\n    const hint =\n      type === \"binance\" && wanted.includes(\"::\")\n        ? ` \"${wanted}\" looks like a lowcap market name; Binance USD-M Futures serves plain symbols such as \"BTCUSDT\".`\n        : \"\";\n    throw new SymmError(\n      \"api\",\n      \"RESOLVE_MARK_PRICE_NOT_FOUND\",\n      `Mark price not returned by the \"${type}\" price service for market \"${wanted}\".${hint}`,\n    );\n  }\n  return tick.markPrice;\n}\n"],"mappings":";;;;AAmCA,eAAsB,EAAiB,GAAgB,GAAyD;CAC9G,IAAI,EAAW,cAAc,KAAA,GAAW,OAAO,EAAW;CAE1D,IAAM,IAAS;EAAE,SAAS,EAAW;EAAS,UAAU,EAAW;CAAS,GACtE,IAAS,EAAW,YACpB,IAAQ,MAAM,EAAc,GAAQ;EAAE,GAAG;EAAQ,OAAO,CAAC,CAAM;CAAE,CAAC,GAIlE,IACJ,EAAM,MAAM,MAAU,EAAM,SAAS,CAAM,KAC3C,EAAM,MAAM,MAAU,EAAM,KAAK,YAAY,MAAM,EAAO,YAAY,CAAC;CAEzE,IAAI,CAAC,GAAM;EACT,IAAM,EAAE,YAAS,EAAoB,GAAQ,CAAM;EAOnD,MAAM,IAAI,EACR,OACA,gCACA,mCAAmC,EAAK,8BAA8B,EAAO,IAN7E,MAAS,aAAa,EAAO,SAAS,IAAI,IACtC,KAAK,EAAO,oGACZ,IAKN;CACF;CACA,OAAO,EAAK;AACd"}

package/dist/solvers/shared/resolvers/resolve-market.d.ts

@@ -1,3 +1,4 @@
+import { SolverId } from '../../../core/chains/types.js';
 import { Config } from '../../../core/config/index.js';
 import { ResolvedMarket } from './types.js';
 /**
@@ -5,21 +6,58 @@ import { ResolvedMarket } from './types.js';
  */
 export interface ResolveMarketParameters {
     chainId?: number;
+    /**
+     * Solver whose `/contract-symbols` listing to read. **Must match the solver
+     * the trade is sent to** — the resolved `name` and precisions are encoded into
+     * the signed quote. Defaults to the chain's `defaultSolverId`.
+     */
+    solverId?: SolverId;
     marketId: number;
     marketName?: string;
     pricePrecision?: number;
     quantityPrecision?: number;
+    /**
+     * Also resolve the market's solver-fee caps (`minOpenSolverFeeCap` /
+     * `minCloseSolverFeeCap`, decimal ratio strings). With this set, pre-filled
+     * metadata short-circuits the fetch only when both caps are pre-filled too;
+     * a fetched market that carries no caps (a non-Enigma kind) resolves both to
+     * `"0"`. The open wizard sets this; the close wizard does not need caps.
+     */
+    includeSolverFeeCaps?: boolean;
+    /** Pre-fetched `minOpenSolverFeeCap` (decimal ratio string). */
+    minOpenSolverFeeCap?: string;
+    /** Pre-fetched `minCloseSolverFeeCap` (decimal ratio string). */
+    minCloseSolverFeeCap?: string;
+    /**
+     * Also resolve the market's solver fee rates (`hedgerFeeOpen` /
+     * `hedgerFeeClose`, decimal fraction strings). Same short-circuit contract as
+     * `includeSolverFeeCaps`: pre-filled metadata skips the fetch only when both
+     * rates are pre-filled too. The open wizard sets this — the solver charges
+     * these fees from the VA, so the `addMargin` transfer must fund them.
+     */
+    includeHedgerFees?: boolean;
+    /** Pre-fetched `hedgerFeeOpen` (decimal fraction string). */
+    hedgerFeeOpen?: string;
+    /** Pre-fetched `hedgerFeeClose` (decimal fraction string). */
+    hedgerFeeClose?: string;
+    /** Pre-fetched early (peak) close-fee rate (decimal fraction string). */
+    hedgerFeeCloseEarlyRate?: string;
+    /** Pre-fetched early-window length in seconds. */
+    hedgerFeeCloseEarlyThreshold?: number;
+    /** Pre-fetched standard-rate threshold in seconds. */
+    hedgerFeeCloseStandardThreshold?: number;
 }
 /**
- * Resolve market metadata (`name`, `pricePrecision`, `quantityPrecision`) for
- * `marketId`. Returns caller-supplied values when all three are pre-filled;
- * otherwise fetches `/contract-symbols` and extracts the matching record.
+ * Resolve market metadata (`name`, `pricePrecision`, `quantityPrecision`, and —
+ * when `includeSolverFeeCaps` is set — the solver-fee cap minimums) for
+ * `marketId`. Returns caller-supplied values when everything needed is
+ * pre-filled; otherwise fetches `/contract-symbols` and extracts the matching
+ * record. The normalized {@link Market} shape guarantees the metadata fields,
+ * so only "not found" can fail here.
  *
  * Shared by the instant-open and instant-close wizards.
  *
  * @throws {SymmError} `RESOLVE_MARKET_NOT_FOUND` when no record matches.
- * @throws {SymmError} `RESOLVE_MARKET_METADATA_INCOMPLETE` when the solver
- *   record is missing required fields.
  */
 export declare function resolveMarket(config: Config, parameters: ResolveMarketParameters): Promise<ResolvedMarket>;
 //# sourceMappingURL=resolve-market.d.ts.map

package/dist/solvers/shared/resolvers/resolve-market.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-market.d.ts","sourceRoot":"","sources":["../../../../src/solvers/shared/resolvers/resolve-market.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAGnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,uBAAuB,GAAG,OAAO,CAAC,cAAc,CAAC,CA2BhH"}
+{"version":3,"file":"resolve-market.d.ts","sourceRoot":"","sources":["../../../../src/solvers/shared/resolvers/resolve-market.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAGnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;;;;OAMG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,gEAAgE;IAChE,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,iEAAiE;IACjE,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,6DAA6D;IAC7D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,8DAA8D;IAC9D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,yEAAyE;IACzE,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,kDAAkD;IAClD,4BAA4B,CAAC,EAAE,MAAM,CAAC;IACtC,sDAAsD;IACtD,+BAA+B,CAAC,EAAE,MAAM,CAAC;CAC1C;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,uBAAuB,GAAG,OAAO,CAAC,cAAc,CAAC,CAoEhH"}

package/dist/solvers/shared/resolvers/resolve-market.js

@@ -2,20 +2,43 @@ import { SymmError as e } from "../../../shared/errors/symm-error.js";
 import { getMarkets as t } from "../../markets/get-markets.js";
 //#region src/solvers/shared/resolvers/resolve-market.ts
 async function n(n, r) {
-	let { marketName: i, pricePrecision: a, quantityPrecision: o } = r;
-	if (i !== void 0 && a !== void 0 && o !== void 0) return {
+	let { marketName: i, pricePrecision: a, quantityPrecision: o, minOpenSolverFeeCap: s, minCloseSolverFeeCap: c } = r, { hedgerFeeOpen: l, hedgerFeeClose: u } = r, { hedgerFeeCloseEarlyRate: d, hedgerFeeCloseEarlyThreshold: f, hedgerFeeCloseStandardThreshold: p } = r, m = r.includeSolverFeeCaps === !0, h = s !== void 0 && c !== void 0, g = r.includeHedgerFees === !0;
+	if (i !== void 0 && a !== void 0 && o !== void 0 && (!m || h) && (!g || l !== void 0 && u !== void 0)) return {
 		name: i,
 		pricePrecision: a,
-		quantityPrecision: o
+		quantityPrecision: o,
+		...m ? {
+			minOpenSolverFeeCap: s,
+			minCloseSolverFeeCap: c
+		} : {},
+		...g ? {
+			hedgerFeeOpen: l,
+			hedgerFeeClose: u,
+			hedgerFeeCloseEarlyRate: d,
+			hedgerFeeCloseEarlyThreshold: f,
+			hedgerFeeCloseStandardThreshold: p
+		} : {}
 	};
-	let s = (await t(n, { chainId: r.chainId })).find((e) => e.symbol_id === r.marketId);
-	if (!s) throw new e("api", "RESOLVE_MARKET_NOT_FOUND", `Market id ${r.marketId} not returned by solver /contract-symbols.`);
-	let c = i ?? s.name, l = a ?? s.price_precision, u = o ?? s.quantity_precision;
-	if (c === void 0 || l === void 0 || u === void 0) throw new e("api", "RESOLVE_MARKET_METADATA_INCOMPLETE", `Solver returned incomplete metadata for market id ${r.marketId} (name/price_precision/quantity_precision missing).`);
+	let _ = (await t(n, {
+		chainId: r.chainId,
+		solverId: r.solverId
+	})).find((e) => e.symbolId === r.marketId);
+	if (!_) throw new e("api", "RESOLVE_MARKET_NOT_FOUND", `Market id ${r.marketId} not returned by solver /contract-symbols.`);
 	return {
-		name: c,
-		pricePrecision: l,
-		quantityPrecision: u
+		name: i ?? _.name,
+		pricePrecision: a ?? _.pricePrecision,
+		quantityPrecision: o ?? _.quantityPrecision,
+		...m ? {
+			minOpenSolverFeeCap: s ?? (_.kind === "enigma" ? _.minOpenSolverFeeCap : "0"),
+			minCloseSolverFeeCap: c ?? (_.kind === "enigma" ? _.minCloseSolverFeeCap : "0")
+		} : {},
+		...g ? {
+			hedgerFeeOpen: l ?? _.hedgerFeeOpen,
+			hedgerFeeClose: u ?? _.hedgerFeeClose,
+			hedgerFeeCloseEarlyRate: d ?? (_.kind === "enigma" ? _.hedgerFeeCloseEarlyRate : void 0),
+			hedgerFeeCloseEarlyThreshold: f ?? (_.kind === "enigma" ? _.hedgerFeeCloseEarlyThreshold : void 0),
+			hedgerFeeCloseStandardThreshold: p ?? (_.kind === "enigma" ? _.hedgerFeeCloseStandardThreshold : void 0)
+		} : {}
 	};
 }
 //#endregion

package/dist/solvers/shared/resolvers/resolve-market.js.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-market.js","names":[],"sources":["../../../../src/solvers/shared/resolvers/resolve-market.ts"],"sourcesContent":["import type { Config } from \"../../../core/config\";\nimport { SymmError } from \"../../../shared/errors/symm-error\";\nimport { getMarkets } from \"../../markets/get-markets\";\nimport type { ResolvedMarket } from \"./types\";\n\n/**\n * Parameters for {@link resolveMarket}.\n */\nexport interface ResolveMarketParameters {\n  chainId?: number;\n  marketId: number;\n  marketName?: string;\n  pricePrecision?: number;\n  quantityPrecision?: number;\n}\n\n/**\n * Resolve market metadata (`name`, `pricePrecision`, `quantityPrecision`) for\n * `marketId`. Returns caller-supplied values when all three are pre-filled;\n * otherwise fetches `/contract-symbols` and extracts the matching record.\n *\n * Shared by the instant-open and instant-close wizards.\n *\n * @throws {SymmError} `RESOLVE_MARKET_NOT_FOUND` when no record matches.\n * @throws {SymmError} `RESOLVE_MARKET_METADATA_INCOMPLETE` when the solver\n *   record is missing required fields.\n */\nexport async function resolveMarket(config: Config, parameters: ResolveMarketParameters): Promise<ResolvedMarket> {\n  const { marketName, pricePrecision, quantityPrecision } = parameters;\n  if (marketName !== undefined && pricePrecision !== undefined && quantityPrecision !== undefined) {\n    return { name: marketName, pricePrecision, quantityPrecision };\n  }\n\n  const markets = await getMarkets(config, { chainId: parameters.chainId });\n  const match = markets.find((m) => m.symbol_id === parameters.marketId);\n  if (!match) {\n    throw new SymmError(\n      \"api\",\n      \"RESOLVE_MARKET_NOT_FOUND\",\n      `Market id ${parameters.marketId} not returned by solver /contract-symbols.`,\n    );\n  }\n\n  const name = marketName ?? match.name;\n  const resolvedPricePrecision = pricePrecision ?? match.price_precision;\n  const resolvedQuantityPrecision = quantityPrecision ?? match.quantity_precision;\n  if (name === undefined || resolvedPricePrecision === undefined || resolvedQuantityPrecision === undefined) {\n    throw new SymmError(\n      \"api\",\n      \"RESOLVE_MARKET_METADATA_INCOMPLETE\",\n      `Solver returned incomplete metadata for market id ${parameters.marketId} (name/price_precision/quantity_precision missing).`,\n    );\n  }\n  return { name, pricePrecision: resolvedPricePrecision, quantityPrecision: resolvedQuantityPrecision };\n}\n"],"mappings":";;;AA2BA,eAAsB,EAAc,GAAgB,GAA8D;CAChH,IAAM,EAAE,eAAY,mBAAgB,yBAAsB;CAC1D,IAAI,MAAe,KAAA,KAAa,MAAmB,KAAA,KAAa,MAAsB,KAAA,GACpF,OAAO;EAAE,MAAM;EAAY;EAAgB;CAAkB;CAI/D,IAAM,KAAQ,MADQ,EAAW,GAAQ,EAAE,SAAS,EAAW,QAAQ,CAAC,GAClD,MAAM,MAAM,EAAE,cAAc,EAAW,QAAQ;CACrE,IAAI,CAAC,GACH,MAAM,IAAI,EACR,OACA,4BACA,aAAa,EAAW,SAAS,2CACnC;CAGF,IAAM,IAAO,KAAc,EAAM,MAC3B,IAAyB,KAAkB,EAAM,iBACjD,IAA4B,KAAqB,EAAM;CAC7D,IAAI,MAAS,KAAA,KAAa,MAA2B,KAAA,KAAa,MAA8B,KAAA,GAC9F,MAAM,IAAI,EACR,OACA,sCACA,qDAAqD,EAAW,SAAS,oDAC3E;CAEF,OAAO;EAAE;EAAM,gBAAgB;EAAwB,mBAAmB;CAA0B;AACtG"}
+{"version":3,"file":"resolve-market.js","names":[],"sources":["../../../../src/solvers/shared/resolvers/resolve-market.ts"],"sourcesContent":["import type { SolverId } from \"../../../core/chains/types\";\nimport type { Config } from \"../../../core/config\";\nimport { SymmError } from \"../../../shared/errors/symm-error\";\nimport { getMarkets } from \"../../markets/get-markets\";\nimport type { ResolvedMarket } from \"./types\";\n\n/**\n * Parameters for {@link resolveMarket}.\n */\nexport interface ResolveMarketParameters {\n  chainId?: number;\n  /**\n   * Solver whose `/contract-symbols` listing to read. **Must match the solver\n   * the trade is sent to** — the resolved `name` and precisions are encoded into\n   * the signed quote. Defaults to the chain's `defaultSolverId`.\n   */\n  solverId?: SolverId;\n  marketId: number;\n  marketName?: string;\n  pricePrecision?: number;\n  quantityPrecision?: number;\n  /**\n   * Also resolve the market's solver-fee caps (`minOpenSolverFeeCap` /\n   * `minCloseSolverFeeCap`, decimal ratio strings). With this set, pre-filled\n   * metadata short-circuits the fetch only when both caps are pre-filled too;\n   * a fetched market that carries no caps (a non-Enigma kind) resolves both to\n   * `\"0\"`. The open wizard sets this; the close wizard does not need caps.\n   */\n  includeSolverFeeCaps?: boolean;\n  /** Pre-fetched `minOpenSolverFeeCap` (decimal ratio string). */\n  minOpenSolverFeeCap?: string;\n  /** Pre-fetched `minCloseSolverFeeCap` (decimal ratio string). */\n  minCloseSolverFeeCap?: string;\n  /**\n   * Also resolve the market's solver fee rates (`hedgerFeeOpen` /\n   * `hedgerFeeClose`, decimal fraction strings). Same short-circuit contract as\n   * `includeSolverFeeCaps`: pre-filled metadata skips the fetch only when both\n   * rates are pre-filled too. The open wizard sets this — the solver charges\n   * these fees from the VA, so the `addMargin` transfer must fund them.\n   */\n  includeHedgerFees?: boolean;\n  /** Pre-fetched `hedgerFeeOpen` (decimal fraction string). */\n  hedgerFeeOpen?: string;\n  /** Pre-fetched `hedgerFeeClose` (decimal fraction string). */\n  hedgerFeeClose?: string;\n  /** Pre-fetched early (peak) close-fee rate (decimal fraction string). */\n  hedgerFeeCloseEarlyRate?: string;\n  /** Pre-fetched early-window length in seconds. */\n  hedgerFeeCloseEarlyThreshold?: number;\n  /** Pre-fetched standard-rate threshold in seconds. */\n  hedgerFeeCloseStandardThreshold?: number;\n}\n\n/**\n * Resolve market metadata (`name`, `pricePrecision`, `quantityPrecision`, and —\n * when `includeSolverFeeCaps` is set — the solver-fee cap minimums) for\n * `marketId`. Returns caller-supplied values when everything needed is\n * pre-filled; otherwise fetches `/contract-symbols` and extracts the matching\n * record. The normalized {@link Market} shape guarantees the metadata fields,\n * so only \"not found\" can fail here.\n *\n * Shared by the instant-open and instant-close wizards.\n *\n * @throws {SymmError} `RESOLVE_MARKET_NOT_FOUND` when no record matches.\n */\nexport async function resolveMarket(config: Config, parameters: ResolveMarketParameters): Promise<ResolvedMarket> {\n  const { marketName, pricePrecision, quantityPrecision, minOpenSolverFeeCap, minCloseSolverFeeCap } = parameters;\n  const { hedgerFeeOpen, hedgerFeeClose } = parameters;\n  const { hedgerFeeCloseEarlyRate, hedgerFeeCloseEarlyThreshold, hedgerFeeCloseStandardThreshold } = parameters;\n  const needCaps = parameters.includeSolverFeeCaps === true;\n  const capsPrefilled = minOpenSolverFeeCap !== undefined && minCloseSolverFeeCap !== undefined;\n  const needFees = parameters.includeHedgerFees === true;\n  const feesPrefilled = hedgerFeeOpen !== undefined && hedgerFeeClose !== undefined;\n\n  if (\n    marketName !== undefined &&\n    pricePrecision !== undefined &&\n    quantityPrecision !== undefined &&\n    (!needCaps || capsPrefilled) &&\n    (!needFees || feesPrefilled)\n  ) {\n    return {\n      name: marketName,\n      pricePrecision,\n      quantityPrecision,\n      ...(needCaps ? { minOpenSolverFeeCap, minCloseSolverFeeCap } : {}),\n      ...(needFees\n        ? {\n            hedgerFeeOpen,\n            hedgerFeeClose,\n            hedgerFeeCloseEarlyRate,\n            hedgerFeeCloseEarlyThreshold,\n            hedgerFeeCloseStandardThreshold,\n          }\n        : {}),\n    };\n  }\n\n  const markets = await getMarkets(config, { chainId: parameters.chainId, solverId: parameters.solverId });\n  const match = markets.find((m) => m.symbolId === parameters.marketId);\n  if (!match) {\n    throw new SymmError(\n      \"api\",\n      \"RESOLVE_MARKET_NOT_FOUND\",\n      `Market id ${parameters.marketId} not returned by solver /contract-symbols.`,\n    );\n  }\n\n  return {\n    name: marketName ?? match.name,\n    pricePrecision: pricePrecision ?? match.pricePrecision,\n    quantityPrecision: quantityPrecision ?? match.quantityPrecision,\n    ...(needCaps\n      ? {\n          minOpenSolverFeeCap: minOpenSolverFeeCap ?? (match.kind === \"enigma\" ? match.minOpenSolverFeeCap : \"0\"),\n          minCloseSolverFeeCap: minCloseSolverFeeCap ?? (match.kind === \"enigma\" ? match.minCloseSolverFeeCap : \"0\"),\n        }\n      : {}),\n    ...(needFees\n      ? {\n          hedgerFeeOpen: hedgerFeeOpen ?? match.hedgerFeeOpen,\n          hedgerFeeClose: hedgerFeeClose ?? match.hedgerFeeClose,\n          // Early-close decay is Enigma-only; a non-Enigma market has no such fields.\n          hedgerFeeCloseEarlyRate:\n            hedgerFeeCloseEarlyRate ?? (match.kind === \"enigma\" ? match.hedgerFeeCloseEarlyRate : undefined),\n          hedgerFeeCloseEarlyThreshold:\n            hedgerFeeCloseEarlyThreshold ?? (match.kind === \"enigma\" ? match.hedgerFeeCloseEarlyThreshold : undefined),\n          hedgerFeeCloseStandardThreshold:\n            hedgerFeeCloseStandardThreshold ??\n            (match.kind === \"enigma\" ? match.hedgerFeeCloseStandardThreshold : undefined),\n        }\n      : {}),\n  };\n}\n"],"mappings":";;;AAiEA,eAAsB,EAAc,GAAgB,GAA8D;CAChH,IAAM,EAAE,eAAY,mBAAgB,sBAAmB,wBAAqB,4BAAyB,GAC/F,EAAE,kBAAe,sBAAmB,GACpC,EAAE,4BAAyB,iCAA8B,uCAAoC,GAC7F,IAAW,EAAW,yBAAyB,IAC/C,IAAgB,MAAwB,KAAA,KAAa,MAAyB,KAAA,GAC9E,IAAW,EAAW,sBAAsB;CAGlD,IACE,MAAe,KAAA,KACf,MAAmB,KAAA,KACnB,MAAsB,KAAA,MACrB,CAAC,KAAY,OACb,CAAC,KAPkB,MAAkB,KAAA,KAAa,MAAmB,KAAA,IAStE,OAAO;EACL,MAAM;EACN;EACA;EACA,GAAI,IAAW;GAAE;GAAqB;EAAqB,IAAI,CAAC;EAChE,GAAI,IACA;GACE;GACA;GACA;GACA;GACA;EACF,IACA,CAAC;CACP;CAIF,IAAM,KAAQ,MADQ,EAAW,GAAQ;EAAE,SAAS,EAAW;EAAS,UAAU,EAAW;CAAS,CAAC,GACjF,MAAM,MAAM,EAAE,aAAa,EAAW,QAAQ;CACpE,IAAI,CAAC,GACH,MAAM,IAAI,EACR,OACA,4BACA,aAAa,EAAW,SAAS,2CACnC;CAGF,OAAO;EACL,MAAM,KAAc,EAAM;EAC1B,gBAAgB,KAAkB,EAAM;EACxC,mBAAmB,KAAqB,EAAM;EAC9C,GAAI,IACA;GACE,qBAAqB,MAAwB,EAAM,SAAS,WAAW,EAAM,sBAAsB;GACnG,sBAAsB,MAAyB,EAAM,SAAS,WAAW,EAAM,uBAAuB;EACxG,IACA,CAAC;EACL,GAAI,IACA;GACE,eAAe,KAAiB,EAAM;GACtC,gBAAgB,KAAkB,EAAM;GAExC,yBACE,MAA4B,EAAM,SAAS,WAAW,EAAM,0BAA0B,KAAA;GACxF,8BACE,MAAiC,EAAM,SAAS,WAAW,EAAM,+BAA+B,KAAA;GAClG,iCACE,MACC,EAAM,SAAS,WAAW,EAAM,kCAAkC,KAAA;EACvE,IACA,CAAC;CACP;AACF"}

package/dist/solvers/shared/resolvers/types.d.ts

@@ -10,5 +10,19 @@ export interface ResolvedMarket {
     name: string;
     pricePrecision: number;
     quantityPrecision: number;
+    /** Present when resolved with `includeSolverFeeCaps`. Decimal ratio string; `"0"` for kinds without caps. */
+    minOpenSolverFeeCap?: string;
+    /** Present when resolved with `includeSolverFeeCaps`. Decimal ratio string; `"0"` for kinds without caps. */
+    minCloseSolverFeeCap?: string;
+    /** Present when resolved with `includeHedgerFees`. Solver open-fee rate, decimal fraction string. */
+    hedgerFeeOpen?: string;
+    /** Present when resolved with `includeHedgerFees`. Solver standard (floor) close-fee rate, decimal fraction string. */
+    hedgerFeeClose?: string;
+    /** Present when resolved with `includeHedgerFees` on an Enigma market. Early (peak) close-fee rate, decimal fraction string. */
+    hedgerFeeCloseEarlyRate?: string;
+    /** Present when resolved with `includeHedgerFees` on an Enigma market. Early-window length in seconds. */
+    hedgerFeeCloseEarlyThreshold?: number;
+    /** Present when resolved with `includeHedgerFees` on an Enigma market. Standard-rate threshold in seconds. */
+    hedgerFeeCloseStandardThreshold?: number;
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/solvers/shared/resolvers/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/solvers/shared/resolvers/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;CAC3B"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/solvers/shared/resolvers/types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,6GAA6G;IAC7G,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,6GAA6G;IAC7G,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,qGAAqG;IACrG,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,uHAAuH;IACvH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gIAAgI;IAChI,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,0GAA0G;IAC1G,4BAA4B,CAAC,EAAE,MAAM,CAAC;IACtC,8GAA8G;IAC9G,+BAA+B,CAAC,EAAE,MAAM,CAAC;CAC1C"}

package/dist/solvers/shared/solver-close-fee.d.ts

@@ -0,0 +1,76 @@
+/**
+ * The close-fee rates a lowcap (Enigma) market charges, as flat fields matching
+ * the `/symbols` wire names. Every {@link SolverSymbol} carries these, so a
+ * symbol can be passed straight to {@link getSolverCloseFeeRate} /
+ * {@link calculateSolverCloseFee}.
+ *
+ * The solver charges more to close a freshly opened position: the rate starts
+ * at `hedgerFeeCloseEarlyRate`, holds flat until `hedgerFeeCloseEarlyThreshold`
+ * seconds, then decays linearly to the standard `hedgerFeeClose` by
+ * `hedgerFeeCloseStandardThreshold`. A market with no decay (a non-Enigma
+ * solver, or one omitting the early fields) has `hedgerFeeCloseEarlyRate` equal
+ * to `hedgerFeeClose` and both thresholds `0`.
+ */
+export interface SolverCloseFeeRates {
+    /** Standard (floor) close-fee rate, decimal fraction string (e.g. `"0.0006"`). Wire: `hedger_fee_close`. */
+    hedgerFeeClose: string;
+    /** Early (peak) close-fee rate, decimal fraction string (e.g. `"0.0024"`). Wire: `hedger_fee_close_early_rate`. */
+    hedgerFeeCloseEarlyRate: string;
+    /** Seconds from open during which the early rate applies flat. Wire: `hedger_fee_close_early_threshold`. */
+    hedgerFeeCloseEarlyThreshold: number;
+    /** Seconds from open at/after which the standard rate applies; linear between the thresholds. Wire: `hedger_fee_close_standard_threshold`. */
+    hedgerFeeCloseStandardThreshold: number;
+}
+/**
+ * The solver close-fee **rate** for a lowcap position held `holdingSeconds`
+ * since it opened.
+ *
+ * Piecewise over the holding age `t`:
+ *
+ * - `t ≤ hedgerFeeCloseEarlyThreshold` → `hedgerFeeCloseEarlyRate` (flat peak);
+ * - `t ≥ hedgerFeeCloseStandardThreshold` → `hedgerFeeClose` (flat floor);
+ * - in between → linear interpolation from the early rate down to the floor.
+ *
+ * With the staging numbers (`hedgerFeeCloseEarlyRate: "0.0024"`,
+ * `hedgerFeeClose: "0.0006"`, thresholds `30` / `180`): a close at 30s pays
+ * `0.0024`, at 105s pays the midpoint `0.0015`, and at 180s pays `0.0006`. A
+ * negative `holdingSeconds` (clock skew on a just-opened position) is clamped
+ * to `0`, so it prices at the peak. When no decay is defined — an unusable
+ * early rate, or `hedgerFeeCloseStandardThreshold ≤ hedgerFeeCloseEarlyThreshold`
+ * — the rate steps from the early rate straight to the floor.
+ *
+ * A {@link SolverSymbol} satisfies the `fees` parameter, so call it directly:
+ * `getSolverCloseFeeRate(symbol, holdingSeconds)`.
+ *
+ * @returns The close-fee rate as a decimal fraction string.
+ */
+export declare function getSolverCloseFeeRate(fees: SolverCloseFeeRates, holdingSeconds: number): string;
+/**
+ * The solver close-fee **amount** for a lowcap position:
+ * `getSolverCloseFeeRate(fees, holdingSeconds) × notional`.
+ *
+ * Use this to price a close: with the position's `createTimestamp`, pass
+ * `holdingSeconds = now − createTimestamp` to get the fee the solver charges
+ * right now. Pass `holdingSeconds = 0` for the worst case (a just-opened
+ * position), which is what an open must provision.
+ *
+ * @returns The close fee as a decimal string; `"0"` when `notional` is
+ *   NaN/absent or negative.
+ *
+ * @example
+ * ```ts
+ * const fee = calculateSolverCloseFee(symbol, { notional: "1000", holdingSeconds: 0 });
+ * // "2.4" with staging hedgerFeeCloseEarlyRate 0.0024
+ * ```
+ */
+export declare function calculateSolverCloseFee(fees: SolverCloseFeeRates, params: {
+    notional: string;
+    holdingSeconds: number;
+}): string;
+/**
+ * Coerce a solver's whole-seconds threshold value (a wire string, a number, or
+ * absent) to a non-negative finite number, defaulting to `0`. Used when mapping
+ * raw `/symbols` rows onto {@link SolverCloseFeeRates}' threshold fields.
+ */
+export declare function toThresholdSeconds(value: string | number | undefined): number;
+//# sourceMappingURL=solver-close-fee.d.ts.map

package/dist/solvers/shared/solver-close-fee.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solver-close-fee.d.ts","sourceRoot":"","sources":["../../../src/solvers/shared/solver-close-fee.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,mBAAmB;IAClC,4GAA4G;IAC5G,cAAc,EAAE,MAAM,CAAC;IACvB,mHAAmH;IACnH,uBAAuB,EAAE,MAAM,CAAC;IAChC,4GAA4G;IAC5G,4BAA4B,EAAE,MAAM,CAAC;IACrC,8IAA8I;IAC9I,+BAA+B,EAAE,MAAM,CAAC;CACzC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM,CAqB/F;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,mBAAmB,EACzB,MAAM,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,MAAM,CAAA;CAAE,GACnD,MAAM,CAMR;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,CAG7E"}

package/dist/solvers/shared/solver-close-fee.js

@@ -0,0 +1,26 @@
+import { toDecimal as e } from "@symmio/utils/decimal";
+//#region src/solvers/shared/solver-close-fee.ts
+function t(t, n) {
+	let r = e(t.hedgerFeeCloseEarlyRate), i = e(t.hedgerFeeClose), a = !r.isNaN() && !r.isNegative(), o = !i.isNaN() && !i.isNegative();
+	if (!a) return o ? i.toString() : "0";
+	if (!o) return r.toString();
+	let s = Math.max(0, n), c = t.hedgerFeeCloseEarlyThreshold, l = t.hedgerFeeCloseStandardThreshold;
+	if (s <= c) return r.toString();
+	if (l <= c || s >= l) return i.toString();
+	let u = e(s - c).div(l - c);
+	return r.plus(i.minus(r).times(u)).toString();
+}
+function n(n, r) {
+	let i = e(r.notional);
+	if (i.isNaN() || i.isNegative()) return "0";
+	let a = e(t(n, r.holdingSeconds));
+	return a.isNaN() ? "0" : i.times(a).toString();
+}
+function r(e) {
+	let t = typeof e == "number" ? e : Number(e);
+	return Number.isFinite(t) && t >= 0 ? t : 0;
+}
+//#endregion
+export { n as calculateSolverCloseFee, t as getSolverCloseFeeRate, r as toThresholdSeconds };
+
+//# sourceMappingURL=solver-close-fee.js.map

package/dist/solvers/shared/solver-close-fee.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"solver-close-fee.js","names":[],"sources":["../../../src/solvers/shared/solver-close-fee.ts"],"sourcesContent":["import { toDecimal } from \"@symmio/utils/decimal\";\n\n/**\n * The close-fee rates a lowcap (Enigma) market charges, as flat fields matching\n * the `/symbols` wire names. Every {@link SolverSymbol} carries these, so a\n * symbol can be passed straight to {@link getSolverCloseFeeRate} /\n * {@link calculateSolverCloseFee}.\n *\n * The solver charges more to close a freshly opened position: the rate starts\n * at `hedgerFeeCloseEarlyRate`, holds flat until `hedgerFeeCloseEarlyThreshold`\n * seconds, then decays linearly to the standard `hedgerFeeClose` by\n * `hedgerFeeCloseStandardThreshold`. A market with no decay (a non-Enigma\n * solver, or one omitting the early fields) has `hedgerFeeCloseEarlyRate` equal\n * to `hedgerFeeClose` and both thresholds `0`.\n */\nexport interface SolverCloseFeeRates {\n  /** Standard (floor) close-fee rate, decimal fraction string (e.g. `\"0.0006\"`). Wire: `hedger_fee_close`. */\n  hedgerFeeClose: string;\n  /** Early (peak) close-fee rate, decimal fraction string (e.g. `\"0.0024\"`). Wire: `hedger_fee_close_early_rate`. */\n  hedgerFeeCloseEarlyRate: string;\n  /** Seconds from open during which the early rate applies flat. Wire: `hedger_fee_close_early_threshold`. */\n  hedgerFeeCloseEarlyThreshold: number;\n  /** Seconds from open at/after which the standard rate applies; linear between the thresholds. Wire: `hedger_fee_close_standard_threshold`. */\n  hedgerFeeCloseStandardThreshold: number;\n}\n\n/**\n * The solver close-fee **rate** for a lowcap position held `holdingSeconds`\n * since it opened.\n *\n * Piecewise over the holding age `t`:\n *\n * - `t ≤ hedgerFeeCloseEarlyThreshold` → `hedgerFeeCloseEarlyRate` (flat peak);\n * - `t ≥ hedgerFeeCloseStandardThreshold` → `hedgerFeeClose` (flat floor);\n * - in between → linear interpolation from the early rate down to the floor.\n *\n * With the staging numbers (`hedgerFeeCloseEarlyRate: \"0.0024\"`,\n * `hedgerFeeClose: \"0.0006\"`, thresholds `30` / `180`): a close at 30s pays\n * `0.0024`, at 105s pays the midpoint `0.0015`, and at 180s pays `0.0006`. A\n * negative `holdingSeconds` (clock skew on a just-opened position) is clamped\n * to `0`, so it prices at the peak. When no decay is defined — an unusable\n * early rate, or `hedgerFeeCloseStandardThreshold ≤ hedgerFeeCloseEarlyThreshold`\n * — the rate steps from the early rate straight to the floor.\n *\n * A {@link SolverSymbol} satisfies the `fees` parameter, so call it directly:\n * `getSolverCloseFeeRate(symbol, holdingSeconds)`.\n *\n * @returns The close-fee rate as a decimal fraction string.\n */\nexport function getSolverCloseFeeRate(fees: SolverCloseFeeRates, holdingSeconds: number): string {\n  const early = toDecimal(fees.hedgerFeeCloseEarlyRate);\n  const close = toDecimal(fees.hedgerFeeClose);\n  const usableEarly = !early.isNaN() && !early.isNegative();\n  const usableClose = !close.isNaN() && !close.isNegative();\n\n  // No usable early rate → there is no decay to price; the standard rate stands\n  // (and `\"0\"` only if that is unusable too, matching the pre-schedule default).\n  if (!usableEarly) return usableClose ? close.toString() : \"0\";\n  if (!usableClose) return early.toString();\n\n  const t = Math.max(0, holdingSeconds);\n  const earlyT = fees.hedgerFeeCloseEarlyThreshold;\n  const standardT = fees.hedgerFeeCloseStandardThreshold;\n\n  if (t <= earlyT) return early.toString();\n  // Non-increasing thresholds leave no interpolation window: step to the floor.\n  if (standardT <= earlyT || t >= standardT) return close.toString();\n\n  const progress = toDecimal(t - earlyT).div(standardT - earlyT);\n  return early.plus(close.minus(early).times(progress)).toString();\n}\n\n/**\n * The solver close-fee **amount** for a lowcap position:\n * `getSolverCloseFeeRate(fees, holdingSeconds) × notional`.\n *\n * Use this to price a close: with the position's `createTimestamp`, pass\n * `holdingSeconds = now − createTimestamp` to get the fee the solver charges\n * right now. Pass `holdingSeconds = 0` for the worst case (a just-opened\n * position), which is what an open must provision.\n *\n * @returns The close fee as a decimal string; `\"0\"` when `notional` is\n *   NaN/absent or negative.\n *\n * @example\n * ```ts\n * const fee = calculateSolverCloseFee(symbol, { notional: \"1000\", holdingSeconds: 0 });\n * // \"2.4\" with staging hedgerFeeCloseEarlyRate 0.0024\n * ```\n */\nexport function calculateSolverCloseFee(\n  fees: SolverCloseFeeRates,\n  params: { notional: string; holdingSeconds: number },\n): string {\n  const notional = toDecimal(params.notional);\n  if (notional.isNaN() || notional.isNegative()) return \"0\";\n  const rate = toDecimal(getSolverCloseFeeRate(fees, params.holdingSeconds));\n  if (rate.isNaN()) return \"0\";\n  return notional.times(rate).toString();\n}\n\n/**\n * Coerce a solver's whole-seconds threshold value (a wire string, a number, or\n * absent) to a non-negative finite number, defaulting to `0`. Used when mapping\n * raw `/symbols` rows onto {@link SolverCloseFeeRates}' threshold fields.\n */\nexport function toThresholdSeconds(value: string | number | undefined): number {\n  const seconds = typeof value === \"number\" ? value : Number(value);\n  return Number.isFinite(seconds) && seconds >= 0 ? seconds : 0;\n}\n"],"mappings":";;AAiDA,SAAgB,EAAsB,GAA2B,GAAgC;CAC/F,IAAM,IAAQ,EAAU,EAAK,uBAAuB,GAC9C,IAAQ,EAAU,EAAK,cAAc,GACrC,IAAc,CAAC,EAAM,MAAM,KAAK,CAAC,EAAM,WAAW,GAClD,IAAc,CAAC,EAAM,MAAM,KAAK,CAAC,EAAM,WAAW;CAIxD,IAAI,CAAC,GAAa,OAAO,IAAc,EAAM,SAAS,IAAI;CAC1D,IAAI,CAAC,GAAa,OAAO,EAAM,SAAS;CAExC,IAAM,IAAI,KAAK,IAAI,GAAG,CAAc,GAC9B,IAAS,EAAK,8BACd,IAAY,EAAK;CAEvB,IAAI,KAAK,GAAQ,OAAO,EAAM,SAAS;CAEvC,IAAI,KAAa,KAAU,KAAK,GAAW,OAAO,EAAM,SAAS;CAEjE,IAAM,IAAW,EAAU,IAAI,CAAM,EAAE,IAAI,IAAY,CAAM;CAC7D,OAAO,EAAM,KAAK,EAAM,MAAM,CAAK,EAAE,MAAM,CAAQ,CAAC,EAAE,SAAS;AACjE;AAoBA,SAAgB,EACd,GACA,GACQ;CACR,IAAM,IAAW,EAAU,EAAO,QAAQ;CAC1C,IAAI,EAAS,MAAM,KAAK,EAAS,WAAW,GAAG,OAAO;CACtD,IAAM,IAAO,EAAU,EAAsB,GAAM,EAAO,cAAc,CAAC;CAEzE,OADI,EAAK,MAAM,IAAU,MAClB,EAAS,MAAM,CAAI,EAAE,SAAS;AACvC;AAOA,SAAgB,EAAmB,GAA4C;CAC7E,IAAM,IAAU,OAAO,KAAU,WAAW,IAAQ,OAAO,CAAK;CAChE,OAAO,OAAO,SAAS,CAAO,KAAK,KAAW,IAAI,IAAU;AAC9D"}

package/dist/solvers/symbols/get-symbols.d.ts

@@ -0,0 +1,53 @@
+import { Config } from '../../core/config/index.js';
+import { Compute, ReadSolverParameter } from '../../shared/types/properties.js';
+import { SolverSymbol, SymbolStateFilter, SymbolValidityFilter } from './types.js';
+/**
+ * Parameters for {@link getSymbols}.
+ */
+export type GetSymbolsParameters = Compute<ReadSolverParameter & {
+    /** Max rows to return (solver max 500, default 100). */
+    limit?: number;
+    /** Row offset for pagination (default 0). */
+    offset?: number;
+    /** Restrict to a single symbol by its numeric id. */
+    symbolId?: number;
+    /** Case-insensitive substring match on the symbol name. */
+    search?: string;
+    /** Exact-match filter on the base asset. */
+    asset?: string;
+    /** Exact-match filter on the collateral token address. */
+    tokenAddress?: string;
+    /** Validity filter; the solver defaults to `"true"` (valid symbols only). */
+    isValid?: SymbolValidityFilter;
+    /** Long-side trading-state filter. */
+    stateLong?: SymbolStateFilter;
+    /** Short-side trading-state filter. */
+    stateShort?: SymbolStateFilter;
+}>;
+/** Return type of {@link getSymbols}: one entry per symbol. */
+export type GetSymbolsReturnType = SolverSymbol[];
+/**
+ * Fetch the tradable symbol catalogue from the chain's solver `/symbols`
+ * endpoint. Returns a normalized {@link SolverSymbol} per row — id, name,
+ * precisions, leverage, fees, and per-side trading state — filtered and paged by
+ * the given `parameters`. The solver base URL is resolved from `config` per call,
+ * so multiple chains never clobber each other.
+ *
+ * `/symbols` is an **Enigma-only** endpoint; the action asserts the resolved
+ * solver is an `enigma` solver and throws before hitting the wire otherwise.
+ *
+ * @param config - The SDK config.
+ * @param parameters - Optional chain id, solver id, and `/symbols` filters.
+ * @returns Normalized symbols, one {@link SolverSymbol} per row.
+ * @throws {SymmApiError} when the API request fails.
+ * @throws {SymmError} `UNSUPPORTED_BY_SOLVER` when the resolved solver is not an `enigma` solver, or when the chain is unsupported.
+ *
+ * @example
+ * ```ts
+ * const symbols = await getSymbols(config, { search: "BTC" });
+ * const btc = symbols.find((s) => s.name === "BTCUSDT");
+ * console.log(btc?.maxLeverage);
+ * ```
+ */
+export declare function getSymbols(config: Config, parameters?: GetSymbolsParameters): Promise<GetSymbolsReturnType>;
+//# sourceMappingURL=get-symbols.d.ts.map

package/dist/solvers/symbols/get-symbols.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-symbols.d.ts","sourceRoot":"","sources":["../../../src/solvers/symbols/get-symbols.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAIlF,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAErF;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,OAAO,CACxC,mBAAmB,GAAG;IACpB,wDAAwD;IACxD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,6CAA6C;IAC7C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,qDAAqD;IACrD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2DAA2D;IAC3D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,4CAA4C;IAC5C,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,0DAA0D;IAC1D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,6EAA6E;IAC7E,OAAO,CAAC,EAAE,oBAAoB,CAAC;IAC/B,sCAAsC;IACtC,SAAS,CAAC,EAAE,iBAAiB,CAAC;IAC9B,uCAAuC;IACvC,UAAU,CAAC,EAAE,iBAAiB,CAAC;CAChC,CACF,CAAC;AAEF,+DAA+D;AAC/D,MAAM,MAAM,oBAAoB,GAAG,YAAY,EAAE,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,GAAE,oBAAyB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAIrH"}

package/dist/solvers/symbols/get-symbols.js

@@ -0,0 +1,37 @@
+import { SymmApiError as e, SymmError as t } from "../../shared/errors/symm-error.js";
+import { getSymbols as n } from "../types/generated/enigma-solver.js";
+import { assertSolverKind as r } from "../assert-solver-kind.js";
+import { toSolverSymbols as i } from "./to-solver-symbol.js";
+import { isAxiosError as a } from "axios";
+//#region src/solvers/symbols/get-symbols.ts
+async function o(e, t = {}) {
+	let n = e.getSolver({
+		chainId: t.chainId,
+		solverId: t.solverId
+	});
+	return r(n, "enigma", "getSymbols"), s(n.url, t);
+}
+async function s(r, o) {
+	try {
+		return i((await n({
+			limit: o.limit,
+			offset: o.offset,
+			symbol_id: o.symbolId,
+			search: o.search,
+			asset: o.asset,
+			token_address: o.tokenAddress,
+			is_valid: o.isValid,
+			state_long: o.stateLong,
+			state_short: o.stateShort
+		}, { baseURL: r })).data.symbols ?? []);
+	} catch (n) {
+		throw n instanceof t ? n : a(n) ? e.fromAxios(n, {
+			code: "FETCH_SYMBOLS_FAILED",
+			baseURL: r
+		}) : new t("api", "FETCH_SYMBOLS_FAILED", `Failed to fetch symbols: ${n instanceof Error ? n.message : String(n)}`, { cause: n instanceof Error ? n : void 0 });
+	}
+}
+//#endregion
+export { o as getSymbols };
+
+//# sourceMappingURL=get-symbols.js.map

package/dist/solvers/symbols/get-symbols.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-symbols.js","names":[],"sources":["../../../src/solvers/symbols/get-symbols.ts"],"sourcesContent":["import { isAxiosError } from \"axios\";\nimport type { Config } from \"../../core/config\";\nimport { SymmApiError, SymmError } from \"../../shared/errors/symm-error\";\nimport type { Compute, ReadSolverParameter } from \"../../shared/types/properties\";\nimport { assertSolverKind } from \"../assert-solver-kind\";\nimport { getSymbols as requestSymbols } from \"../types/generated/enigma-solver\";\nimport { toSolverSymbols } from \"./to-solver-symbol\";\nimport type { SolverSymbol, SymbolStateFilter, SymbolValidityFilter } from \"./types\";\n\n/**\n * Parameters for {@link getSymbols}.\n */\nexport type GetSymbolsParameters = Compute<\n  ReadSolverParameter & {\n    /** Max rows to return (solver max 500, default 100). */\n    limit?: number;\n    /** Row offset for pagination (default 0). */\n    offset?: number;\n    /** Restrict to a single symbol by its numeric id. */\n    symbolId?: number;\n    /** Case-insensitive substring match on the symbol name. */\n    search?: string;\n    /** Exact-match filter on the base asset. */\n    asset?: string;\n    /** Exact-match filter on the collateral token address. */\n    tokenAddress?: string;\n    /** Validity filter; the solver defaults to `\"true\"` (valid symbols only). */\n    isValid?: SymbolValidityFilter;\n    /** Long-side trading-state filter. */\n    stateLong?: SymbolStateFilter;\n    /** Short-side trading-state filter. */\n    stateShort?: SymbolStateFilter;\n  }\n>;\n\n/** Return type of {@link getSymbols}: one entry per symbol. */\nexport type GetSymbolsReturnType = SolverSymbol[];\n\n/**\n * Fetch the tradable symbol catalogue from the chain's solver `/symbols`\n * endpoint. Returns a normalized {@link SolverSymbol} per row — id, name,\n * precisions, leverage, fees, and per-side trading state — filtered and paged by\n * the given `parameters`. The solver base URL is resolved from `config` per call,\n * so multiple chains never clobber each other.\n *\n * `/symbols` is an **Enigma-only** endpoint; the action asserts the resolved\n * solver is an `enigma` solver and throws before hitting the wire otherwise.\n *\n * @param config - The SDK config.\n * @param parameters - Optional chain id, solver id, and `/symbols` filters.\n * @returns Normalized symbols, one {@link SolverSymbol} per row.\n * @throws {SymmApiError} when the API request fails.\n * @throws {SymmError} `UNSUPPORTED_BY_SOLVER` when the resolved solver is not an `enigma` solver, or when the chain is unsupported.\n *\n * @example\n * ```ts\n * const symbols = await getSymbols(config, { search: \"BTC\" });\n * const btc = symbols.find((s) => s.name === \"BTCUSDT\");\n * console.log(btc?.maxLeverage);\n * ```\n */\nexport async function getSymbols(config: Config, parameters: GetSymbolsParameters = {}): Promise<GetSymbolsReturnType> {\n  const solver = config.getSolver({ chainId: parameters.chainId, solverId: parameters.solverId });\n  assertSolverKind(solver, \"enigma\", \"getSymbols\");\n  return fetchSymbols(solver.url, parameters);\n}\n\n/**\n * Call the solver's `/symbols` endpoint with a per-call base URL, mapping the\n * SDK's camelCase filters onto the generated snake_case query params, and\n * normalize the response rows into the SDK's stable array.\n *\n * @internal\n */\nasync function fetchSymbols(baseURL: string, parameters: GetSymbolsParameters): Promise<SolverSymbol[]> {\n  try {\n    const response = await requestSymbols(\n      {\n        limit: parameters.limit,\n        offset: parameters.offset,\n        symbol_id: parameters.symbolId,\n        search: parameters.search,\n        asset: parameters.asset,\n        token_address: parameters.tokenAddress,\n        is_valid: parameters.isValid,\n        state_long: parameters.stateLong,\n        state_short: parameters.stateShort,\n      },\n      { baseURL },\n    );\n    return toSolverSymbols(response.data.symbols ?? []);\n  } catch (err) {\n    if (err instanceof SymmError) throw err;\n\n    if (isAxiosError(err)) {\n      throw SymmApiError.fromAxios(err, { code: \"FETCH_SYMBOLS_FAILED\", baseURL });\n    }\n\n    throw new SymmError(\n      \"api\",\n      \"FETCH_SYMBOLS_FAILED\",\n      `Failed to fetch symbols: ${err instanceof Error ? err.message : String(err)}`,\n      { cause: err instanceof Error ? err : undefined },\n    );\n  }\n}\n"],"mappings":";;;;;;AA6DA,eAAsB,EAAW,GAAgB,IAAmC,CAAC,GAAkC;CACrH,IAAM,IAAS,EAAO,UAAU;EAAE,SAAS,EAAW;EAAS,UAAU,EAAW;CAAS,CAAC;CAE9F,OADA,EAAiB,GAAQ,UAAU,YAAY,GACxC,EAAa,EAAO,KAAK,CAAU;AAC5C;AASA,eAAe,EAAa,GAAiB,GAA2D;CACtG,IAAI;EAeF,OAAO,GAAgB,MAdA,EACrB;GACE,OAAO,EAAW;GAClB,QAAQ,EAAW;GACnB,WAAW,EAAW;GACtB,QAAQ,EAAW;GACnB,OAAO,EAAW;GAClB,eAAe,EAAW;GAC1B,UAAU,EAAW;GACrB,YAAY,EAAW;GACvB,aAAa,EAAW;EAC1B,GACA,EAAE,WAAQ,CACZ,GACgC,KAAK,WAAW,CAAC,CAAC;CACpD,SAAS,GAAK;EAOZ,MANI,aAAe,IAAiB,IAEhC,EAAa,CAAG,IACZ,EAAa,UAAU,GAAK;GAAE,MAAM;GAAwB;EAAQ,CAAC,IAGvE,IAAI,EACR,OACA,wBACA,4BAA4B,aAAe,QAAQ,EAAI,UAAU,OAAO,CAAG,KAC3E,EAAE,OAAO,aAAe,QAAQ,IAAM,KAAA,EAAU,CAClD;CACF;AACF"}

package/dist/solvers/symbols/index.d.ts

@@ -0,0 +1,5 @@
+export * from './get-symbols.js';
+export * from './query.js';
+export * from './to-solver-symbol.js';
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/solvers/symbols/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/solvers/symbols/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,SAAS,CAAC;AACxB,cAAc,oBAAoB,CAAC;AACnC,cAAc,SAAS,CAAC"}

package/dist/solvers/symbols/query.d.ts

@@ -0,0 +1,28 @@
+import { Config } from '../../core/config/index.js';
+import { Compute, ConfigKeyParameter } from '../../shared/types/properties.js';
+import { QueryParameter, SymmioQueryOptions } from '../../shared/types/query.js';
+import { GetSymbolsParameters, GetSymbolsReturnType } from './get-symbols.js';
+/** Data resolved by the {@link getSymbolsQueryOptions} query. */
+export type GetSymbolsData = GetSymbolsReturnType;
+/** Build the TanStack Query key for {@link getSymbolsQueryOptions}. */
+export declare function getSymbolsQueryKey(options?: Compute<GetSymbolsParameters & ConfigKeyParameter>): readonly ["getSymbols", Record<string, unknown>];
+/** Query-key type produced by {@link getSymbolsQueryKey}. */
+export type GetSymbolsQueryKey = ReturnType<typeof getSymbolsQueryKey>;
+/** Options accepted by {@link getSymbolsQueryOptions}. */
+export type GetSymbolsOptions = Compute<GetSymbolsParameters & QueryParameter<GetSymbolsData, Error, GetSymbolsData, GetSymbolsQueryKey>>;
+/** TanStack Query options returned by {@link getSymbolsQueryOptions}. */
+export type GetSymbolsQueryOptions = SymmioQueryOptions<GetSymbolsData, Error, GetSymbolsData, GetSymbolsQueryKey>;
+/**
+ * Build TanStack Query options for {@link getSymbols}.
+ *
+ * @param config - The SDK config.
+ * @param options - Query parameters (optional `chainId` / `solverId` / `/symbols` filters) and TanStack overrides.
+ * @returns Options to pass to `useQuery` / `queryClient.fetchQuery`.
+ *
+ * @example
+ * ```ts
+ * useQuery(getSymbolsQueryOptions(config, { search: "BTC" }));
+ * ```
+ */
+export declare function getSymbolsQueryOptions(config: Config, options?: GetSymbolsOptions): GetSymbolsQueryOptions;
+//# sourceMappingURL=query.d.ts.map

package/dist/solvers/symbols/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../src/solvers/symbols/query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACjF,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEnF,OAAO,EAAc,KAAK,oBAAoB,EAAE,KAAK,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAEjG,iEAAiE;AACjE,MAAM,MAAM,cAAc,GAAG,oBAAoB,CAAC;AAElD,uEAAuE;AACvE,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,OAAO,CAAC,oBAAoB,GAAG,kBAAkB,CAAM,oDAElG;AAED,6DAA6D;AAC7D,MAAM,MAAM,kBAAkB,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEvE,0DAA0D;AAC1D,MAAM,MAAM,iBAAiB,GAAG,OAAO,CACrC,oBAAoB,GAAG,cAAc,CAAC,cAAc,EAAE,KAAK,EAAE,cAAc,EAAE,kBAAkB,CAAC,CACjG,CAAC;AAEF,yEAAyE;AACzE,MAAM,MAAM,sBAAsB,GAAG,kBAAkB,CAAC,cAAc,EAAE,KAAK,EAAE,cAAc,EAAE,kBAAkB,CAAC,CAAC;AAEnH;;;;;;;;;;;GAWG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,iBAAsB,GAAG,sBAAsB,CAuB9G"}

package/dist/solvers/symbols/query.js

@@ -0,0 +1,33 @@
+import { filterQueryOptions as e } from "../../shared/utils/query.js";
+import { getSymbols as t } from "./get-symbols.js";
+//#region src/solvers/symbols/query.ts
+function n(t = {}) {
+	return ["getSymbols", e(t)];
+}
+function r(e, r = {}) {
+	return {
+		...r.query,
+		queryKey: n({
+			...r,
+			configKey: e.getChainConfigKey(r.chainId)
+		}),
+		enabled: r.query?.enabled ?? !0,
+		queryFn: () => t(e, {
+			chainId: r.chainId,
+			solverId: r.solverId,
+			limit: r.limit,
+			offset: r.offset,
+			symbolId: r.symbolId,
+			search: r.search,
+			asset: r.asset,
+			tokenAddress: r.tokenAddress,
+			isValid: r.isValid,
+			stateLong: r.stateLong,
+			stateShort: r.stateShort
+		})
+	};
+}
+//#endregion
+export { n as getSymbolsQueryKey, r as getSymbolsQueryOptions };
+
+//# sourceMappingURL=query.js.map

package/dist/solvers/symbols/query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.js","names":[],"sources":["../../../src/solvers/symbols/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 { getSymbols, type GetSymbolsParameters, type GetSymbolsReturnType } from \"./get-symbols\";\n\n/** Data resolved by the {@link getSymbolsQueryOptions} query. */\nexport type GetSymbolsData = GetSymbolsReturnType;\n\n/** Build the TanStack Query key for {@link getSymbolsQueryOptions}. */\nexport function getSymbolsQueryKey(options: Compute<GetSymbolsParameters & ConfigKeyParameter> = {}) {\n  return [\"getSymbols\", filterQueryOptions(options)] as const;\n}\n\n/** Query-key type produced by {@link getSymbolsQueryKey}. */\nexport type GetSymbolsQueryKey = ReturnType<typeof getSymbolsQueryKey>;\n\n/** Options accepted by {@link getSymbolsQueryOptions}. */\nexport type GetSymbolsOptions = Compute<\n  GetSymbolsParameters & QueryParameter<GetSymbolsData, Error, GetSymbolsData, GetSymbolsQueryKey>\n>;\n\n/** TanStack Query options returned by {@link getSymbolsQueryOptions}. */\nexport type GetSymbolsQueryOptions = SymmioQueryOptions<GetSymbolsData, Error, GetSymbolsData, GetSymbolsQueryKey>;\n\n/**\n * Build TanStack Query options for {@link getSymbols}.\n *\n * @param config - The SDK config.\n * @param options - Query parameters (optional `chainId` / `solverId` / `/symbols` filters) and TanStack overrides.\n * @returns Options to pass to `useQuery` / `queryClient.fetchQuery`.\n *\n * @example\n * ```ts\n * useQuery(getSymbolsQueryOptions(config, { search: \"BTC\" }));\n * ```\n */\nexport function getSymbolsQueryOptions(config: Config, options: GetSymbolsOptions = {}): GetSymbolsQueryOptions {\n  return {\n    ...options.query,\n    queryKey: getSymbolsQueryKey({\n      ...options,\n      configKey: config.getChainConfigKey(options.chainId),\n    }),\n    enabled: options.query?.enabled ?? true,\n    queryFn: () =>\n      getSymbols(config, {\n        chainId: options.chainId,\n        solverId: options.solverId,\n        limit: options.limit,\n        offset: options.offset,\n        symbolId: options.symbolId,\n        search: options.search,\n        asset: options.asset,\n        tokenAddress: options.tokenAddress,\n        isValid: options.isValid,\n        stateLong: options.stateLong,\n        stateShort: options.stateShort,\n      }),\n  };\n}\n"],"mappings":";;;AAUA,SAAgB,EAAmB,IAA8D,CAAC,GAAG;CACnG,OAAO,CAAC,cAAc,EAAmB,CAAO,CAAC;AACnD;AAyBA,SAAgB,EAAuB,GAAgB,IAA6B,CAAC,GAA2B;CAC9G,OAAO;EACL,GAAG,EAAQ;EACX,UAAU,EAAmB;GAC3B,GAAG;GACH,WAAW,EAAO,kBAAkB,EAAQ,OAAO;EACrD,CAAC;EACD,SAAS,EAAQ,OAAO,WAAW;EACnC,eACE,EAAW,GAAQ;GACjB,SAAS,EAAQ;GACjB,UAAU,EAAQ;GAClB,OAAO,EAAQ;GACf,QAAQ,EAAQ;GAChB,UAAU,EAAQ;GAClB,QAAQ,EAAQ;GAChB,OAAO,EAAQ;GACf,cAAc,EAAQ;GACtB,SAAS,EAAQ;GACjB,WAAW,EAAQ;GACnB,YAAY,EAAQ;EACtB,CAAC;CACL;AACF"}