@symmio/trading-react 0.1.0

package/dist/muon/use-muon-settle-upnl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-muon-settle-upnl.d.ts","sourceRoot":"","sources":["../../src/muon/use-muon-settle-upnl.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,2BAA2B,EAChC,KAAK,2BAA2B,EACjC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAe,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAIzE;;;GAGG;AACH,MAAM,MAAM,2BAA2B,GAAG,eAAe,CAAC;AAE1D,gDAAgD;AAChD,MAAM,MAAM,2BAA2B,GAAG,iBAAiB,CACzD,2BAA2B,EAC3B,kBAAkB,EAClB,2BAA2B,CAC5B,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,GAAE,2BAAgC,GAAG,2BAA2B,CAkB3G"}

package/dist/muon/use-muon-settle-upnl.js

@@ -0,0 +1,28 @@
+"use client";
+import { useSymmioChainId as e } from "../provider/use-symmio-chain-id.js";
+import { useSymmioConfig as t } from "../provider/use-symmio-config.js";
+import { normalizeSymmError as n } from "../errors/normalize-symm-error.js";
+import { getMuonSettleUpnl as r } from "@symmio/trading-core";
+import { useMutation as i } from "@tanstack/react-query";
+//#region src/muon/use-muon-settle-upnl.ts
+function a(a = {}) {
+	let o = t(a), s = e();
+	return i({
+		mutationKey: ["getMuonSettleUpnl"],
+		mutationFn: async (e) => {
+			try {
+				return await r(o, {
+					partyA: e.partyA,
+					quoteIds: e.quoteIds,
+					chainId: e.chainId ?? s
+				});
+			} catch (e) {
+				throw n(e);
+			}
+		}
+	});
+}
+//#endregion
+export { a as useMuonSettleUpnl };
+
+//# sourceMappingURL=use-muon-settle-upnl.js.map

package/dist/muon/use-muon-settle-upnl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-muon-settle-upnl.js","names":[],"sources":["../../src/muon/use-muon-settle-upnl.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getMuonSettleUpnl,\n  type ConfigParameter,\n  type GetMuonSettleUpnlParameters,\n  type GetMuonSettleUpnlReturnType,\n} from \"@symmio/trading-core\";\nimport { useMutation, type UseMutationResult } from \"@tanstack/react-query\";\nimport { normalizeSymmError } from \"../errors/normalize-symm-error\";\nimport type { SymmioRequestError } from \"../errors/symmio-request-error\";\nimport { useSymmioChainId } from \"../provider/use-symmio-chain-id\";\nimport { useSymmioConfig } from \"../provider/use-symmio-config\";\n\n/**\n * Parameters for {@link useMuonSettleUpnl}: an optional `config` override. The\n * partyA and quote ids are passed as the mutation `variables`.\n */\nexport type UseMuonSettleUpnlParameters = ConfigParameter;\n\n/** Return type of {@link useMuonSettleUpnl}. */\nexport type UseMuonSettleUpnlReturnType = UseMutationResult<\n  GetMuonSettleUpnlReturnType,\n  SymmioRequestError,\n  GetMuonSettleUpnlParameters\n>;\n\n/**\n * Fetch a fresh Muon `settle_upnl` attestation for a partyA over a set of quote\n * ids, on demand, normalized to typed fields (settlement uPnL, quote ids,\n * signature envelope).\n *\n * Modeled as a **mutation** rather than a query: Muon attestations are timestamped\n * and short-lived, so they are fetched on an explicit action, not eagerly on\n * mount. Call `mutateAsync({ partyA, quoteIds })`. `chainId` and the `symmio`\n * address are resolved from the connected chain's config. The settlement data\n * this produces is what `settleUpnl` requires.\n *\n * @example\n * ```tsx\n * const { mutateAsync } = useMuonSettleUpnl();\n * const s = await mutateAsync({ partyA: \"0xva…\", quoteIds: [10n, 11n] });\n * ```\n */\nexport function useMuonSettleUpnl(parameters: UseMuonSettleUpnlParameters = {}): UseMuonSettleUpnlReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n\n  return useMutation<GetMuonSettleUpnlReturnType, SymmioRequestError, GetMuonSettleUpnlParameters>({\n    mutationKey: [\"getMuonSettleUpnl\"],\n    mutationFn: async (variables) => {\n      try {\n        return await getMuonSettleUpnl(config, {\n          partyA: variables.partyA,\n          quoteIds: variables.quoteIds,\n          chainId: variables.chainId ?? chainId,\n        });\n      } catch (err) {\n        throw normalizeSymmError(err);\n      }\n    },\n  });\n}\n"],"mappings":";;;;;;;AA4CA,SAAgB,EAAkB,IAA0C,CAAC,GAAgC;CAC3G,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB;CAEjC,OAAO,EAA0F;EAC/F,aAAa,CAAC,mBAAmB;EACjC,YAAY,OAAO,MAAc;GAC/B,IAAI;IACF,OAAO,MAAM,EAAkB,GAAQ;KACrC,QAAQ,EAAU;KAClB,UAAU,EAAU;KACpB,SAAS,EAAU,WAAW;IAChC,CAAC;GACH,SAAS,GAAK;IACZ,MAAM,EAAmB,CAAG;GAC9B;EACF;CACF,CAAC;AACH"}

package/dist/muon/use-muon-upnl-a-with-symbol-price.d.ts

