@symmio/trading-react 0.1.0

package/dist/instant-layer/use-simulate-grant-delegation.d.ts

@@ -0,0 +1,25 @@
+import { ConfigParameter, SimulateGrantDelegationParameters, SimulateGrantDelegationReturnType } from '@symmio/trading-core';
+import { UseMutationResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error';
+/**
+ * Parameters for {@link useSimulateGrantDelegation}: an optional `config` override. The dry-run's
+ * inputs are passed as the mutation `variables`.
+ */
+export type UseSimulateGrantDelegationParameters = ConfigParameter;
+/** Return type of {@link useSimulateGrantDelegation}. */
+export type UseSimulateGrantDelegationReturnType = UseMutationResult<SimulateGrantDelegationReturnType, SymmioRequestError, SimulateGrantDelegationParameters>;
+/**
+ * On-demand dry-run (`simulateContract`) of `grantDelegation`. Call
+ * `mutate(args)` to run it; `data` holds viem's `{ request, result }` (a would-be
+ * revert surfaces as a normalized {@link SymmioRequestError}). `from` defaults to
+ * the connected wallet and `chainId` to the connected chain.
+ *
+ * @example
+ * ```tsx
+ * const sim = useSimulateGrantDelegation();
+ * sim.mutate({ ...args });
+ * // sim.data?.result, sim.isPending, sim.error
+ * ```
+ */
+export declare function useSimulateGrantDelegation(parameters?: UseSimulateGrantDelegationParameters): UseSimulateGrantDelegationReturnType;
+//# sourceMappingURL=use-simulate-grant-delegation.d.ts.map

package/dist/instant-layer/use-simulate-grant-delegation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-simulate-grant-delegation.d.ts","sourceRoot":"","sources":["../../src/instant-layer/use-simulate-grant-delegation.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,iCAAiC,EACtC,KAAK,iCAAiC,EACvC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAe,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAG5E,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,iCAAiC,EACjC,kBAAkB,EAClB,iCAAiC,CAClC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,wBAAgB,0BAA0B,CACxC,UAAU,GAAE,oCAAyC,GACpD,oCAAoC,CAoBtC"}

package/dist/instant-layer/use-simulate-grant-delegation.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 { simulateGrantDelegationMutationOptions as r } from "@symmio/trading-core";
+import { useConnection as i } from "wagmi";
+import { useMutation as a } from "@tanstack/react-query";
+//#region src/instant-layer/use-simulate-grant-delegation.ts
+function o(o = {}) {
+	let s = t(o), c = e(), { address: l } = i(), u = r(s);
+	return a({
+		mutationKey: u.mutationKey,
+		mutationFn: async (e) => {
+			try {
+				return await u.mutationFn({
+					...e,
+					chainId: e.chainId ?? c,
+					from: e.from ?? l
+				});
+			} catch (e) {
+				throw n(e);
+			}
+		}
+	});
+}
+//#endregion
+export { o as useSimulateGrantDelegation };
+
+//# sourceMappingURL=use-simulate-grant-delegation.js.map

package/dist/instant-layer/use-simulate-grant-delegation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-simulate-grant-delegation.js","names":[],"sources":["../../src/instant-layer/use-simulate-grant-delegation.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  simulateGrantDelegationMutationOptions,\n  type ConfigParameter,\n  type SimulateGrantDelegationParameters,\n  type SimulateGrantDelegationReturnType,\n} from \"@symmio/trading-core\";\nimport { useMutation, type UseMutationResult } from \"@tanstack/react-query\";\nimport { useConnection } from \"wagmi\";\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 useSimulateGrantDelegation}: an optional `config` override. The dry-run's\n * inputs are passed as the mutation `variables`.\n */\nexport type UseSimulateGrantDelegationParameters = ConfigParameter;\n\n/** Return type of {@link useSimulateGrantDelegation}. */\nexport type UseSimulateGrantDelegationReturnType = UseMutationResult<\n  SimulateGrantDelegationReturnType,\n  SymmioRequestError,\n  SimulateGrantDelegationParameters\n>;\n\n/**\n * On-demand dry-run (`simulateContract`) of `grantDelegation`. Call\n * `mutate(args)` to run it; `data` holds viem's `{ request, result }` (a would-be\n * revert surfaces as a normalized {@link SymmioRequestError}). `from` defaults to\n * the connected wallet and `chainId` to the connected chain.\n *\n * @example\n * ```tsx\n * const sim = useSimulateGrantDelegation();\n * sim.mutate({ ...args });\n * // sim.data?.result, sim.isPending, sim.error\n * ```\n */\nexport function useSimulateGrantDelegation(\n  parameters: UseSimulateGrantDelegationParameters = {},\n): UseSimulateGrantDelegationReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n  const { address } = useConnection();\n  const base = simulateGrantDelegationMutationOptions(config);\n\n  return useMutation<SimulateGrantDelegationReturnType, SymmioRequestError, SimulateGrantDelegationParameters>({\n    mutationKey: base.mutationKey,\n    mutationFn: async (variables) => {\n      try {\n        return await base.mutationFn({\n          ...variables,\n          chainId: variables.chainId ?? chainId,\n          from: variables.from ?? address,\n        });\n      } catch (err) {\n        throw normalizeSymmError(err);\n      }\n    },\n  });\n}\n"],"mappings":";;;;;;;;AAyCA,SAAgB,EACd,IAAmD,CAAC,GACd;CACtC,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB,GAC3B,EAAE,eAAY,EAAc,GAC5B,IAAO,EAAuC,CAAM;CAE1D,OAAO,EAAsG;EAC3G,aAAa,EAAK;EAClB,YAAY,OAAO,MAAc;GAC/B,IAAI;IACF,OAAO,MAAM,EAAK,WAAW;KAC3B,GAAG;KACH,SAAS,EAAU,WAAW;KAC9B,MAAM,EAAU,QAAQ;IAC1B,CAAC;GACH,SAAS,GAAK;IACZ,MAAM,EAAmB,CAAG;GAC9B;EACF;CACF,CAAC;AACH"}