@@ -0,0 +1,29 @@
+import { ConfigParameter, GetMuonUpnlAWithSymbolPriceParameters, GetMuonUpnlAWithSymbolPriceReturnType } from '@symmio/trading-core';
+import { UseMutationResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error';
+/**
+ * Parameters for {@link useMuonUpnlAWithSymbolPrice}: an optional `config` override.
+ * The partyA and symbolId are passed as the mutation `variables`.
+ */
+export type UseMuonUpnlAWithSymbolPriceParameters = ConfigParameter;
+/** Return type of {@link useMuonUpnlAWithSymbolPrice}. */
+export type UseMuonUpnlAWithSymbolPriceReturnType = UseMutationResult<GetMuonUpnlAWithSymbolPriceReturnType, SymmioRequestError, GetMuonUpnlAWithSymbolPriceParameters>;
+/**
+ * Fetch a fresh Muon `uPnl_A_withSymbolPrice` attestation for a partyA and a single
+ * symbol, on demand, normalized to typed fields (uPnl, price, notional, quote/symbol
+ * ids, signature envelope).
+ *
+ * Modeled as a **mutation** rather than a query: Muon attestations are timestamped
+ * and short-lived, so they are fetched on an explicit action, not eagerly on
+ * mount. Call `mutateAsync({ partyA, symbolId })`. `chainId` and the `symmio`
+ * address are resolved from the connected chain's config. This attestation feeds
+ * the `sendQuoteWithAffiliate` flow.
+ *
+ * @example
+ * ```tsx
+ * const { mutateAsync } = useMuonUpnlAWithSymbolPrice();
+ * const a = await mutateAsync({ partyA: "0xva…", symbolId: 1n });
+ * ```
+ */
+export declare function useMuonUpnlAWithSymbolPrice(parameters?: UseMuonUpnlAWithSymbolPriceParameters): UseMuonUpnlAWithSymbolPriceReturnType;
+//# sourceMappingURL=use-muon-upnl-a-with-symbol-price.d.ts.map

package/dist/muon/use-muon-upnl-a-with-symbol-price.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-muon-upnl-a-with-symbol-price.d.ts","sourceRoot":"","sources":["../../src/muon/use-muon-upnl-a-with-symbol-price.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,qCAAqC,EAC1C,KAAK,qCAAqC,EAC3C,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAe,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAIzE;;;GAGG;AACH,MAAM,MAAM,qCAAqC,GAAG,eAAe,CAAC;AAEpE,0DAA0D;AAC1D,MAAM,MAAM,qCAAqC,GAAG,iBAAiB,CACnE,qCAAqC,EACrC,kBAAkB,EAClB,qCAAqC,CACtC,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,2BAA2B,CACzC,UAAU,GAAE,qCAA0C,GACrD,qCAAqC,CAkBvC"}

package/dist/muon/use-muon-upnl-a-with-symbol-price.js

@@ -0,0 +1,28 @@
+"use client";
+import { useSymmioChainId as e } from "../provider/use-symmio-chain-id.js";
+import { useSymmioConfig as t } from "../provider/use-symmio-config.js";
+import { normalizeSymmError as n } from "../errors/normalize-symm-error.js";
+import { getMuonUpnlAWithSymbolPrice as r } from "@symmio/trading-core";
+import { useMutation as i } from "@tanstack/react-query";
+//#region src/muon/use-muon-upnl-a-with-symbol-price.ts
+function a(a = {}) {
+	let o = t(a), s = e();
+	return i({
+		mutationKey: ["getMuonUpnlAWithSymbolPrice"],
+		mutationFn: async (e) => {
+			try {
+				return await r(o, {
+					partyA: e.partyA,
+					symbolId: e.symbolId,
+					chainId: e.chainId ?? s
+				});
+			} catch (e) {
+				throw n(e);
+			}
+		}
+	});
+}
+//#endregion
+export { a as useMuonUpnlAWithSymbolPrice };
+
+//# sourceMappingURL=use-muon-upnl-a-with-symbol-price.js.map

package/dist/muon/use-muon-upnl-a-with-symbol-price.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-muon-upnl-a-with-symbol-price.js","names":[],"sources":["../../src/muon/use-muon-upnl-a-with-symbol-price.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getMuonUpnlAWithSymbolPrice,\n  type ConfigParameter,\n  type GetMuonUpnlAWithSymbolPriceParameters,\n  type GetMuonUpnlAWithSymbolPriceReturnType,\n} from \"@symmio/trading-core\";\nimport { useMutation, type UseMutationResult } from \"@tanstack/react-query\";\nimport { normalizeSymmError } from \"../errors/normalize-symm-error\";\nimport type { SymmioRequestError } from \"../errors/symmio-request-error\";\nimport { useSymmioChainId } from \"../provider/use-symmio-chain-id\";\nimport { useSymmioConfig } from \"../provider/use-symmio-config\";\n\n/**\n * Parameters for {@link useMuonUpnlAWithSymbolPrice}: an optional `config` override.\n * The partyA and symbolId are passed as the mutation `variables`.\n */\nexport type UseMuonUpnlAWithSymbolPriceParameters = ConfigParameter;\n\n/** Return type of {@link useMuonUpnlAWithSymbolPrice}. */\nexport type UseMuonUpnlAWithSymbolPriceReturnType = UseMutationResult<\n  GetMuonUpnlAWithSymbolPriceReturnType,\n  SymmioRequestError,\n  GetMuonUpnlAWithSymbolPriceParameters\n>;\n\n/**\n * Fetch a fresh Muon `uPnl_A_withSymbolPrice` attestation for a partyA and a single\n * symbol, on demand, normalized to typed fields (uPnl, price, notional, quote/symbol\n * ids, signature envelope).\n *\n * Modeled as a **mutation** rather than a query: Muon attestations are timestamped\n * and short-lived, so they are fetched on an explicit action, not eagerly on\n * mount. Call `mutateAsync({ partyA, symbolId })`. `chainId` and the `symmio`\n * address are resolved from the connected chain's config. This attestation feeds\n * the `sendQuoteWithAffiliate` flow.\n *\n * @example\n * ```tsx\n * const { mutateAsync } = useMuonUpnlAWithSymbolPrice();\n * const a = await mutateAsync({ partyA: \"0xva…\", symbolId: 1n });\n * ```\n */\nexport function useMuonUpnlAWithSymbolPrice(\n  parameters: UseMuonUpnlAWithSymbolPriceParameters = {},\n): UseMuonUpnlAWithSymbolPriceReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n\n  return useMutation<GetMuonUpnlAWithSymbolPriceReturnType, SymmioRequestError, GetMuonUpnlAWithSymbolPriceParameters>({\n    mutationKey: [\"getMuonUpnlAWithSymbolPrice\"],\n    mutationFn: async (variables) => {\n      try {\n        return await getMuonUpnlAWithSymbolPrice(config, {\n          partyA: variables.partyA,\n          symbolId: variables.symbolId,\n          chainId: variables.chainId ?? chainId,\n        });\n      } catch (err) {\n        throw normalizeSymmError(err);\n      }\n    },\n  });\n}\n"],"mappings":";;;;;;;AA4CA,SAAgB,EACd,IAAoD,CAAC,GACd;CACvC,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB;CAEjC,OAAO,EAA8G;EACnH,aAAa,CAAC,6BAA6B;EAC3C,YAAY,OAAO,MAAc;GAC/B,IAAI;IACF,OAAO,MAAM,EAA4B,GAAQ;KAC/C,QAAQ,EAAU;KAClB,UAAU,EAAU;KACpB,SAAS,EAAU,WAAW;IAChC,CAAC;GACH,SAAS,GAAK;IACZ,MAAM,EAAmB,CAAG;GAC9B;EACF;CACF,CAAC;AACH"}

package/dist/muon/use-muon-upnl-a.d.ts