package/dist/locked-params/index.d.ts

@@ -0,0 +1,2 @@
+export * from './use-locked-params';
+//# sourceMappingURL=index.d.ts.map

package/dist/locked-params/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/locked-params/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}

package/dist/locked-params/use-locked-params.d.ts

@@ -0,0 +1,23 @@
+import { ConfigParameter, GetLockedParamsOptions, GetLockedParamsReturnType } from '@symmio/trading-core';
+import { UseQueryResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error';
+/**
+ * Parameters for {@link useLockedParams}: the core query options (symbol,
+ * leverage, chain id, TanStack `query` overrides) plus an optional `config`.
+ */
+export type UseLockedParamsParameters = GetLockedParamsOptions & ConfigParameter;
+/** Return type of {@link useLockedParams}. */
+export type UseLockedParamsReturnType = UseQueryResult<GetLockedParamsReturnType, SymmioRequestError>;
+/**
+ * Fetch solver locked params for a market/leverage pair.
+ *
+ * The query is disabled until both `symbol` and a positive `leverage` are set.
+ * Errors are normalized to {@link SymmioRequestError}.
+ *
+ * @example
+ * ```tsx
+ * const query = useLockedParams({ symbol: "BTCUSDT", leverage: 5 });
+ * ```
+ */
+export declare function useLockedParams(parameters: UseLockedParamsParameters): UseLockedParamsReturnType;
+//# sourceMappingURL=use-locked-params.d.ts.map

package/dist/locked-params/use-locked-params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-locked-params.d.ts","sourceRoot":"","sources":["../../src/locked-params/use-locked-params.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,KAAK,yBAAyB,EAC/B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAIzE;;;GAGG;AACH,MAAM,MAAM,yBAAyB,GAAG,sBAAsB,GAAG,eAAe,CAAC;AAEjF,8CAA8C;AAC9C,MAAM,MAAM,yBAAyB,GAAG,cAAc,CAAC,yBAAyB,EAAE,kBAAkB,CAAC,CAAC;AAEtG;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,yBAAyB,GAAG,yBAAyB,CAkBhG"}

package/dist/locked-params/use-locked-params.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 { getLockedParamsQueryOptions as r } from "@symmio/trading-core";
+import { useQuery as i } from "@tanstack/react-query";
+//#region src/locked-params/use-locked-params.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 useLockedParams };
+
+//# sourceMappingURL=use-locked-params.js.map

package/dist/locked-params/use-locked-params.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-locked-params.js","names":[],"sources":["../../src/locked-params/use-locked-params.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getLockedParamsQueryOptions,\n  type ConfigParameter,\n  type GetLockedParamsOptions,\n  type GetLockedParamsReturnType,\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 useLockedParams}: the core query options (symbol,\n * leverage, chain id, TanStack `query` overrides) plus an optional `config`.\n */\nexport type UseLockedParamsParameters = GetLockedParamsOptions & ConfigParameter;\n\n/** Return type of {@link useLockedParams}. */\nexport type UseLockedParamsReturnType = UseQueryResult<GetLockedParamsReturnType, SymmioRequestError>;\n\n/**\n * Fetch solver locked params for a market/leverage pair.\n *\n * The query is disabled until both `symbol` and a positive `leverage` are set.\n * Errors are normalized to {@link SymmioRequestError}.\n *\n * @example\n * ```tsx\n * const query = useLockedParams({ symbol: \"BTCUSDT\", leverage: 5 });\n * ```\n */\nexport function useLockedParams(parameters: UseLockedParamsParameters): UseLockedParamsReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n  const options = getLockedParamsQueryOptions(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 UseLockedParamsReturnType;\n}\n"],"mappings":";;;;;;;AAkCA,SAAgB,EAAgB,GAAkE;CAChG,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB,GAC3B,IAAU,EAA4B,GAAQ;EAClD,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/markets/index.d.ts

@@ -0,0 +1,3 @@
+export * from './use-markets';
+export * from './use-onchain-contract-markets';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/markets/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,gCAAgC,CAAC"}

package/dist/markets/use-markets.d.ts

@@ -0,0 +1,26 @@
+import { ConfigParameter, GetMarketsOptions, SymbolContractSymbol } from '@symmio/trading-core';
+import { UseQueryResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error';
+/**
+ * Parameters for {@link useMarkets}: the core query options (chain id, TanStack
+ * `query` overrides) plus an optional `config`.
+ */
+export type UseMarketsParameters = GetMarketsOptions & ConfigParameter;
+/** Return type of {@link useMarkets}. */
+export type UseMarketsReturnType = UseQueryResult<SymbolContractSymbol[], SymmioRequestError>;
+/**
+ * Fetch all tradable markets (contract symbols) from the chain's solver.
+ *
+ * Returns react-query's full {@link UseQueryResult}. Errors are normalized to
+ * {@link SymmioRequestError} so `error.kind` is always a documented value.
+ *
+ * @example
+ * ```tsx
+ * const { data: markets, isLoading, error } = useMarkets();
+ * if (isLoading) return <Spinner />;
+ * if (error) return <ErrorView kind={error.kind} message={error.message} />;
+ * return <MarketList items={markets ?? []} />;
+ * ```
+ */
+export declare function useMarkets(parameters?: UseMarketsParameters): UseMarketsReturnType;
+//# sourceMappingURL=use-markets.d.ts.map

package/dist/markets/use-markets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-markets.d.ts","sourceRoot":"","sources":["../../src/markets/use-markets.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EAC1B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAIzE;;;GAGG;AACH,MAAM,MAAM,oBAAoB,GAAG,iBAAiB,GAAG,eAAe,CAAC;AAEvE,yCAAyC;AACzC,MAAM,MAAM,oBAAoB,GAAG,cAAc,CAAC,oBAAoB,EAAE,EAAE,kBAAkB,CAAC,CAAC;AAE9F;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,UAAU,GAAE,oBAAyB,GAAG,oBAAoB,CAkBtF"}

package/dist/markets/use-markets.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 { getMarketsQueryOptions as r } from "@symmio/trading-core";
+import { useQuery as i } from "@tanstack/react-query";
+//#region src/markets/use-markets.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 useMarkets };
+
+//# sourceMappingURL=use-markets.js.map

package/dist/markets/use-markets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-markets.js","names":[],"sources":["../../src/markets/use-markets.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getMarketsQueryOptions,\n  type ConfigParameter,\n  type GetMarketsOptions,\n  type SymbolContractSymbol,\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 useMarkets}: the core query options (chain id, TanStack\n * `query` overrides) plus an optional `config`.\n */\nexport type UseMarketsParameters = GetMarketsOptions & ConfigParameter;\n\n/** Return type of {@link useMarkets}. */\nexport type UseMarketsReturnType = UseQueryResult<SymbolContractSymbol[], SymmioRequestError>;\n\n/**\n * Fetch all tradable markets (contract symbols) from the chain's solver.\n *\n * Returns react-query's full {@link UseQueryResult}. Errors are normalized to\n * {@link SymmioRequestError} so `error.kind` is always a documented value.\n *\n * @example\n * ```tsx\n * const { data: markets, isLoading, error } = useMarkets();\n * if (isLoading) return <Spinner />;\n * if (error) return <ErrorView kind={error.kind} message={error.message} />;\n * return <MarketList items={markets ?? []} />;\n * ```\n */\nexport function useMarkets(parameters: UseMarketsParameters = {}): UseMarketsReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n  const options = getMarketsQueryOptions(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 UseMarketsReturnType;\n}\n"],"mappings":";;;;;;;AAqCA,SAAgB,EAAW,IAAmC,CAAC,GAAyB;CACtF,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB,GAC3B,IAAU,EAAuB,GAAQ;EAC7C,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/markets/use-onchain-contract-markets.d.ts