@@ -0,0 +1,28 @@
+import { ConfigParameter, GetMuonUpnlAParameters, GetMuonUpnlAReturnType } from '@symmio/trading-core';
+import { UseMutationResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error';
+/**
+ * Parameters for {@link useMuonUpnlA}: an optional `config` override. The partyA
+ * is passed as the mutation `variables`.
+ */
+export type UseMuonUpnlAParameters = ConfigParameter;
+/** Return type of {@link useMuonUpnlA}. */
+export type UseMuonUpnlAReturnType = UseMutationResult<GetMuonUpnlAReturnType, SymmioRequestError, GetMuonUpnlAParameters>;
+/**
+ * Fetch a fresh Muon `uPnl_A` attestation for a partyA, on demand, normalized to
+ * typed fields (uPnl, notional, quote/symbol ids, signature envelope).
+ *
+ * Modeled as a **mutation** rather than a query: Muon attestations are timestamped
+ * and short-lived, so they are fetched on an explicit action, not eagerly on
+ * mount. Call `mutateAsync({ partyA })`. `chainId` and the `symmio` address are
+ * resolved from the connected chain's config. For the contract-ready
+ * `SingleUpnlSig` that `removeMargin` needs, use {@link useDeallocateUpnlSig}.
+ *
+ * @example
+ * ```tsx
+ * const { mutateAsync } = useMuonUpnlA();
+ * const a = await mutateAsync({ partyA: "0xva…" });
+ * ```
+ */
+export declare function useMuonUpnlA(parameters?: UseMuonUpnlAParameters): UseMuonUpnlAReturnType;
+//# sourceMappingURL=use-muon-upnl-a.d.ts.map

package/dist/muon/use-muon-upnl-a.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-muon-upnl-a.d.ts","sourceRoot":"","sources":["../../src/muon/use-muon-upnl-a.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC5B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAe,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAIzE;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAAG,eAAe,CAAC;AAErD,2CAA2C;AAC3C,MAAM,MAAM,sBAAsB,GAAG,iBAAiB,CACpD,sBAAsB,EACtB,kBAAkB,EAClB,sBAAsB,CACvB,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,YAAY,CAAC,UAAU,GAAE,sBAA2B,GAAG,sBAAsB,CAiB5F"}

package/dist/muon/use-muon-upnl-a.js

@@ -0,0 +1,27 @@
+"use client";
+import { useSymmioChainId as e } from "../provider/use-symmio-chain-id.js";
+import { useSymmioConfig as t } from "../provider/use-symmio-config.js";
+import { normalizeSymmError as n } from "../errors/normalize-symm-error.js";
+import { getMuonUpnlA as r } from "@symmio/trading-core";
+import { useMutation as i } from "@tanstack/react-query";
+//#region src/muon/use-muon-upnl-a.ts
+function a(a = {}) {
+	let o = t(a), s = e();
+	return i({
+		mutationKey: ["getMuonUpnlA"],
+		mutationFn: async (e) => {
+			try {
+				return await r(o, {
+					partyA: e.partyA,
+					chainId: e.chainId ?? s
+				});
+			} catch (e) {
+				throw n(e);
+			}
+		}
+	});
+}
+//#endregion
+export { a as useMuonUpnlA };
+
+//# sourceMappingURL=use-muon-upnl-a.js.map

package/dist/muon/use-muon-upnl-a.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-muon-upnl-a.js","names":[],"sources":["../../src/muon/use-muon-upnl-a.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getMuonUpnlA,\n  type ConfigParameter,\n  type GetMuonUpnlAParameters,\n  type GetMuonUpnlAReturnType,\n} from \"@symmio/trading-core\";\nimport { useMutation, type UseMutationResult } from \"@tanstack/react-query\";\nimport { normalizeSymmError } from \"../errors/normalize-symm-error\";\nimport type { SymmioRequestError } from \"../errors/symmio-request-error\";\nimport { useSymmioChainId } from \"../provider/use-symmio-chain-id\";\nimport { useSymmioConfig } from \"../provider/use-symmio-config\";\n\n/**\n * Parameters for {@link useMuonUpnlA}: an optional `config` override. The partyA\n * is passed as the mutation `variables`.\n */\nexport type UseMuonUpnlAParameters = ConfigParameter;\n\n/** Return type of {@link useMuonUpnlA}. */\nexport type UseMuonUpnlAReturnType = UseMutationResult<\n  GetMuonUpnlAReturnType,\n  SymmioRequestError,\n  GetMuonUpnlAParameters\n>;\n\n/**\n * Fetch a fresh Muon `uPnl_A` attestation for a partyA, on demand, normalized to\n * typed fields (uPnl, notional, quote/symbol ids, signature envelope).\n *\n * Modeled as a **mutation** rather than a query: Muon attestations are timestamped\n * and short-lived, so they are fetched on an explicit action, not eagerly on\n * mount. Call `mutateAsync({ partyA })`. `chainId` and the `symmio` address are\n * resolved from the connected chain's config. For the contract-ready\n * `SingleUpnlSig` that `removeMargin` needs, use {@link useDeallocateUpnlSig}.\n *\n * @example\n * ```tsx\n * const { mutateAsync } = useMuonUpnlA();\n * const a = await mutateAsync({ partyA: \"0xva…\" });\n * ```\n */\nexport function useMuonUpnlA(parameters: UseMuonUpnlAParameters = {}): UseMuonUpnlAReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n\n  return useMutation<GetMuonUpnlAReturnType, SymmioRequestError, GetMuonUpnlAParameters>({\n    mutationKey: [\"getMuonUpnlA\"],\n    mutationFn: async (variables) => {\n      try {\n        return await getMuonUpnlA(config, {\n          partyA: variables.partyA,\n          chainId: variables.chainId ?? chainId,\n        });\n      } catch (err) {\n        throw normalizeSymmError(err);\n      }\n    },\n  });\n}\n"],"mappings":";;;;;;;AA2CA,SAAgB,EAAa,IAAqC,CAAC,GAA2B;CAC5F,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB;CAEjC,OAAO,EAAgF;EACrF,aAAa,CAAC,cAAc;EAC5B,YAAY,OAAO,MAAc;GAC/B,IAAI;IACF,OAAO,MAAM,EAAa,GAAQ;KAChC,QAAQ,EAAU;KAClB,SAAS,EAAU,WAAW;IAChC,CAAC;GACH,SAAS,GAAK;IACZ,MAAM,EAAmB,CAAG;GAC9B;EACF;CACF,CAAC;AACH"}

package/dist/muon/use-muon-upnl-b.d.ts