@@ -0,0 +1,24 @@
+import { ConfigParameter, GetOnchainContractMarketsOptions, GetOnchainContractMarketsReturnType } from '@symmio/trading-core';
+import { UseQueryResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error';
+/**
+ * Parameters for {@link useOnchainContractMarkets}: the core query options
+ * (start, size, chain id, TanStack `query` overrides) plus an optional `config`.
+ */
+export type UseOnchainContractMarketsParameters = GetOnchainContractMarketsOptions & ConfigParameter;
+/** Return type of {@link useOnchainContractMarkets}. */
+export type UseOnchainContractMarketsReturnType = UseQueryResult<GetOnchainContractMarketsReturnType, SymmioRequestError>;
+/**
+ * Read paginated on-chain contract markets from the SYMMIO core diamond.
+ *
+ * This hook delegates to core's `getOnchainContractMarkets`, which calls the
+ * contract `getSymbols(start, size)` view. Errors are normalized to
+ * {@link SymmioRequestError}.
+ *
+ * @example
+ * ```tsx
+ * const { data } = useOnchainContractMarkets({ start: 0, size: 100 });
+ * ```
+ */
+export declare function useOnchainContractMarkets(parameters: UseOnchainContractMarketsParameters): UseOnchainContractMarketsReturnType;
+//# sourceMappingURL=use-onchain-contract-markets.d.ts.map

package/dist/markets/use-onchain-contract-markets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-onchain-contract-markets.d.ts","sourceRoot":"","sources":["../../src/markets/use-onchain-contract-markets.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,gCAAgC,EACrC,KAAK,mCAAmC,EACzC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAIzE;;;GAGG;AACH,MAAM,MAAM,mCAAmC,GAAG,gCAAgC,GAAG,eAAe,CAAC;AAErG,wDAAwD;AACxD,MAAM,MAAM,mCAAmC,GAAG,cAAc,CAC9D,mCAAmC,EACnC,kBAAkB,CACnB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,mCAAmC,GAC9C,mCAAmC,CAkBrC"}

package/dist/markets/use-onchain-contract-markets.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 { getOnchainContractMarketsQueryOptions as r } from "@symmio/trading-core";
+import { useQuery as i } from "@tanstack/react-query";
+//#region src/markets/use-onchain-contract-markets.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 useOnchainContractMarkets };
+
+//# sourceMappingURL=use-onchain-contract-markets.js.map

package/dist/markets/use-onchain-contract-markets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-onchain-contract-markets.js","names":[],"sources":["../../src/markets/use-onchain-contract-markets.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getOnchainContractMarketsQueryOptions,\n  type ConfigParameter,\n  type GetOnchainContractMarketsOptions,\n  type GetOnchainContractMarketsReturnType,\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 useOnchainContractMarkets}: the core query options\n * (start, size, chain id, TanStack `query` overrides) plus an optional `config`.\n */\nexport type UseOnchainContractMarketsParameters = GetOnchainContractMarketsOptions & ConfigParameter;\n\n/** Return type of {@link useOnchainContractMarkets}. */\nexport type UseOnchainContractMarketsReturnType = UseQueryResult<\n  GetOnchainContractMarketsReturnType,\n  SymmioRequestError\n>;\n\n/**\n * Read paginated on-chain contract markets from the SYMMIO core diamond.\n *\n * This hook delegates to core's `getOnchainContractMarkets`, which calls the\n * contract `getSymbols(start, size)` view. Errors are normalized to\n * {@link SymmioRequestError}.\n *\n * @example\n * ```tsx\n * const { data } = useOnchainContractMarkets({ start: 0, size: 100 });\n * ```\n */\nexport function useOnchainContractMarkets(\n  parameters: UseOnchainContractMarketsParameters,\n): UseOnchainContractMarketsReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n  const options = getOnchainContractMarketsQueryOptions(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 UseOnchainContractMarketsReturnType;\n}\n"],"mappings":";;;;;;;AAsCA,SAAgB,EACd,GACqC;CACrC,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB,GAC3B,IAAU,EAAsC,GAAQ;EAC5D,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/muon/index.d.ts

@@ -0,0 +1,11 @@
+export * from './use-deallocate-upnl-sig';
+export * from './use-muon-party-a-overview';
+export * from './use-muon-price';
+export * from './use-muon-price-range';
+export * from './use-muon-settle-upnl';
+export * from './use-muon-upnl';
+export * from './use-muon-upnl-a';
+export * from './use-muon-upnl-a-with-symbol-price';
+export * from './use-muon-upnl-b';
+export * from './use-muon-upnl-with-symbol-price';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/muon/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AACvC,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qCAAqC,CAAC;AACpD,cAAc,mBAAmB,CAAC;AAClC,cAAc,mCAAmC,CAAC"}

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