@@ -0,0 +1,29 @@
+import { ConfigParameter, GetMuonUpnlBParameters, GetMuonUpnlBReturnType } from '@symmio/trading-core';
+import { UseMutationResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error';
+/**
+ * Parameters for {@link useMuonUpnlB}: an optional `config` override. The partyB
+ * and partyA are passed as the mutation `variables`.
+ */
+export type UseMuonUpnlBParameters = ConfigParameter;
+/** Return type of {@link useMuonUpnlB}. */
+export type UseMuonUpnlBReturnType = UseMutationResult<GetMuonUpnlBReturnType, SymmioRequestError, GetMuonUpnlBParameters>;
+/**
+ * Fetch a fresh Muon `uPnl_B` attestation for a partyB against a partyA, on
+ * demand, normalized to typed fields (uPnl, notional, quote ids, signature
+ * envelope).
+ *
+ * Modeled as a **mutation** rather than a query: Muon attestations are timestamped
+ * and short-lived, so they are fetched on an explicit action, not eagerly on
+ * mount. Call `mutateAsync({ partyB, partyA })`. `chainId` and the `symmio`
+ * address are resolved from the connected chain's config. A partyB's uPnL against
+ * a partyA is used in `lockQuote` solvency validation.
+ *
+ * @example
+ * ```tsx
+ * const { mutateAsync } = useMuonUpnlB();
+ * const b = await mutateAsync({ partyB: "0xpb…", partyA: "0xva…" });
+ * ```
+ */
+export declare function useMuonUpnlB(parameters?: UseMuonUpnlBParameters): UseMuonUpnlBReturnType;
+//# sourceMappingURL=use-muon-upnl-b.d.ts.map

package/dist/muon/use-muon-upnl-b.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-muon-upnl-b.d.ts","sourceRoot":"","sources":["../../src/muon/use-muon-upnl-b.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC5B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAe,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAIzE;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAAG,eAAe,CAAC;AAErD,2CAA2C;AAC3C,MAAM,MAAM,sBAAsB,GAAG,iBAAiB,CACpD,sBAAsB,EACtB,kBAAkB,EAClB,sBAAsB,CACvB,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,YAAY,CAAC,UAAU,GAAE,sBAA2B,GAAG,sBAAsB,CAkB5F"}

package/dist/muon/use-muon-upnl-b.js

@@ -0,0 +1,28 @@
+"use client";
+import { useSymmioChainId as e } from "../provider/use-symmio-chain-id.js";
+import { useSymmioConfig as t } from "../provider/use-symmio-config.js";
+import { normalizeSymmError as n } from "../errors/normalize-symm-error.js";
+import { getMuonUpnlB as r } from "@symmio/trading-core";
+import { useMutation as i } from "@tanstack/react-query";
+//#region src/muon/use-muon-upnl-b.ts
+function a(a = {}) {
+	let o = t(a), s = e();
+	return i({
+		mutationKey: ["getMuonUpnlB"],
+		mutationFn: async (e) => {
+			try {
+				return await r(o, {
+					partyB: e.partyB,
+					partyA: e.partyA,
+					chainId: e.chainId ?? s
+				});
+			} catch (e) {
+				throw n(e);
+			}
+		}
+	});
+}
+//#endregion
+export { a as useMuonUpnlB };
+
+//# sourceMappingURL=use-muon-upnl-b.js.map

package/dist/muon/use-muon-upnl-b.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-muon-upnl-b.js","names":[],"sources":["../../src/muon/use-muon-upnl-b.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getMuonUpnlB,\n  type ConfigParameter,\n  type GetMuonUpnlBParameters,\n  type GetMuonUpnlBReturnType,\n} from \"@symmio/trading-core\";\nimport { useMutation, type UseMutationResult } from \"@tanstack/react-query\";\nimport { normalizeSymmError } from \"../errors/normalize-symm-error\";\nimport type { SymmioRequestError } from \"../errors/symmio-request-error\";\nimport { useSymmioChainId } from \"../provider/use-symmio-chain-id\";\nimport { useSymmioConfig } from \"../provider/use-symmio-config\";\n\n/**\n * Parameters for {@link useMuonUpnlB}: an optional `config` override. The partyB\n * and partyA are passed as the mutation `variables`.\n */\nexport type UseMuonUpnlBParameters = ConfigParameter;\n\n/** Return type of {@link useMuonUpnlB}. */\nexport type UseMuonUpnlBReturnType = UseMutationResult<\n  GetMuonUpnlBReturnType,\n  SymmioRequestError,\n  GetMuonUpnlBParameters\n>;\n\n/**\n * Fetch a fresh Muon `uPnl_B` attestation for a partyB against a partyA, on\n * demand, normalized to typed fields (uPnl, notional, quote ids, signature\n * envelope).\n *\n * Modeled as a **mutation** rather than a query: Muon attestations are timestamped\n * and short-lived, so they are fetched on an explicit action, not eagerly on\n * mount. Call `mutateAsync({ partyB, partyA })`. `chainId` and the `symmio`\n * address are resolved from the connected chain's config. A partyB's uPnL against\n * a partyA is used in `lockQuote` solvency validation.\n *\n * @example\n * ```tsx\n * const { mutateAsync } = useMuonUpnlB();\n * const b = await mutateAsync({ partyB: \"0xpb…\", partyA: \"0xva…\" });\n * ```\n */\nexport function useMuonUpnlB(parameters: UseMuonUpnlBParameters = {}): UseMuonUpnlBReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n\n  return useMutation<GetMuonUpnlBReturnType, SymmioRequestError, GetMuonUpnlBParameters>({\n    mutationKey: [\"getMuonUpnlB\"],\n    mutationFn: async (variables) => {\n      try {\n        return await getMuonUpnlB(config, {\n          partyB: variables.partyB,\n          partyA: variables.partyA,\n          chainId: variables.chainId ?? chainId,\n        });\n      } catch (err) {\n        throw normalizeSymmError(err);\n      }\n    },\n  });\n}\n"],"mappings":";;;;;;;AA4CA,SAAgB,EAAa,IAAqC,CAAC,GAA2B;CAC5F,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB;CAEjC,OAAO,EAAgF;EACrF,aAAa,CAAC,cAAc;EAC5B,YAAY,OAAO,MAAc;GAC/B,IAAI;IACF,OAAO,MAAM,EAAa,GAAQ;KAChC,QAAQ,EAAU;KAClB,QAAQ,EAAU;KAClB,SAAS,EAAU,WAAW;IAChC,CAAC;GACH,SAAS,GAAK;IACZ,MAAM,EAAmB,CAAG;GAC9B;EACF;CACF,CAAC;AACH"}

package/dist/muon/use-muon-upnl-with-symbol-price.d.ts

@@ -0,0 +1,28 @@
+import { ConfigParameter, GetMuonUpnlWithSymbolPriceParameters, GetMuonUpnlWithSymbolPriceReturnType } from '@symmio/trading-core';
+import { UseMutationResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error';
+/**
+ * Parameters for {@link useMuonUpnlWithSymbolPrice}: an optional `config` override.
+ * The partyB, partyA, and symbolId are passed as the mutation `variables`.
+ */
+export type UseMuonUpnlWithSymbolPriceParameters = ConfigParameter;
+/** Return type of {@link useMuonUpnlWithSymbolPrice}. */
+export type UseMuonUpnlWithSymbolPriceReturnType = UseMutationResult<GetMuonUpnlWithSymbolPriceReturnType, SymmioRequestError, GetMuonUpnlWithSymbolPriceParameters>;
+/**
+ * Fetch a fresh Muon `uPnlWithSymbolPrice` attestation for a partyB/partyA pair
+ * and a symbol id, on demand, normalized to typed fields (price, both parties'
+ * uPnL, quote ids, signature envelope).
+ *
+ * Modeled as a **mutation** rather than a query: Muon attestations are timestamped
+ * and short-lived, so they are fetched on an explicit action, not eagerly on
+ * mount. Call `mutateAsync({ partyB, partyA, symbolId })`. `chainId` and the
+ * `symmio` address are resolved from the connected chain's config.
+ *
+ * @example
+ * ```tsx
+ * const { mutateAsync } = useMuonUpnlWithSymbolPrice();
+ * const a = await mutateAsync({ partyB: "0xsolver…", partyA: "0xva…", symbolId: 1n });
+ * ```
+ */
+export declare function useMuonUpnlWithSymbolPrice(parameters?: UseMuonUpnlWithSymbolPriceParameters): UseMuonUpnlWithSymbolPriceReturnType;
+//# sourceMappingURL=use-muon-upnl-with-symbol-price.d.ts.map

package/dist/muon/use-muon-upnl-with-symbol-price.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-muon-upnl-with-symbol-price.d.ts","sourceRoot":"","sources":["../../src/muon/use-muon-upnl-with-symbol-price.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,oCAAoC,EACzC,KAAK,oCAAoC,EAC1C,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAe,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAIzE;;;GAGG;AACH,MAAM,MAAM,oCAAoC,GAAG,eAAe,CAAC;AAEnE,yDAAyD;AACzD,MAAM,MAAM,oCAAoC,GAAG,iBAAiB,CAClE,oCAAoC,EACpC,kBAAkB,EAClB,oCAAoC,CACrC,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,0BAA0B,CACxC,UAAU,GAAE,oCAAyC,GACpD,oCAAoC,CAmBtC"}

package/dist/muon/use-muon-upnl-with-symbol-price.js

@@ -0,0 +1,29 @@
+"use client";
+import { useSymmioChainId as e } from "../provider/use-symmio-chain-id.js";
+import { useSymmioConfig as t } from "../provider/use-symmio-config.js";
+import { normalizeSymmError as n } from "../errors/normalize-symm-error.js";
+import { getMuonUpnlWithSymbolPrice as r } from "@symmio/trading-core";
+import { useMutation as i } from "@tanstack/react-query";
+//#region src/muon/use-muon-upnl-with-symbol-price.ts
+function a(a = {}) {
+	let o = t(a), s = e();
+	return i({
+		mutationKey: ["getMuonUpnlWithSymbolPrice"],
+		mutationFn: async (e) => {
+			try {
+				return await r(o, {
+					partyB: e.partyB,
+					partyA: e.partyA,
+					symbolId: e.symbolId,
+					chainId: e.chainId ?? s
+				});
+			} catch (e) {
+				throw n(e);
+			}
+		}
+	});
+}
+//#endregion
+export { a as useMuonUpnlWithSymbolPrice };
+
+//# sourceMappingURL=use-muon-upnl-with-symbol-price.js.map

package/dist/muon/use-muon-upnl-with-symbol-price.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-muon-upnl-with-symbol-price.js","names":[],"sources":["../../src/muon/use-muon-upnl-with-symbol-price.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getMuonUpnlWithSymbolPrice,\n  type ConfigParameter,\n  type GetMuonUpnlWithSymbolPriceParameters,\n  type GetMuonUpnlWithSymbolPriceReturnType,\n} from \"@symmio/trading-core\";\nimport { useMutation, type UseMutationResult } from \"@tanstack/react-query\";\nimport { normalizeSymmError } from \"../errors/normalize-symm-error\";\nimport type { SymmioRequestError } from \"../errors/symmio-request-error\";\nimport { useSymmioChainId } from \"../provider/use-symmio-chain-id\";\nimport { useSymmioConfig } from \"../provider/use-symmio-config\";\n\n/**\n * Parameters for {@link useMuonUpnlWithSymbolPrice}: an optional `config` override.\n * The partyB, partyA, and symbolId are passed as the mutation `variables`.\n */\nexport type UseMuonUpnlWithSymbolPriceParameters = ConfigParameter;\n\n/** Return type of {@link useMuonUpnlWithSymbolPrice}. */\nexport type UseMuonUpnlWithSymbolPriceReturnType = UseMutationResult<\n  GetMuonUpnlWithSymbolPriceReturnType,\n  SymmioRequestError,\n  GetMuonUpnlWithSymbolPriceParameters\n>;\n\n/**\n * Fetch a fresh Muon `uPnlWithSymbolPrice` attestation for a partyB/partyA pair\n * and a symbol id, on demand, normalized to typed fields (price, both parties'\n * uPnL, quote ids, signature envelope).\n *\n * Modeled as a **mutation** rather than a query: Muon attestations are timestamped\n * and short-lived, so they are fetched on an explicit action, not eagerly on\n * mount. Call `mutateAsync({ partyB, partyA, symbolId })`. `chainId` and the\n * `symmio` address are resolved from the connected chain's config.\n *\n * @example\n * ```tsx\n * const { mutateAsync } = useMuonUpnlWithSymbolPrice();\n * const a = await mutateAsync({ partyB: \"0xsolver…\", partyA: \"0xva…\", symbolId: 1n });\n * ```\n */\nexport function useMuonUpnlWithSymbolPrice(\n  parameters: UseMuonUpnlWithSymbolPriceParameters = {},\n): UseMuonUpnlWithSymbolPriceReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n\n  return useMutation<GetMuonUpnlWithSymbolPriceReturnType, SymmioRequestError, GetMuonUpnlWithSymbolPriceParameters>({\n    mutationKey: [\"getMuonUpnlWithSymbolPrice\"],\n    mutationFn: async (variables) => {\n      try {\n        return await getMuonUpnlWithSymbolPrice(config, {\n          partyB: variables.partyB,\n          partyA: variables.partyA,\n          symbolId: variables.symbolId,\n          chainId: variables.chainId ?? chainId,\n        });\n      } catch (err) {\n        throw normalizeSymmError(err);\n      }\n    },\n  });\n}\n"],"mappings":";;;;;;;AA2CA,SAAgB,EACd,IAAmD,CAAC,GACd;CACtC,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB;CAEjC,OAAO,EAA4G;EACjH,aAAa,CAAC,4BAA4B;EAC1C,YAAY,OAAO,MAAc;GAC/B,IAAI;IACF,OAAO,MAAM,EAA2B,GAAQ;KAC9C,QAAQ,EAAU;KAClB,QAAQ,EAAU;KAClB,UAAU,EAAU;KACpB,SAAS,EAAU,WAAW;IAChC,CAAC;GACH,SAAS,GAAK;IACZ,MAAM,EAAmB,CAAG;GAC9B;EACF;CACF,CAAC;AACH"}

package/dist/muon/use-muon-upnl.d.ts