@@ -0,0 +1,28 @@
+import { ConfigParameter, GetDeallocateUpnlSigParameters, GetDeallocateUpnlSigReturnType } from '@symmio/trading-core';
+import { UseMutationResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error';
+/**
+ * Parameters for {@link useDeallocateUpnlSig}: an optional `config` override. The
+ * virtual account is passed as the mutation `variables`.
+ */
+export type UseDeallocateUpnlSigParameters = ConfigParameter;
+/** Return type of {@link useDeallocateUpnlSig}. */
+export type UseDeallocateUpnlSigReturnType = UseMutationResult<GetDeallocateUpnlSigReturnType, SymmioRequestError, GetDeallocateUpnlSigParameters>;
+/**
+ * Fetch a fresh Muon uPnL (`uPnl_A`) attestation for a virtual account, on demand.
+ *
+ * Modeled as a **mutation** rather than a query: the signature is timestamped and
+ * short-lived, so it must be fetched at submit time, not eagerly on mount. Call
+ * `mutateAsync({ virtualAccount })` to get the contract-ready `SingleUpnlSig` to
+ * pass to {@link useRemoveMargin} (or the core `removeMargin`). `useRemoveMargin`
+ * already does this for you — reach for this hook only when you need the raw
+ * signature (or the attested uPnL) on its own.
+ *
+ * @example
+ * ```tsx
+ * const { mutateAsync } = useDeallocateUpnlSig();
+ * const upnlSig = await mutateAsync({ virtualAccount: "0xva…" });
+ * ```
+ */
+export declare function useDeallocateUpnlSig(parameters?: UseDeallocateUpnlSigParameters): UseDeallocateUpnlSigReturnType;
+//# sourceMappingURL=use-deallocate-upnl-sig.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-deallocate-upnl-sig.d.ts","sourceRoot":"","sources":["../../src/muon/use-deallocate-upnl-sig.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,8BAA8B,EACnC,KAAK,8BAA8B,EACpC,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,8BAA8B,GAAG,eAAe,CAAC;AAE7D,mDAAmD;AACnD,MAAM,MAAM,8BAA8B,GAAG,iBAAiB,CAC5D,8BAA8B,EAC9B,kBAAkB,EAClB,8BAA8B,CAC/B,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,GAAE,8BAAmC,GAAG,8BAA8B,CAiBpH"}

package/dist/muon/use-deallocate-upnl-sig.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 { getDeallocateUpnlSig as r } from "@symmio/trading-core";
+import { useMutation as i } from "@tanstack/react-query";
+//#region src/muon/use-deallocate-upnl-sig.ts
+function a(a = {}) {
+	let o = t(a), s = e();
+	return i({
+		mutationKey: ["getDeallocateUpnlSig"],
+		mutationFn: async (e) => {
+			try {
+				return await r(o, {
+					virtualAccount: e.virtualAccount,
+					chainId: e.chainId ?? s
+				});
+			} catch (e) {
+				throw n(e);
+			}
+		}
+	});
+}
+//#endregion
+export { a as useDeallocateUpnlSig };
+
+//# sourceMappingURL=use-deallocate-upnl-sig.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-deallocate-upnl-sig.js","names":[],"sources":["../../src/muon/use-deallocate-upnl-sig.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getDeallocateUpnlSig,\n  type ConfigParameter,\n  type GetDeallocateUpnlSigParameters,\n  type GetDeallocateUpnlSigReturnType,\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 useDeallocateUpnlSig}: an optional `config` override. The\n * virtual account is passed as the mutation `variables`.\n */\nexport type UseDeallocateUpnlSigParameters = ConfigParameter;\n\n/** Return type of {@link useDeallocateUpnlSig}. */\nexport type UseDeallocateUpnlSigReturnType = UseMutationResult<\n  GetDeallocateUpnlSigReturnType,\n  SymmioRequestError,\n  GetDeallocateUpnlSigParameters\n>;\n\n/**\n * Fetch a fresh Muon uPnL (`uPnl_A`) attestation for a virtual account, on demand.\n *\n * Modeled as a **mutation** rather than a query: the signature is timestamped and\n * short-lived, so it must be fetched at submit time, not eagerly on mount. Call\n * `mutateAsync({ virtualAccount })` to get the contract-ready `SingleUpnlSig` to\n * pass to {@link useRemoveMargin} (or the core `removeMargin`). `useRemoveMargin`\n * already does this for you — reach for this hook only when you need the raw\n * signature (or the attested uPnL) on its own.\n *\n * @example\n * ```tsx\n * const { mutateAsync } = useDeallocateUpnlSig();\n * const upnlSig = await mutateAsync({ virtualAccount: \"0xva…\" });\n * ```\n */\nexport function useDeallocateUpnlSig(parameters: UseDeallocateUpnlSigParameters = {}): UseDeallocateUpnlSigReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n\n  return useMutation<GetDeallocateUpnlSigReturnType, SymmioRequestError, GetDeallocateUpnlSigParameters>({\n    mutationKey: [\"getDeallocateUpnlSig\"],\n    mutationFn: async (variables) => {\n      try {\n        return await getDeallocateUpnlSig(config, {\n          virtualAccount: variables.virtualAccount,\n          chainId: variables.chainId ?? chainId,\n        });\n      } catch (err) {\n        throw normalizeSymmError(err);\n      }\n    },\n  });\n}\n"],"mappings":";;;;;;;AA2CA,SAAgB,EAAqB,IAA6C,CAAC,GAAmC;CACpH,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB;CAEjC,OAAO,EAAgG;EACrG,aAAa,CAAC,sBAAsB;EACpC,YAAY,OAAO,MAAc;GAC/B,IAAI;IACF,OAAO,MAAM,EAAqB,GAAQ;KACxC,gBAAgB,EAAU;KAC1B,SAAS,EAAU,WAAW;IAChC,CAAC;GACH,SAAS,GAAK;IACZ,MAAM,EAAmB,CAAG;GAC9B;EACF;CACF,CAAC;AACH"}

package/dist/muon/use-muon-party-a-overview.d.ts

@@ -0,0 +1,29 @@
+import { ConfigParameter, GetMuonPartyAOverviewParameters, GetMuonPartyAOverviewReturnType } from '@symmio/trading-core';
+import { UseMutationResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error';
+/**
+ * Parameters for {@link useMuonPartyAOverview}: an optional `config` override. The
+ * partyA is passed as the mutation `variables`.
+ */
+export type UseMuonPartyAOverviewParameters = ConfigParameter;
+/** Return type of {@link useMuonPartyAOverview}. */
+export type UseMuonPartyAOverviewReturnType = UseMutationResult<GetMuonPartyAOverviewReturnType, SymmioRequestError, GetMuonPartyAOverviewParameters>;
+/**
+ * Fetch a fresh Muon `partyA_overview` attestation for a partyA, on demand,
+ * normalized to typed fields (uPnl, loss, liquidation id, 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. This is the uPnL + liquidation data
+ * behind `liquidatePartyA` / `setSymbolsPrice` (it produces a `LiquidationSig`).
+ *
+ * @example
+ * ```tsx
+ * const { mutateAsync } = useMuonPartyAOverview();
+ * const overview = await mutateAsync({ partyA: "0xva…" });
+ * ```
+ */
+export declare function useMuonPartyAOverview(parameters?: UseMuonPartyAOverviewParameters): UseMuonPartyAOverviewReturnType;
+//# sourceMappingURL=use-muon-party-a-overview.d.ts.map

package/dist/muon/use-muon-party-a-overview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-muon-party-a-overview.d.ts","sourceRoot":"","sources":["../../src/muon/use-muon-party-a-overview.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,+BAA+B,EACpC,KAAK,+BAA+B,EACrC,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,+BAA+B,GAAG,eAAe,CAAC;AAE9D,oDAAoD;AACpD,MAAM,MAAM,+BAA+B,GAAG,iBAAiB,CAC7D,+BAA+B,EAC/B,kBAAkB,EAClB,+BAA+B,CAChC,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,GAAE,+BAAoC,GAC/C,+BAA+B,CAiBjC"}

package/dist/muon/use-muon-party-a-overview.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 { getMuonPartyAOverview as r } from "@symmio/trading-core";
+import { useMutation as i } from "@tanstack/react-query";
+//#region src/muon/use-muon-party-a-overview.ts
+function a(a = {}) {
+	let o = t(a), s = e();
+	return i({
+		mutationKey: ["getMuonPartyAOverview"],
+		mutationFn: async (e) => {
+			try {
+				return await r(o, {
+					partyA: e.partyA,
+					chainId: e.chainId ?? s
+				});
+			} catch (e) {
+				throw n(e);
+			}
+		}
+	});
+}
+//#endregion
+export { a as useMuonPartyAOverview };
+
+//# sourceMappingURL=use-muon-party-a-overview.js.map

package/dist/muon/use-muon-party-a-overview.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-muon-party-a-overview.js","names":[],"sources":["../../src/muon/use-muon-party-a-overview.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getMuonPartyAOverview,\n  type ConfigParameter,\n  type GetMuonPartyAOverviewParameters,\n  type GetMuonPartyAOverviewReturnType,\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 useMuonPartyAOverview}: an optional `config` override. The\n * partyA is passed as the mutation `variables`.\n */\nexport type UseMuonPartyAOverviewParameters = ConfigParameter;\n\n/** Return type of {@link useMuonPartyAOverview}. */\nexport type UseMuonPartyAOverviewReturnType = UseMutationResult<\n  GetMuonPartyAOverviewReturnType,\n  SymmioRequestError,\n  GetMuonPartyAOverviewParameters\n>;\n\n/**\n * Fetch a fresh Muon `partyA_overview` attestation for a partyA, on demand,\n * normalized to typed fields (uPnl, loss, liquidation id, quote/symbol 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 })`. `chainId` and the `symmio` address are\n * resolved from the connected chain's config. This is the uPnL + liquidation data\n * behind `liquidatePartyA` / `setSymbolsPrice` (it produces a `LiquidationSig`).\n *\n * @example\n * ```tsx\n * const { mutateAsync } = useMuonPartyAOverview();\n * const overview = await mutateAsync({ partyA: \"0xva…\" });\n * ```\n */\nexport function useMuonPartyAOverview(\n  parameters: UseMuonPartyAOverviewParameters = {},\n): UseMuonPartyAOverviewReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n\n  return useMutation<GetMuonPartyAOverviewReturnType, SymmioRequestError, GetMuonPartyAOverviewParameters>({\n    mutationKey: [\"getMuonPartyAOverview\"],\n    mutationFn: async (variables) => {\n      try {\n        return await getMuonPartyAOverview(config, {\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,EACd,IAA8C,CAAC,GACd;CACjC,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB;CAEjC,OAAO,EAAkG;EACvG,aAAa,CAAC,uBAAuB;EACrC,YAAY,OAAO,MAAc;GAC/B,IAAI;IACF,OAAO,MAAM,EAAsB,GAAQ;KACzC,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-price-range.d.ts

@@ -0,0 +1,35 @@
+import { ConfigParameter, GetMuonPriceRangeParameters, GetMuonPriceRangeReturnType } from '@symmio/trading-core';
+import { UseMutationResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error';
+/**
+ * Parameters for {@link useMuonPriceRange}: an optional `config` override. The
+ * window, parties, and symbol id are passed as the mutation `variables`.
+ */
+export type UseMuonPriceRangeParameters = ConfigParameter;
+/** Return type of {@link useMuonPriceRange}. */
+export type UseMuonPriceRangeReturnType = UseMutationResult<GetMuonPriceRangeReturnType, SymmioRequestError, GetMuonPriceRangeParameters>;
+/**
+ * Fetch a fresh Muon `priceRange` attestation for a position over a `[t0, t1]`
+ * window, on demand, normalized to typed fields (lowest/highest/mean/price,
+ * uPnL, 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({ t0, t1, partyA, partyB, symbolId })`.
+ * `chainId` and the `symmio` address are resolved from the connected chain's
+ * config.
+ *
+ * @example
+ * ```tsx
+ * const { mutateAsync } = useMuonPriceRange();
+ * const r = await mutateAsync({
+ *   t0: 1_700_000_000n,
+ *   t1: 1_700_000_900n,
+ *   partyA: "0xva…",
+ *   partyB: "0xpb…",
+ *   symbolId: 1n,
+ * });
+ * ```
+ */
+export declare function useMuonPriceRange(parameters?: UseMuonPriceRangeParameters): UseMuonPriceRangeReturnType;
+//# sourceMappingURL=use-muon-price-range.d.ts.map

package/dist/muon/use-muon-price-range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-muon-price-range.d.ts","sourceRoot":"","sources":["../../src/muon/use-muon-price-range.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;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,GAAE,2BAAgC,GAAG,2BAA2B,CAqB3G"}

package/dist/muon/use-muon-price-range.js

@@ -0,0 +1,31 @@
+"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 { getMuonPriceRange as r } from "@symmio/trading-core";
+import { useMutation as i } from "@tanstack/react-query";
+//#region src/muon/use-muon-price-range.ts
+function a(a = {}) {
+	let o = t(a), s = e();
+	return i({
+		mutationKey: ["getMuonPriceRange"],
+		mutationFn: async (e) => {
+			try {
+				return await r(o, {
+					t0: e.t0,
+					t1: e.t1,
+					partyA: e.partyA,
+					partyB: e.partyB,
+					symbolId: e.symbolId,
+					chainId: e.chainId ?? s
+				});
+			} catch (e) {
+				throw n(e);
+			}
+		}
+	});
+}
+//#endregion
+export { a as useMuonPriceRange };
+
+//# sourceMappingURL=use-muon-price-range.js.map

package/dist/muon/use-muon-price-range.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-muon-price-range.js","names":[],"sources":["../../src/muon/use-muon-price-range.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getMuonPriceRange,\n  type ConfigParameter,\n  type GetMuonPriceRangeParameters,\n  type GetMuonPriceRangeReturnType,\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 useMuonPriceRange}: an optional `config` override. The\n * window, parties, and symbol id are passed as the mutation `variables`.\n */\nexport type UseMuonPriceRangeParameters = ConfigParameter;\n\n/** Return type of {@link useMuonPriceRange}. */\nexport type UseMuonPriceRangeReturnType = UseMutationResult<\n  GetMuonPriceRangeReturnType,\n  SymmioRequestError,\n  GetMuonPriceRangeParameters\n>;\n\n/**\n * Fetch a fresh Muon `priceRange` attestation for a position over a `[t0, t1]`\n * window, on demand, normalized to typed fields (lowest/highest/mean/price,\n * uPnL, signature envelope).\n *\n * Modeled as a **mutation** rather than a query: Muon attestations are\n * timestamped and short-lived, so they are fetched on an explicit action, not\n * eagerly on mount. Call `mutateAsync({ t0, t1, partyA, partyB, symbolId })`.\n * `chainId` and the `symmio` address are resolved from the connected chain's\n * config.\n *\n * @example\n * ```tsx\n * const { mutateAsync } = useMuonPriceRange();\n * const r = await mutateAsync({\n *   t0: 1_700_000_000n,\n *   t1: 1_700_000_900n,\n *   partyA: \"0xva…\",\n *   partyB: \"0xpb…\",\n *   symbolId: 1n,\n * });\n * ```\n */\nexport function useMuonPriceRange(parameters: UseMuonPriceRangeParameters = {}): UseMuonPriceRangeReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n\n  return useMutation<GetMuonPriceRangeReturnType, SymmioRequestError, GetMuonPriceRangeParameters>({\n    mutationKey: [\"getMuonPriceRange\"],\n    mutationFn: async (variables) => {\n      try {\n        return await getMuonPriceRange(config, {\n          t0: variables.t0,\n          t1: variables.t1,\n          partyA: variables.partyA,\n          partyB: variables.partyB,\n          symbolId: variables.symbolId,\n          chainId: variables.chainId ?? chainId,\n        });\n      } catch (err) {\n        throw normalizeSymmError(err);\n      }\n    },\n  });\n}\n"],"mappings":";;;;;;;AAkDA,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,IAAI,EAAU;KACd,IAAI,EAAU;KACd,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-price.d.ts

@@ -0,0 +1,28 @@
+import { ConfigParameter, GetMuonPriceParameters, GetMuonPriceReturnType } from '@symmio/trading-core';
+import { UseMutationResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error';
+/**
+ * Parameters for {@link useMuonPrice}: an optional `config` override. The quote
+ * ids are passed as the mutation `variables`.
+ */
+export type UseMuonPriceParameters = ConfigParameter;
+/** Return type of {@link useMuonPrice}. */
+export type UseMuonPriceReturnType = UseMutationResult<GetMuonPriceReturnType, SymmioRequestError, GetMuonPriceParameters>;
+/**
+ * Fetch a fresh Muon `price` attestation for a set of quote ids, on demand,
+ * normalized to typed fields (validated prices, mark prices, symbols, 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({ quoteIds })`. `chainId` and the `symmio` address are
+ * resolved from the connected chain's config.
+ *
+ * @example
+ * ```tsx
+ * const { mutateAsync } = useMuonPrice();
+ * const p = await mutateAsync({ quoteIds: [10n, 11n] });
+ * ```
+ */
+export declare function useMuonPrice(parameters?: UseMuonPriceParameters): UseMuonPriceReturnType;
+//# sourceMappingURL=use-muon-price.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-muon-price.d.ts","sourceRoot":"","sources":["../../src/muon/use-muon-price.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-price.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 { getMuonPrice as r } from "@symmio/trading-core";
+import { useMutation as i } from "@tanstack/react-query";
+//#region src/muon/use-muon-price.ts
+function a(a = {}) {
+	let o = t(a), s = e();
+	return i({
+		mutationKey: ["getMuonPrice"],
+		mutationFn: async (e) => {
+			try {
+				return await r(o, {
+					quoteIds: e.quoteIds,
+					chainId: e.chainId ?? s
+				});
+			} catch (e) {
+				throw n(e);
+			}
+		}
+	});
+}
+//#endregion
+export { a as useMuonPrice };
+
+//# sourceMappingURL=use-muon-price.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"use-muon-price.js","names":[],"sources":["../../src/muon/use-muon-price.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getMuonPrice,\n  type ConfigParameter,\n  type GetMuonPriceParameters,\n  type GetMuonPriceReturnType,\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 useMuonPrice}: an optional `config` override. The quote\n * ids are passed as the mutation `variables`.\n */\nexport type UseMuonPriceParameters = ConfigParameter;\n\n/** Return type of {@link useMuonPrice}. */\nexport type UseMuonPriceReturnType = UseMutationResult<\n  GetMuonPriceReturnType,\n  SymmioRequestError,\n  GetMuonPriceParameters\n>;\n\n/**\n * Fetch a fresh Muon `price` attestation for a set of quote ids, on demand,\n * normalized to typed fields (validated prices, mark prices, symbols, 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({ quoteIds })`. `chainId` and the `symmio` address are\n * resolved from the connected chain's config.\n *\n * @example\n * ```tsx\n * const { mutateAsync } = useMuonPrice();\n * const p = await mutateAsync({ quoteIds: [10n, 11n] });\n * ```\n */\nexport function useMuonPrice(parameters: UseMuonPriceParameters = {}): UseMuonPriceReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n\n  return useMutation<GetMuonPriceReturnType, SymmioRequestError, GetMuonPriceParameters>({\n    mutationKey: [\"getMuonPrice\"],\n    mutationFn: async (variables) => {\n      try {\n        return await getMuonPrice(config, {\n          quoteIds: variables.quoteIds,\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,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-settle-upnl.d.ts

@@ -0,0 +1,29 @@
+import { ConfigParameter, GetMuonSettleUpnlParameters, GetMuonSettleUpnlReturnType } from '@symmio/trading-core';
+import { UseMutationResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error';
+/**
+ * Parameters for {@link useMuonSettleUpnl}: an optional `config` override. The
+ * partyA and quote ids are passed as the mutation `variables`.
+ */
+export type UseMuonSettleUpnlParameters = ConfigParameter;
+/** Return type of {@link useMuonSettleUpnl}. */
+export type UseMuonSettleUpnlReturnType = UseMutationResult<GetMuonSettleUpnlReturnType, SymmioRequestError, GetMuonSettleUpnlParameters>;
+/**
+ * Fetch a fresh Muon `settle_upnl` attestation for a partyA over a set of quote
+ * ids, on demand, normalized to typed fields (settlement 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({ partyA, quoteIds })`. `chainId` and the `symmio`
+ * address are resolved from the connected chain's config. The settlement data
+ * this produces is what `settleUpnl` requires.
+ *
+ * @example
+ * ```tsx
+ * const { mutateAsync } = useMuonSettleUpnl();
+ * const s = await mutateAsync({ partyA: "0xva…", quoteIds: [10n, 11n] });
+ * ```
+ */
+export declare function useMuonSettleUpnl(parameters?: UseMuonSettleUpnlParameters): UseMuonSettleUpnlReturnType;
+//# sourceMappingURL=use-muon-settle-upnl.d.ts.map