@@ -0,0 +1,28 @@
+import { ConfigParameter, GetMuonUpnlParameters, GetMuonUpnlReturnType } from '@symmio/trading-core';
+import { UseMutationResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error';
+/**
+ * Parameters for {@link useMuonUpnl}: an optional `config` override. The partyB
+ * and partyA are passed as the mutation `variables`.
+ */
+export type UseMuonUpnlParameters = ConfigParameter;
+/** Return type of {@link useMuonUpnl}. */
+export type UseMuonUpnlReturnType = UseMutationResult<GetMuonUpnlReturnType, SymmioRequestError, GetMuonUpnlParameters>;
+/**
+ * Fetch a fresh Muon `uPnl` attestation for a partyB / partyA pair, on demand,
+ * normalized to typed fields (combined uPnL with a per-party breakdown plus the
+ * signature envelope).
+ *
+ * Modeled as a **mutation** rather than a query: Muon attestations are timestamped
+ * and short-lived, so they are fetched on an explicit action, not eagerly on
+ * mount. Call `mutateAsync({ partyB, partyA })`. `chainId` and the `symmio`
+ * address are resolved from the connected chain's config.
+ *
+ * @example
+ * ```tsx
+ * const { mutateAsync } = useMuonUpnl();
+ * const a = await mutateAsync({ partyB: "0xb…", partyA: "0xva…" });
+ * ```
+ */
+export declare function useMuonUpnl(parameters?: UseMuonUpnlParameters): UseMuonUpnlReturnType;
+//# sourceMappingURL=use-muon-upnl.d.ts.map

package/dist/muon/use-muon-upnl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-muon-upnl.d.ts","sourceRoot":"","sources":["../../src/muon/use-muon-upnl.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC3B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAe,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAIzE;;;GAGG;AACH,MAAM,MAAM,qBAAqB,GAAG,eAAe,CAAC;AAEpD,0CAA0C;AAC1C,MAAM,MAAM,qBAAqB,GAAG,iBAAiB,CAAC,qBAAqB,EAAE,kBAAkB,EAAE,qBAAqB,CAAC,CAAC;AAExH;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,UAAU,GAAE,qBAA0B,GAAG,qBAAqB,CAkBzF"}

package/dist/muon/use-muon-upnl.js

@@ -0,0 +1,28 @@
+"use client";
+import { useSymmioChainId as e } from "../provider/use-symmio-chain-id.js";
+import { useSymmioConfig as t } from "../provider/use-symmio-config.js";
+import { normalizeSymmError as n } from "../errors/normalize-symm-error.js";
+import { getMuonUpnl as r } from "@symmio/trading-core";
+import { useMutation as i } from "@tanstack/react-query";
+//#region src/muon/use-muon-upnl.ts
+function a(a = {}) {
+	let o = t(a), s = e();
+	return i({
+		mutationKey: ["getMuonUpnl"],
+		mutationFn: async (e) => {
+			try {
+				return await r(o, {
+					partyB: e.partyB,
+					partyA: e.partyA,
+					chainId: e.chainId ?? s
+				});
+			} catch (e) {
+				throw n(e);
+			}
+		}
+	});
+}
+//#endregion
+export { a as useMuonUpnl };
+
+//# sourceMappingURL=use-muon-upnl.js.map

package/dist/muon/use-muon-upnl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-muon-upnl.js","names":[],"sources":["../../src/muon/use-muon-upnl.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getMuonUpnl,\n  type ConfigParameter,\n  type GetMuonUpnlParameters,\n  type GetMuonUpnlReturnType,\n} from \"@symmio/trading-core\";\nimport { useMutation, type UseMutationResult } from \"@tanstack/react-query\";\nimport { normalizeSymmError } from \"../errors/normalize-symm-error\";\nimport type { SymmioRequestError } from \"../errors/symmio-request-error\";\nimport { useSymmioChainId } from \"../provider/use-symmio-chain-id\";\nimport { useSymmioConfig } from \"../provider/use-symmio-config\";\n\n/**\n * Parameters for {@link useMuonUpnl}: an optional `config` override. The partyB\n * and partyA are passed as the mutation `variables`.\n */\nexport type UseMuonUpnlParameters = ConfigParameter;\n\n/** Return type of {@link useMuonUpnl}. */\nexport type UseMuonUpnlReturnType = UseMutationResult<GetMuonUpnlReturnType, SymmioRequestError, GetMuonUpnlParameters>;\n\n/**\n * Fetch a fresh Muon `uPnl` attestation for a partyB / partyA pair, on demand,\n * normalized to typed fields (combined uPnL with a per-party breakdown plus the\n * signature envelope).\n *\n * Modeled as a **mutation** rather than a query: Muon attestations are timestamped\n * and short-lived, so they are fetched on an explicit action, not eagerly on\n * mount. Call `mutateAsync({ partyB, partyA })`. `chainId` and the `symmio`\n * address are resolved from the connected chain's config.\n *\n * @example\n * ```tsx\n * const { mutateAsync } = useMuonUpnl();\n * const a = await mutateAsync({ partyB: \"0xb…\", partyA: \"0xva…\" });\n * ```\n */\nexport function useMuonUpnl(parameters: UseMuonUpnlParameters = {}): UseMuonUpnlReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n\n  return useMutation<GetMuonUpnlReturnType, SymmioRequestError, GetMuonUpnlParameters>({\n    mutationKey: [\"getMuonUpnl\"],\n    mutationFn: async (variables) => {\n      try {\n        return await getMuonUpnl(config, {\n          partyB: variables.partyB,\n          partyA: variables.partyA,\n          chainId: variables.chainId ?? chainId,\n        });\n      } catch (err) {\n        throw normalizeSymmError(err);\n      }\n    },\n  });\n}\n"],"mappings":";;;;;;;AAuCA,SAAgB,EAAY,IAAoC,CAAC,GAA0B;CACzF,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB;CAEjC,OAAO,EAA8E;EACnF,aAAa,CAAC,aAAa;EAC3B,YAAY,OAAO,MAAc;GAC/B,IAAI;IACF,OAAO,MAAM,EAAY,GAAQ;KAC/B,QAAQ,EAAU;KAClB,QAAQ,EAAU;KAClB,SAAS,EAAU,WAAW;IAChC,CAAC;GACH,SAAS,GAAK;IACZ,MAAM,EAAmB,CAAG;GAC9B;EACF;CACF,CAAC;AACH"}

package/dist/notifications/index.d.ts

@@ -0,0 +1,2 @@
+export { useSearchNotifications, type UseSearchNotificationsParameters, type UseSearchNotificationsReturnType, } from './use-search-notifications';
+//# sourceMappingURL=index.d.ts.map

package/dist/notifications/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/notifications/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,KAAK,gCAAgC,EACrC,KAAK,gCAAgC,GACtC,MAAM,4BAA4B,CAAC"}

package/dist/notifications/use-search-notifications.d.ts

@@ -0,0 +1,29 @@
+import { ConfigParameter, SearchNotificationsOptions, SearchNotificationsReturnType } from '@symmio/trading-core';
+import { UseQueryResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error';
+/**
+ * Parameters for {@link useSearchNotifications}: the core search options
+ * (`filter`, `size`, `start`, chain id, TanStack `query` overrides) plus an
+ * optional `config`.
+ */
+export type UseSearchNotificationsParameters = SearchNotificationsOptions & ConfigParameter;
+/** Return type of {@link useSearchNotifications}. */
+export type UseSearchNotificationsReturnType = UseQueryResult<SearchNotificationsReturnType, SymmioRequestError>;
+/**
+ * Search stored notifications via the notification service's free-form
+ * `POST /api/v1/search` endpoint. The `filter` matches keys exactly — top-level
+ * fields (`app_name`, …) or dotted payload paths (`data.temp_quote_id`, …).
+ *
+ * The query is disabled until `filter` has at least one key. `chainId` defaults
+ * to the connected chain. Errors are normalized to {@link SymmioRequestError}.
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useSearchNotifications({
+ *   filter: { app_name: "Base_Superflow_Stage", "data.temp_quote_id": -172 },
+ * });
+ * data?.documents.forEach((d) => console.log(d.id));
+ * ```
+ */
+export declare function useSearchNotifications(parameters: UseSearchNotificationsParameters): UseSearchNotificationsReturnType;
+//# sourceMappingURL=use-search-notifications.d.ts.map

package/dist/notifications/use-search-notifications.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-search-notifications.d.ts","sourceRoot":"","sources":["../../src/notifications/use-search-notifications.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,0BAA0B,EAC/B,KAAK,6BAA6B,EACnC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAIzE;;;;GAIG;AACH,MAAM,MAAM,gCAAgC,GAAG,0BAA0B,GAAG,eAAe,CAAC;AAE5F,qDAAqD;AACrD,MAAM,MAAM,gCAAgC,GAAG,cAAc,CAAC,6BAA6B,EAAE,kBAAkB,CAAC,CAAC;AAEjH;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,gCAAgC,GAAG,gCAAgC,CAkBrH"}

package/dist/notifications/use-search-notifications.js

@@ -0,0 +1,27 @@
+"use client";
+import { useSymmioChainId as e } from "../provider/use-symmio-chain-id.js";
+import { useSymmioConfig as t } from "../provider/use-symmio-config.js";
+import { normalizeSymmError as n } from "../errors/normalize-symm-error.js";
+import { searchNotificationsQueryOptions as r } from "@symmio/trading-core";
+import { useQuery as i } from "@tanstack/react-query";
+//#region src/notifications/use-search-notifications.ts
+function a(a) {
+	let o = t(a), s = e(), c = r(o, {
+		...a,
+		chainId: a.chainId ?? s
+	});
+	return i({
+		...c,
+		queryFn: async () => {
+			try {
+				return await c.queryFn();
+			} catch (e) {
+				throw n(e);
+			}
+		}
+	});
+}
+//#endregion
+export { a as useSearchNotifications };
+
+//# sourceMappingURL=use-search-notifications.js.map

package/dist/notifications/use-search-notifications.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-search-notifications.js","names":[],"sources":["../../src/notifications/use-search-notifications.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  searchNotificationsQueryOptions,\n  type ConfigParameter,\n  type SearchNotificationsOptions,\n  type SearchNotificationsReturnType,\n} from \"@symmio/trading-core\";\nimport { useQuery, type UseQueryResult } from \"@tanstack/react-query\";\nimport { normalizeSymmError } from \"../errors/normalize-symm-error\";\nimport type { SymmioRequestError } from \"../errors/symmio-request-error\";\nimport { useSymmioChainId } from \"../provider/use-symmio-chain-id\";\nimport { useSymmioConfig } from \"../provider/use-symmio-config\";\n\n/**\n * Parameters for {@link useSearchNotifications}: the core search options\n * (`filter`, `size`, `start`, chain id, TanStack `query` overrides) plus an\n * optional `config`.\n */\nexport type UseSearchNotificationsParameters = SearchNotificationsOptions & ConfigParameter;\n\n/** Return type of {@link useSearchNotifications}. */\nexport type UseSearchNotificationsReturnType = UseQueryResult<SearchNotificationsReturnType, SymmioRequestError>;\n\n/**\n * Search stored notifications via the notification service's free-form\n * `POST /api/v1/search` endpoint. The `filter` matches keys exactly — top-level\n * fields (`app_name`, …) or dotted payload paths (`data.temp_quote_id`, …).\n *\n * The query is disabled until `filter` has at least one key. `chainId` defaults\n * to the connected chain. Errors are normalized to {@link SymmioRequestError}.\n *\n * @example\n * ```tsx\n * const { data, isLoading } = useSearchNotifications({\n *   filter: { app_name: \"Base_Superflow_Stage\", \"data.temp_quote_id\": -172 },\n * });\n * data?.documents.forEach((d) => console.log(d.id));\n * ```\n */\nexport function useSearchNotifications(parameters: UseSearchNotificationsParameters): UseSearchNotificationsReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n  const options = searchNotificationsQueryOptions(config, {\n    ...parameters,\n    chainId: parameters.chainId ?? chainId,\n  });\n\n  return useQuery({\n    ...options,\n    queryFn: async () => {\n      try {\n        return await options.queryFn();\n      } catch (err) {\n        throw normalizeSymmError(err);\n      }\n    },\n  }) as UseSearchNotificationsReturnType;\n}\n"],"mappings":";;;;;;;AAwCA,SAAgB,EAAuB,GAAgF;CACrH,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB,GAC3B,IAAU,EAAgC,GAAQ;EACtD,GAAG;EACH,SAAS,EAAW,WAAW;CACjC,CAAC;CAED,OAAO,EAAS;EACd,GAAG;EACH,SAAS,YAAY;GACnB,IAAI;IACF,OAAO,MAAM,EAAQ,QAAQ;GAC/B,SAAS,GAAK;IACZ,MAAM,EAAmB,CAAG;GAC9B;EACF;CACF,CAAC;AACH"}

package/dist/notional-cap/index.d.ts

@@ -0,0 +1,4 @@
+export * from './use-notional-cap-all';
+export * from './use-notional-cap-by-symbol-id';
+export * from './use-open-interest-by-symbol-id';
+//# sourceMappingURL=index.d.ts.map

package/dist/notional-cap/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/notional-cap/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,iCAAiC,CAAC;AAChD,cAAc,kCAAkC,CAAC"}

package/dist/notional-cap/use-notional-cap-all.d.ts

@@ -0,0 +1,32 @@
+import { ConfigParameter, GetNotionalCapAllOptions, GetNotionalCapAllReturnType } from '@symmio/trading-core';
+import { UseQueryResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error';
+/**
+ * Parameters for {@link useNotionalCapAll}: the core query options plus an
+ * optional `config` and a `pollingInterval` knob layered on top of
+ * `query.refetchInterval`.
+ */
+export type UseNotionalCapAllParameters = GetNotionalCapAllOptions & ConfigParameter & {
+    /**
+     * Polling cadence in milliseconds. Defaults to
+     * {@link DEFAULT_NOTIONAL_CAP_POLLING_MS}. Pass `false` to disable polling.
+     */
+    pollingInterval?: number | false;
+};
+/** Return type of {@link useNotionalCapAll}. */
+export type UseNotionalCapAllReturnType = UseQueryResult<GetNotionalCapAllReturnType, SymmioRequestError>;
+/**
+ * Read every market's notional cap in one solver call. Surfaces the aggregate
+ * `totalOpenInterest` / `totalUsed` plus the per-symbol rows.
+ *
+ * Polls every {@link DEFAULT_NOTIONAL_CAP_POLLING_MS} by default; pass
+ * `pollingInterval` to change or disable.
+ *
+ * @example
+ * ```tsx
+ * const { data } = useNotionalCapAll();
+ * console.log(data?.totalOpenInterest, data?.symbols.length);
+ * ```
+ */
+export declare function useNotionalCapAll(parameters?: UseNotionalCapAllParameters): UseNotionalCapAllReturnType;
+//# sourceMappingURL=use-notional-cap-all.d.ts.map

package/dist/notional-cap/use-notional-cap-all.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-notional-cap-all.d.ts","sourceRoot":"","sources":["../../src/notional-cap/use-notional-cap-all.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,wBAAwB,EAC7B,KAAK,2BAA2B,EACjC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAKzE;;;;GAIG;AACH,MAAM,MAAM,2BAA2B,GAAG,wBAAwB,GAChE,eAAe,GAAG;IAChB;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;CAClC,CAAC;AAEJ,gDAAgD;AAChD,MAAM,MAAM,2BAA2B,GAAG,cAAc,CAAC,2BAA2B,EAAE,kBAAkB,CAAC,CAAC;AAE1G;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,GAAE,2BAAgC,GAAG,2BAA2B,CAuB3G"}

package/dist/notional-cap/use-notional-cap-all.js

@@ -0,0 +1,32 @@
+"use client";
+import { useSymmioChainId as e } from "../provider/use-symmio-chain-id.js";
+import { useSymmioConfig as t } from "../provider/use-symmio-config.js";
+import { normalizeSymmError as n } from "../errors/normalize-symm-error.js";
+import { DEFAULT_NOTIONAL_CAP_POLLING_MS as r } from "./use-notional-cap-by-symbol-id.js";
+import { getNotionalCapAllQueryOptions as i } from "@symmio/trading-core";
+import { useQuery as a } from "@tanstack/react-query";
+//#region src/notional-cap/use-notional-cap-all.ts
+function o(o = {}) {
+	let { pollingInterval: s = r, query: c, ...l } = o, u = t(o), d = e(), f = i(u, {
+		...l,
+		chainId: l.chainId ?? d,
+		query: {
+			refetchInterval: s === !1 ? !1 : s,
+			...c
+		}
+	});
+	return a({
+		...f,
+		queryFn: async () => {
+			try {
+				return await f.queryFn();
+			} catch (e) {
+				throw n(e);
+			}
+		}
+	});
+}
+//#endregion
+export { o as useNotionalCapAll };
+
+//# sourceMappingURL=use-notional-cap-all.js.map

package/dist/notional-cap/use-notional-cap-all.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-notional-cap-all.js","names":[],"sources":["../../src/notional-cap/use-notional-cap-all.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getNotionalCapAllQueryOptions,\n  type ConfigParameter,\n  type GetNotionalCapAllOptions,\n  type GetNotionalCapAllReturnType,\n} from \"@symmio/trading-core\";\nimport { useQuery, type UseQueryResult } from \"@tanstack/react-query\";\nimport { normalizeSymmError } from \"../errors/normalize-symm-error\";\nimport type { SymmioRequestError } from \"../errors/symmio-request-error\";\nimport { useSymmioChainId } from \"../provider/use-symmio-chain-id\";\nimport { useSymmioConfig } from \"../provider/use-symmio-config\";\nimport { DEFAULT_NOTIONAL_CAP_POLLING_MS } from \"./use-notional-cap-by-symbol-id\";\n\n/**\n * Parameters for {@link useNotionalCapAll}: the core query options plus an\n * optional `config` and a `pollingInterval` knob layered on top of\n * `query.refetchInterval`.\n */\nexport type UseNotionalCapAllParameters = GetNotionalCapAllOptions &\n  ConfigParameter & {\n    /**\n     * Polling cadence in milliseconds. Defaults to\n     * {@link DEFAULT_NOTIONAL_CAP_POLLING_MS}. Pass `false` to disable polling.\n     */\n    pollingInterval?: number | false;\n  };\n\n/** Return type of {@link useNotionalCapAll}. */\nexport type UseNotionalCapAllReturnType = UseQueryResult<GetNotionalCapAllReturnType, SymmioRequestError>;\n\n/**\n * Read every market's notional cap in one solver call. Surfaces the aggregate\n * `totalOpenInterest` / `totalUsed` plus the per-symbol rows.\n *\n * Polls every {@link DEFAULT_NOTIONAL_CAP_POLLING_MS} by default; pass\n * `pollingInterval` to change or disable.\n *\n * @example\n * ```tsx\n * const { data } = useNotionalCapAll();\n * console.log(data?.totalOpenInterest, data?.symbols.length);\n * ```\n */\nexport function useNotionalCapAll(parameters: UseNotionalCapAllParameters = {}): UseNotionalCapAllReturnType {\n  const { pollingInterval = DEFAULT_NOTIONAL_CAP_POLLING_MS, query, ...rest } = parameters;\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n  const options = getNotionalCapAllQueryOptions(config, {\n    ...rest,\n    chainId: rest.chainId ?? chainId,\n    query: {\n      refetchInterval: pollingInterval === false ? false : pollingInterval,\n      ...query,\n    },\n  });\n\n  return useQuery({\n    ...options,\n    queryFn: async () => {\n      try {\n        return await options.queryFn();\n      } catch (err) {\n        throw normalizeSymmError(err);\n      }\n    },\n  }) as UseNotionalCapAllReturnType;\n}\n"],"mappings":";;;;;;;;AA6CA,SAAgB,EAAkB,IAA0C,CAAC,GAAgC;CAC3G,IAAM,EAAE,qBAAkB,GAAiC,UAAO,GAAG,MAAS,GACxE,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB,GAC3B,IAAU,EAA8B,GAAQ;EACpD,GAAG;EACH,SAAS,EAAK,WAAW;EACzB,OAAO;GACL,iBAAiB,MAAoB,KAAQ,KAAQ;GACrD,GAAG;EACL;CACF,CAAC;CAED,OAAO,EAAS;EACd,GAAG;EACH,SAAS,YAAY;GACnB,IAAI;IACF,OAAO,MAAM,EAAQ,QAAQ;GAC/B,SAAS,GAAK;IACZ,MAAM,EAAmB,CAAG;GAC9B;EACF;CACF,CAAC;AACH"}

package/dist/notional-cap/use-notional-cap-by-symbol-id.d.ts

@@ -0,0 +1,36 @@
+import { ConfigParameter, GetNotionalCapBySymbolIdOptions, GetNotionalCapBySymbolIdReturnType } from '@symmio/trading-core';
+import { UseQueryResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error';
+/** Default polling cadence — 15 s, matching how often the solver re-publishes caps. */
+export declare const DEFAULT_NOTIONAL_CAP_POLLING_MS = 15000;
+/**
+ * Parameters for {@link useNotionalCapBySymbolId}: the core query options
+ * (symbol id, chain id, TanStack `query` overrides) plus an optional `config`
+ * and a `pollingInterval` knob layered on top of `query.refetchInterval`.
+ */
+export type UseNotionalCapBySymbolIdParameters = GetNotionalCapBySymbolIdOptions & ConfigParameter & {
+    /**
+     * Polling cadence in milliseconds. Defaults to
+     * {@link DEFAULT_NOTIONAL_CAP_POLLING_MS}. Pass `false` to disable polling
+     * (the query still refetches on focus / reconnect per TanStack defaults).
+     */
+    pollingInterval?: number | false;
+};
+/** Return type of {@link useNotionalCapBySymbolId}. */
+export type UseNotionalCapBySymbolIdReturnType = UseQueryResult<GetNotionalCapBySymbolIdReturnType, SymmioRequestError>;
+/**
+ * Read the solver's available-liquidity figures for a market. Polls every
+ * {@link DEFAULT_NOTIONAL_CAP_POLLING_MS} by default; pass
+ * `pollingInterval: <ms>` to change the cadence or `pollingInterval: false` to
+ * disable it.
+ *
+ * Errors are normalized to {@link SymmioRequestError}.
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useNotionalCapBySymbolId({ symbolId: 132 });
+ * console.log(data?.availableToLong);
+ * ```
+ */
+export declare function useNotionalCapBySymbolId(parameters: UseNotionalCapBySymbolIdParameters): UseNotionalCapBySymbolIdReturnType;
+//# sourceMappingURL=use-notional-cap-by-symbol-id.d.ts.map

package/dist/notional-cap/use-notional-cap-by-symbol-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-notional-cap-by-symbol-id.d.ts","sourceRoot":"","sources":["../../src/notional-cap/use-notional-cap-by-symbol-id.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,+BAA+B,EACpC,KAAK,kCAAkC,EACxC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAIzE,uFAAuF;AACvF,eAAO,MAAM,+BAA+B,QAAS,CAAC;AAEtD;;;;GAIG;AACH,MAAM,MAAM,kCAAkC,GAAG,+BAA+B,GAC9E,eAAe,GAAG;IAChB;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;CAClC,CAAC;AAEJ,uDAAuD;AACvD,MAAM,MAAM,kCAAkC,GAAG,cAAc,CAAC,kCAAkC,EAAE,kBAAkB,CAAC,CAAC;AAExH;;;;;;;;;;;;;GAaG;AACH,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,kCAAkC,GAC7C,kCAAkC,CAuBpC"}