@symmio/trading-react 3.0.0 → 3.1.0

package/dist/instant-layer/use-initiate-revoke-delegation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-initiate-revoke-delegation.js","names":[],"sources":["../../src/instant-layer/use-initiate-revoke-delegation.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getActiveDelegationsQueryKey,\n  getDelegationExpiryQueryKey,\n  getIsDelegationActiveQueryKey,\n  getPendingRevocationEtasQueryKey,\n  initiateRevokeDelegationMutationOptions,\n  type InitiateRevokeDelegationParameters,\n} from \"@symmio/trading-core\";\nimport { useMutation, useQueryClient, 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\";\nimport { resolveWriteResult, type WriteParameters, type WriteResult } from \"../transactions\";\nimport { predicateMatch } from \"../utils\";\n\n/** Parameters for {@link useInitiateRevokeDelegation}. */\nexport type UseInitiateRevokeDelegationParameters = WriteParameters;\n\n/** Result returned by the {@link useInitiateRevokeDelegation} mutation. */\nexport type InitiateRevokeDelegationResult = WriteResult;\n\n/** Return type of {@link useInitiateRevokeDelegation}. */\nexport type UseInitiateRevokeDelegationReturnType = UseMutationResult<\n  InitiateRevokeDelegationResult,\n  SymmioRequestError,\n  InitiateRevokeDelegationParameters\n>;\n\n/**\n * Start revoking a session key's Instant Layer delegation.\n *\n * **Always a gas-paid wallet transaction — there is no gasless option.** The\n * relay signs InstantLayer *operations*, and the contract accepts a\n * self-targeted operation only as a delegation grant, so a relayed revocation\n * would revert. Budget native gas for this call.\n *\n * The contract accepts it from the account owner, from the delegate itself, or\n * from a `REVOKER_ROLE` holder, and it only *schedules* the revocation: the key\n * keeps its authority until the cooldown ETA passes (see\n * {@link useRevocationCooldown}), after which {@link useFinalizeRevokeDelegation}\n * clears the stored grant.\n *\n * @example\n * ```tsx\n * const { mutate } = useInitiateRevokeDelegation();\n * mutate({ account: { addr: subAccount, isPartyB: false }, delegate: sessionKey, selectors });\n * ```\n */\nexport function useInitiateRevokeDelegation(\n  parameters: UseInitiateRevokeDelegationParameters = {},\n): UseInitiateRevokeDelegationReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n  const queryClient = useQueryClient();\n\n  const base = initiateRevokeDelegationMutationOptions(config);\n\n  return useMutation<InitiateRevokeDelegationResult, SymmioRequestError, InitiateRevokeDelegationParameters>({\n    mutationKey: base.mutationKey,\n    mutationFn: async (variables) => {\n      try {\n        const hash = await base.mutationFn(variables);\n        return resolveWriteResult(config, hash, {\n          chainId: variables.chainId,\n          waitForReceipt: parameters.waitForReceipt,\n          confirmations: parameters.confirmations,\n        });\n      } catch (err) {\n        throw normalizeSymmError(err);\n      }\n    },\n    onSuccess: (_data, variables) => {\n      const configKey = config.getChainConfigKey(variables.chainId ?? chainId);\n      const delegation = { configKey, account: variables.account.addr, delegate: variables.delegate };\n\n      void queryClient.invalidateQueries({ predicate: predicateMatch(getDelegationExpiryQueryKey, delegation) });\n      void queryClient.invalidateQueries({ predicate: predicateMatch(getIsDelegationActiveQueryKey, delegation) });\n      /**\n       * The canonicalizing read keys by `delegator`, not `account`, so it needs\n       * its own predicate rather than reusing the pair above.\n       */\n      void queryClient.invalidateQueries({\n        predicate: predicateMatch(getActiveDelegationsQueryKey, { configKey, delegator: variables.account }),\n      });\n      /**\n       * The one read whose answer this write actually changes — the others keep\n       * reporting the delegation as active until the cooldown ETA passes.\n       */\n      void queryClient.invalidateQueries({\n        predicate: predicateMatch(getPendingRevocationEtasQueryKey, {\n          configKey,\n          delegator: variables.account,\n          delegate: variables.delegate,\n        }),\n      });\n    },\n  });\n}\n"],"mappings":";;;;;;;;;AAmDA,SAAgB,EACd,IAAoD,CAAC,GACd;CACvC,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB,GAC3B,IAAc,EAAe,GAE7B,IAAO,EAAwC,CAAM;CAE3D,OAAO,EAAoG;EACzG,aAAa,EAAK;EAClB,YAAY,OAAO,MAAc;GAC/B,IAAI;IAEF,OAAO,EAAmB,GAAQ,MADf,EAAK,WAAW,CAAS,GACJ;KACtC,SAAS,EAAU;KACnB,gBAAgB,EAAW;KAC3B,eAAe,EAAW;IAC5B,CAAC;GACH,SAAS,GAAK;IACZ,MAAM,EAAmB,CAAG;GAC9B;EACF;EACA,YAAY,GAAO,MAAc;GAC/B,IAAM,IAAY,EAAO,kBAAkB,EAAU,WAAW,CAAO,GACjE,IAAa;IAAE;IAAW,SAAS,EAAU,QAAQ;IAAM,UAAU,EAAU;GAAS;GAe9F,AAbA,EAAiB,kBAAkB,EAAE,WAAW,EAAe,GAA6B,CAAU,EAAE,CAAC,GACzG,EAAiB,kBAAkB,EAAE,WAAW,EAAe,GAA+B,CAAU,EAAE,CAAC,GAK3G,EAAiB,kBAAkB,EACjC,WAAW,EAAe,GAA8B;IAAE;IAAW,WAAW,EAAU;GAAQ,CAAC,EACrG,CAAC,GAKD,EAAiB,kBAAkB,EACjC,WAAW,EAAe,GAAkC;IAC1D;IACA,WAAW,EAAU;IACrB,UAAU,EAAU;GACtB,CAAC,EACH,CAAC;EACH;CACF,CAAC;AACH"}

package/dist/instant-layer/use-pending-revocation.d.ts

@@ -0,0 +1,119 @@
+import { ConfigParameter, GetPendingRevocationEtasOptions, GetPendingRevocationEtasReturnType, InstantLayerAccount } from '@symmio/trading-core';
+import { UseQueryResult } from '@tanstack/react-query';
+import { Address, Hex } from 'viem';
+import { SymmioRequestError } from '../errors/symmio-request-error.js';
+/** Parameters for {@link usePendingRevocation}. */
+export interface UsePendingRevocationParameters extends ConfigParameter {
+    /**
+     * Account the delegation is enforced under — pass the same account that was
+     * handed to `useInitiateRevokeDelegation`. Unlike {@link useAreDelegationsActive},
+     * the underlying read does **not** canonicalize a virtual account to its
+     * parent, because neither does the mapping it reads.
+     */
+    account: InstantLayerAccount;
+    /** Delegated signer being checked, typically the session key's address. */
+    delegate: Address;
+    /**
+     * Selectors to probe. Pass the **granted** set — the same one handed to
+     * `useSessionKeySelectors` / `useAreDelegationsActive` — not that hook's
+     * `activeSelectors`. Enforcement stops the moment the ETA passes, so
+     * `activeSelectors` empties out exactly when the revocation becomes
+     * finalizable, and probing it would hide the scheduled revocation at the one
+     * moment a UI needs it.
+     */
+    selectors: readonly Hex[];
+    /** Optional chain override; defaults to the config's chain. */
+    chainId?: number;
+    /** TanStack Query overrides for the underlying read. */
+    query?: GetPendingRevocationEtasOptions["query"];
+}
+/** Return type of {@link usePendingRevocation}. */
+export interface UsePendingRevocationReturnType {
+    /**
+     * `true` while at least one probed selector has a scheduled revocation whose
+     * ETA has **not** passed — the key is still signing, but on its way out.
+     */
+    isRevoking: boolean;
+    /**
+     * The **latest** ETA across the scheduled selectors, as a Unix timestamp in
+     * seconds — the moment the key stops being able to sign anything at all.
+     * `undefined` when no revocation is scheduled.
+     */
+    etaTimestamp?: bigint;
+    /**
+     * Whole seconds left until {@link UsePendingRevocationReturnType.etaTimestamp},
+     * recomputed every second while the revocation counts down and clamped at `0`
+     * once it lands. `undefined` when no revocation is scheduled.
+     *
+     * This is the value to render as a live countdown: `etaTimestamp` alone is a
+     * fixed instant, so formatting it relatively (`"in 9m"`) looks frozen for a
+     * minute at a time.
+     */
+    secondsRemaining?: number;
+    /**
+     * Probed selectors with a scheduled revocation, in the order they were
+     * requested. A selector stays in this list after its ETA passes, until
+     * someone finalizes — it is scheduled either way, only no longer enforced.
+     */
+    revokingSelectors: readonly Hex[];
+    /**
+     * `true` when a revocation is scheduled and **every** scheduled ETA has
+     * passed, so `useFinalizeRevokeDelegation` will go through. Finalizing while
+     * any ETA is still in the future reverts with `RevocationCooldownNotOver`.
+     */
+    isFinalizable: boolean;
+    /** `true` while the underlying read is in flight. */
+    isLoading: boolean;
+    /** `true` when the underlying read failed. */
+    isError: boolean;
+    /** The read's error, if any. */
+    error: SymmioRequestError | null;
+    /** Refetch the underlying read — call it after an initiate or finalize settles. */
+    refetch: UseQueryResult<GetPendingRevocationEtasReturnType, SymmioRequestError>["refetch"];
+    /** The full underlying query result, for states this hook does not surface. */
+    query: UseQueryResult<GetPendingRevocationEtasReturnType, SymmioRequestError>;
+}
+/**
+ * "Is this key being revoked, and until when is it still live?" — the pending
+ * side of the two-step revocation, against a clock that ticks.
+ *
+ * **This is the only way to see a revocation in flight.** `initiateRevokeDelegation`
+ * does not clear the grant; it schedules one, and the contract keeps enforcing
+ * the delegation until the ETA passes. {@link useAreDelegationsActive} therefore
+ * keeps reporting the key as active for the whole cooldown — correctly, because
+ * it is. Pair the two: that hook answers "can it sign?", this one answers "is it
+ * on its way out, and when does that land?".
+ *
+ * The comparison runs against a 1-second clock that starts only while something
+ * is actually counting down and stops itself once the last ETA passes, so
+ * `isRevoking` flips to `false` and `isFinalizable` to `true` on their own —
+ * a finalize button gated on them enables itself without a refresh. That same
+ * clock drives `secondsRemaining`, so a live countdown needs no timer of its
+ * own.
+ *
+ * **Probe the granted selector set, not the active one.** A delegation stops
+ * being enforced at its ETA but stays scheduled until someone finalizes, so
+ * `useAreDelegationsActive`'s `activeSelectors` goes empty precisely when
+ * `isFinalizable` should turn `true`. Feeding that shrinking list back in here
+ * would disable a finalize button at the moment it becomes callable.
+ *
+ * The read is skipped entirely for an empty `selectors` list — there is nothing
+ * to probe — unless `query.enabled` says otherwise.
+ *
+ * @param parameters - Account, delegate, probed selectors, optional chain and query overrides.
+ * @returns Whether a revocation is pending, its ETA, the scheduled selectors, and the read's state.
+ *
+ * @example
+ * ```tsx
+ * const { isRevoking, etaTimestamp, isFinalizable } = usePendingRevocation({
+ *   account: { addr: subAccount, isPartyB: false },
+ *   delegate: sessionKeyAddress,
+ *   selectors: grantedSelectors,
+ * });
+ *
+ * if (isRevoking) return <p>Revoking — still live until {formatTime(etaTimestamp)}</p>;
+ * return <button disabled={!isFinalizable}>Finalize revoke</button>;
+ * ```
+ */
+export declare function usePendingRevocation(parameters: UsePendingRevocationParameters): UsePendingRevocationReturnType;
+//# sourceMappingURL=use-pending-revocation.d.ts.map

package/dist/instant-layer/use-pending-revocation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-pending-revocation.d.ts","sourceRoot":"","sources":["../../src/instant-layer/use-pending-revocation.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,+BAA+B,EACpC,KAAK,kCAAkC,EACvC,KAAK,mBAAmB,EACzB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEtE,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAEzC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAGzE,mDAAmD;AACnD,MAAM,WAAW,8BAA+B,SAAQ,eAAe;IACrE;;;;;OAKG;IACH,OAAO,EAAE,mBAAmB,CAAC;IAC7B,2EAA2E;IAC3E,QAAQ,EAAE,OAAO,CAAC;IAClB;;;;;;;OAOG;IACH,SAAS,EAAE,SAAS,GAAG,EAAE,CAAC;IAC1B,+DAA+D;IAC/D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,wDAAwD;IACxD,KAAK,CAAC,EAAE,+BAA+B,CAAC,OAAO,CAAC,CAAC;CAClD;AAED,mDAAmD;AACnD,MAAM,WAAW,8BAA8B;IAC7C;;;OAGG;IACH,UAAU,EAAE,OAAO,CAAC;IACpB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;;;OAQG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,iBAAiB,EAAE,SAAS,GAAG,EAAE,CAAC;IAClC;;;;OAIG;IACH,aAAa,EAAE,OAAO,CAAC;IACvB,qDAAqD;IACrD,SAAS,EAAE,OAAO,CAAC;IACnB,8CAA8C;IAC9C,OAAO,EAAE,OAAO,CAAC;IACjB,gCAAgC;IAChC,KAAK,EAAE,kBAAkB,GAAG,IAAI,CAAC;IACjC,mFAAmF;IACnF,OAAO,EAAE,cAAc,CAAC,kCAAkC,EAAE,kBAAkB,CAAC,CAAC,SAAS,CAAC,CAAC;IAC3F,+EAA+E;IAC/E,KAAK,EAAE,cAAc,CAAC,kCAAkC,EAAE,kBAAkB,CAAC,CAAC;CAC/E;AAUD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,8BAA8B,GAAG,8BAA8B,CA6E/G"}

package/dist/instant-layer/use-pending-revocation.js

@@ -0,0 +1,73 @@
+"use client";
+import { useSymmioConfig as e } from "../provider/use-symmio-config.js";
+import { normalizeSymmError as t } from "../errors/normalize-symm-error.js";
+import { getPendingRevocationEtasQueryOptions as n } from "@symmio/trading-core";
+import { useEffect as r, useMemo as i, useState as a } from "react";
+import { useQuery as o } from "@tanstack/react-query";
+//#region src/instant-layer/use-pending-revocation.ts
+var s = /* @__PURE__ */ new Map();
+function c() {
+	return BigInt(Math.floor(Date.now() / 1e3));
+}
+function l(l) {
+	let u = e(l), { account: d, delegate: f, selectors: p, chainId: m, query: h } = l, g = n(u, {
+		delegator: d,
+		delegate: f,
+		selectors: p,
+		chainId: m,
+		query: {
+			...h,
+			enabled: h?.enabled ?? p.length > 0
+		}
+	}), _ = o({
+		...g,
+		queryFn: async () => {
+			try {
+				return await g.queryFn();
+			} catch (e) {
+				throw t(e);
+			}
+		}
+	}), { data: v, isLoading: y, isError: b, error: x, refetch: S } = _, C = v ?? s, w = i(() => p.filter((e) => C.has(e)), [p, C]), T = i(() => {
+		let e;
+		for (let t of C.values()) (e === void 0 || t > e) && (e = t);
+		return e;
+	}, [C]), [E, D] = a(c);
+	return r(() => {
+		if (T === void 0 || (D(c()), T <= c())) return;
+		let e = setInterval(() => {
+			let t = c();
+			D(t), t >= T && clearInterval(e);
+		}, 1e3);
+		return () => clearInterval(e);
+	}, [T]), i(() => {
+		let e = !1, t = C.size > 0;
+		for (let n of C.values()) n > E && (e = !0, t = !1);
+		return {
+			isRevoking: e,
+			etaTimestamp: T,
+			secondsRemaining: T === void 0 ? void 0 : Number(T > E ? T - E : 0n),
+			revokingSelectors: w,
+			isFinalizable: t,
+			isLoading: y,
+			isError: b,
+			error: x ?? null,
+			refetch: S,
+			query: _
+		};
+	}, [
+		C,
+		E,
+		T,
+		w,
+		y,
+		b,
+		x,
+		S,
+		_
+	]);
+}
+//#endregion
+export { l as usePendingRevocation };
+
+//# sourceMappingURL=use-pending-revocation.js.map

package/dist/instant-layer/use-pending-revocation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-pending-revocation.js","names":[],"sources":["../../src/instant-layer/use-pending-revocation.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getPendingRevocationEtasQueryOptions,\n  type ConfigParameter,\n  type GetPendingRevocationEtasOptions,\n  type GetPendingRevocationEtasReturnType,\n  type InstantLayerAccount,\n} from \"@symmio/trading-core\";\nimport { useQuery, type UseQueryResult } from \"@tanstack/react-query\";\nimport { useEffect, useMemo, useState } from \"react\";\nimport type { Address, Hex } from \"viem\";\nimport { normalizeSymmError } from \"../errors/normalize-symm-error\";\nimport type { SymmioRequestError } from \"../errors/symmio-request-error\";\nimport { useSymmioConfig } from \"../provider/use-symmio-config\";\n\n/** Parameters for {@link usePendingRevocation}. */\nexport interface UsePendingRevocationParameters extends ConfigParameter {\n  /**\n   * Account the delegation is enforced under — pass the same account that was\n   * handed to `useInitiateRevokeDelegation`. Unlike {@link useAreDelegationsActive},\n   * the underlying read does **not** canonicalize a virtual account to its\n   * parent, because neither does the mapping it reads.\n   */\n  account: InstantLayerAccount;\n  /** Delegated signer being checked, typically the session key's address. */\n  delegate: Address;\n  /**\n   * Selectors to probe. Pass the **granted** set — the same one handed to\n   * `useSessionKeySelectors` / `useAreDelegationsActive` — not that hook's\n   * `activeSelectors`. Enforcement stops the moment the ETA passes, so\n   * `activeSelectors` empties out exactly when the revocation becomes\n   * finalizable, and probing it would hide the scheduled revocation at the one\n   * moment a UI needs it.\n   */\n  selectors: readonly Hex[];\n  /** Optional chain override; defaults to the config's chain. */\n  chainId?: number;\n  /** TanStack Query overrides for the underlying read. */\n  query?: GetPendingRevocationEtasOptions[\"query\"];\n}\n\n/** Return type of {@link usePendingRevocation}. */\nexport interface UsePendingRevocationReturnType {\n  /**\n   * `true` while at least one probed selector has a scheduled revocation whose\n   * ETA has **not** passed — the key is still signing, but on its way out.\n   */\n  isRevoking: boolean;\n  /**\n   * The **latest** ETA across the scheduled selectors, as a Unix timestamp in\n   * seconds — the moment the key stops being able to sign anything at all.\n   * `undefined` when no revocation is scheduled.\n   */\n  etaTimestamp?: bigint;\n  /**\n   * Whole seconds left until {@link UsePendingRevocationReturnType.etaTimestamp},\n   * recomputed every second while the revocation counts down and clamped at `0`\n   * once it lands. `undefined` when no revocation is scheduled.\n   *\n   * This is the value to render as a live countdown: `etaTimestamp` alone is a\n   * fixed instant, so formatting it relatively (`\"in 9m\"`) looks frozen for a\n   * minute at a time.\n   */\n  secondsRemaining?: number;\n  /**\n   * Probed selectors with a scheduled revocation, in the order they were\n   * requested. A selector stays in this list after its ETA passes, until\n   * someone finalizes — it is scheduled either way, only no longer enforced.\n   */\n  revokingSelectors: readonly Hex[];\n  /**\n   * `true` when a revocation is scheduled and **every** scheduled ETA has\n   * passed, so `useFinalizeRevokeDelegation` will go through. Finalizing while\n   * any ETA is still in the future reverts with `RevocationCooldownNotOver`.\n   */\n  isFinalizable: boolean;\n  /** `true` while the underlying read is in flight. */\n  isLoading: boolean;\n  /** `true` when the underlying read failed. */\n  isError: boolean;\n  /** The read's error, if any. */\n  error: SymmioRequestError | null;\n  /** Refetch the underlying read — call it after an initiate or finalize settles. */\n  refetch: UseQueryResult<GetPendingRevocationEtasReturnType, SymmioRequestError>[\"refetch\"];\n  /** The full underlying query result, for states this hook does not surface. */\n  query: UseQueryResult<GetPendingRevocationEtasReturnType, SymmioRequestError>;\n}\n\n/** Stable empty result so a pending read does not churn the memo's identity. */\nconst NO_ETAS: GetPendingRevocationEtasReturnType = new Map<Hex, bigint>();\n\n/** Current Unix time in seconds, the unit every on-chain timestamp uses. */\nfunction nowSeconds(): bigint {\n  return BigInt(Math.floor(Date.now() / 1000));\n}\n\n/**\n * \"Is this key being revoked, and until when is it still live?\" — the pending\n * side of the two-step revocation, against a clock that ticks.\n *\n * **This is the only way to see a revocation in flight.** `initiateRevokeDelegation`\n * does not clear the grant; it schedules one, and the contract keeps enforcing\n * the delegation until the ETA passes. {@link useAreDelegationsActive} therefore\n * keeps reporting the key as active for the whole cooldown — correctly, because\n * it is. Pair the two: that hook answers \"can it sign?\", this one answers \"is it\n * on its way out, and when does that land?\".\n *\n * The comparison runs against a 1-second clock that starts only while something\n * is actually counting down and stops itself once the last ETA passes, so\n * `isRevoking` flips to `false` and `isFinalizable` to `true` on their own —\n * a finalize button gated on them enables itself without a refresh. That same\n * clock drives `secondsRemaining`, so a live countdown needs no timer of its\n * own.\n *\n * **Probe the granted selector set, not the active one.** A delegation stops\n * being enforced at its ETA but stays scheduled until someone finalizes, so\n * `useAreDelegationsActive`'s `activeSelectors` goes empty precisely when\n * `isFinalizable` should turn `true`. Feeding that shrinking list back in here\n * would disable a finalize button at the moment it becomes callable.\n *\n * The read is skipped entirely for an empty `selectors` list — there is nothing\n * to probe — unless `query.enabled` says otherwise.\n *\n * @param parameters - Account, delegate, probed selectors, optional chain and query overrides.\n * @returns Whether a revocation is pending, its ETA, the scheduled selectors, and the read's state.\n *\n * @example\n * ```tsx\n * const { isRevoking, etaTimestamp, isFinalizable } = usePendingRevocation({\n *   account: { addr: subAccount, isPartyB: false },\n *   delegate: sessionKeyAddress,\n *   selectors: grantedSelectors,\n * });\n *\n * if (isRevoking) return <p>Revoking — still live until {formatTime(etaTimestamp)}</p>;\n * return <button disabled={!isFinalizable}>Finalize revoke</button>;\n * ```\n */\nexport function usePendingRevocation(parameters: UsePendingRevocationParameters): UsePendingRevocationReturnType {\n  const config = useSymmioConfig(parameters);\n  const { account, delegate, selectors, chainId, query } = parameters;\n\n  const options = getPendingRevocationEtasQueryOptions(config, {\n    delegator: account,\n    delegate,\n    selectors,\n    chainId,\n    query: { ...query, enabled: query?.enabled ?? selectors.length > 0 },\n  });\n\n  const result = useQuery({\n    ...options,\n    queryFn: async () => {\n      try {\n        return await options.queryFn();\n      } catch (err) {\n        throw normalizeSymmError(err);\n      }\n    },\n  }) as UseQueryResult<GetPendingRevocationEtasReturnType, SymmioRequestError>;\n\n  const { data, isLoading, isError, error, refetch } = result;\n  const etas = data ?? NO_ETAS;\n\n  const revokingSelectors = useMemo(() => selectors.filter((selector) => etas.has(selector)), [selectors, etas]);\n  const etaTimestamp = useMemo(() => {\n    let latest: bigint | undefined;\n    for (const eta of etas.values()) if (latest === undefined || eta > latest) latest = eta;\n    return latest;\n  }, [etas]);\n\n  const [now, setNow] = useState(nowSeconds);\n\n  /**\n   * Re-key the clock on the deadline itself: it resyncs the moment a new ETA\n   * arrives (the read can resolve long after mount, leaving `now` stale), ticks\n   * only while that deadline is in the future, and clears itself once it\n   * passes — a scheduled-but-elapsed revocation never leaves a timer running.\n   */\n  useEffect(() => {\n    if (etaTimestamp === undefined) return;\n    setNow(nowSeconds());\n    if (etaTimestamp <= nowSeconds()) return;\n\n    const id = setInterval(() => {\n      const current = nowSeconds();\n      setNow(current);\n      if (current >= etaTimestamp) clearInterval(id);\n    }, 1000);\n    return () => clearInterval(id);\n  }, [etaTimestamp]);\n\n  return useMemo<UsePendingRevocationReturnType>(() => {\n    let isRevoking = false;\n    let allElapsed = etas.size > 0;\n    for (const eta of etas.values()) {\n      if (eta > now) {\n        isRevoking = true;\n        allElapsed = false;\n      }\n    }\n\n    return {\n      isRevoking,\n      etaTimestamp,\n      secondsRemaining: etaTimestamp === undefined ? undefined : Number(etaTimestamp > now ? etaTimestamp - now : 0n),\n      revokingSelectors,\n      isFinalizable: allElapsed,\n      isLoading,\n      isError,\n      error: error ?? null,\n      refetch,\n      query: result,\n    };\n  }, [etas, now, etaTimestamp, revokingSelectors, isLoading, isError, error, refetch, result]);\n}\n"],"mappings":";;;;;;;AA0FA,IAAM,oBAA8C,IAAI,IAAiB;AAGzE,SAAS,IAAqB;CAC5B,OAAO,OAAO,KAAK,MAAM,KAAK,IAAI,IAAI,GAAI,CAAC;AAC7C;AA4CA,SAAgB,EAAqB,GAA4E;CAC/G,IAAM,IAAS,EAAgB,CAAU,GACnC,EAAE,YAAS,aAAU,cAAW,YAAS,aAAU,GAEnD,IAAU,EAAqC,GAAQ;EAC3D,WAAW;EACX;EACA;EACA;EACA,OAAO;GAAE,GAAG;GAAO,SAAS,GAAO,WAAW,EAAU,SAAS;EAAE;CACrE,CAAC,GAEK,IAAS,EAAS;EACtB,GAAG;EACH,SAAS,YAAY;GACnB,IAAI;IACF,OAAO,MAAM,EAAQ,QAAQ;GAC/B,SAAS,GAAK;IACZ,MAAM,EAAmB,CAAG;GAC9B;EACF;CACF,CAAC,GAEK,EAAE,SAAM,cAAW,YAAS,UAAO,eAAY,GAC/C,IAAO,KAAQ,GAEf,IAAoB,QAAc,EAAU,QAAQ,MAAa,EAAK,IAAI,CAAQ,CAAC,GAAG,CAAC,GAAW,CAAI,CAAC,GACvG,IAAe,QAAc;EACjC,IAAI;EACJ,KAAK,IAAM,KAAO,EAAK,OAAO,GAAG,CAAI,MAAW,KAAA,KAAa,IAAM,OAAQ,IAAS;EACpF,OAAO;CACT,GAAG,CAAC,CAAI,CAAC,GAEH,CAAC,GAAK,KAAU,EAAS,CAAU;CAqBzC,OAbA,QAAgB;EAGd,IAFI,MAAiB,KAAA,MACrB,EAAO,EAAW,CAAC,GACf,KAAgB,EAAW,IAAG;EAElC,IAAM,IAAK,kBAAkB;GAC3B,IAAM,IAAU,EAAW;GAE3B,AADA,EAAO,CAAO,GACV,KAAW,KAAc,cAAc,CAAE;EAC/C,GAAG,GAAI;EACP,aAAa,cAAc,CAAE;CAC/B,GAAG,CAAC,CAAY,CAAC,GAEV,QAA8C;EACnD,IAAI,IAAa,IACb,IAAa,EAAK,OAAO;EAC7B,KAAK,IAAM,KAAO,EAAK,OAAO,GAC5B,AAAI,IAAM,MACR,IAAa,IACb,IAAa;EAIjB,OAAO;GACL;GACA;GACA,kBAAkB,MAAiB,KAAA,IAAY,KAAA,IAAY,OAAO,IAAe,IAAM,IAAe,IAAM,EAAE;GAC9G;GACA,eAAe;GACf;GACA;GACA,OAAO,KAAS;GAChB;GACA,OAAO;EACT;CACF,GAAG;EAAC;EAAM;EAAK;EAAc;EAAmB;EAAW;EAAS;EAAO;EAAS;CAAM,CAAC;AAC7F"}

package/dist/instant-layer/use-revocation-cooldown.d.ts

@@ -0,0 +1,24 @@
+import { ConfigParameter, GetRevocationCooldownOptions, GetRevocationCooldownReturnType } from '@symmio/trading-core';
+import { UseQueryResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error.js';
+/**
+ * Parameters for {@link useRevocationCooldown}: an optional chain id and
+ * TanStack `query` overrides, plus an optional `config`.
+ */
+export type UseRevocationCooldownParameters = GetRevocationCooldownOptions & ConfigParameter;
+/** Return type of {@link useRevocationCooldown}. */
+export type UseRevocationCooldownReturnType = UseQueryResult<GetRevocationCooldownReturnType, SymmioRequestError>;
+/**
+ * Read the Instant Layer's delegation revocation cooldown, in seconds.
+ *
+ * This is the delay between {@link useInitiateRevokeDelegation} and the moment
+ * the delegation stops being enforced — surface it so a UI can tell the user
+ * how long a revoked key stays live.
+ *
+ * @example
+ * ```tsx
+ * const { data: cooldownSeconds } = useRevocationCooldown();
+ * ```
+ */
+export declare function useRevocationCooldown(parameters?: UseRevocationCooldownParameters): UseRevocationCooldownReturnType;
+//# sourceMappingURL=use-revocation-cooldown.d.ts.map

package/dist/instant-layer/use-revocation-cooldown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-revocation-cooldown.d.ts","sourceRoot":"","sources":["../../src/instant-layer/use-revocation-cooldown.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,4BAA4B,EACjC,KAAK,+BAA+B,EACrC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAGzE;;;GAGG;AACH,MAAM,MAAM,+BAA+B,GAAG,4BAA4B,GAAG,eAAe,CAAC;AAE7F,oDAAoD;AACpD,MAAM,MAAM,+BAA+B,GAAG,cAAc,CAAC,+BAA+B,EAAE,kBAAkB,CAAC,CAAC;AAElH;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,GAAE,+BAAoC,GAC/C,+BAA+B,CAcjC"}

package/dist/instant-layer/use-revocation-cooldown.js

@@ -0,0 +1,23 @@
+"use client";
+import { useSymmioConfig as e } from "../provider/use-symmio-config.js";
+import { normalizeSymmError as t } from "../errors/normalize-symm-error.js";
+import { getRevocationCooldownQueryOptions as n } from "@symmio/trading-core";
+import { useQuery as r } from "@tanstack/react-query";
+//#region src/instant-layer/use-revocation-cooldown.ts
+function i(i = {}) {
+	let a = n(e(i), i);
+	return r({
+		...a,
+		queryFn: async () => {
+			try {
+				return await a.queryFn();
+			} catch (e) {
+				throw t(e);
+			}
+		}
+	});
+}
+//#endregion
+export { i as useRevocationCooldown };
+
+//# sourceMappingURL=use-revocation-cooldown.js.map

package/dist/instant-layer/use-revocation-cooldown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-revocation-cooldown.js","names":[],"sources":["../../src/instant-layer/use-revocation-cooldown.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getRevocationCooldownQueryOptions,\n  type ConfigParameter,\n  type GetRevocationCooldownOptions,\n  type GetRevocationCooldownReturnType,\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 { useSymmioConfig } from \"../provider/use-symmio-config\";\n\n/**\n * Parameters for {@link useRevocationCooldown}: an optional chain id and\n * TanStack `query` overrides, plus an optional `config`.\n */\nexport type UseRevocationCooldownParameters = GetRevocationCooldownOptions & ConfigParameter;\n\n/** Return type of {@link useRevocationCooldown}. */\nexport type UseRevocationCooldownReturnType = UseQueryResult<GetRevocationCooldownReturnType, SymmioRequestError>;\n\n/**\n * Read the Instant Layer's delegation revocation cooldown, in seconds.\n *\n * This is the delay between {@link useInitiateRevokeDelegation} and the moment\n * the delegation stops being enforced — surface it so a UI can tell the user\n * how long a revoked key stays live.\n *\n * @example\n * ```tsx\n * const { data: cooldownSeconds } = useRevocationCooldown();\n * ```\n */\nexport function useRevocationCooldown(\n  parameters: UseRevocationCooldownParameters = {},\n): UseRevocationCooldownReturnType {\n  const config = useSymmioConfig(parameters);\n  const options = getRevocationCooldownQueryOptions(config, parameters);\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 UseRevocationCooldownReturnType;\n}\n"],"mappings":";;;;;;AAkCA,SAAgB,EACd,IAA8C,CAAC,GACd;CAEjC,IAAM,IAAU,EADD,EAAgB,CACmB,GAAQ,CAAU;CAEpE,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/instant-layer/use-session-key-selectors.d.ts

@@ -0,0 +1,53 @@
+import { ConfigParameter, SessionKeySelectorScope } from '@symmio/trading-core';
+import { Hex } from 'viem';
+/** Parameters for {@link useSessionKeySelectors}: the target chain plus the authority scope. */
+export interface UseSessionKeySelectorsParameters extends ConfigParameter, SessionKeySelectorScope {
+    /** Chain to resolve the selector set for; defaults to the connected chain. */
+    chainId?: number;
+}
+/** Return type of {@link useSessionKeySelectors}: the de-duplicated selector set to grant. */
+export type UseSessionKeySelectorsReturnType = readonly Hex[];
+/**
+ * **The** selector set to hand a session key — the set to pass to
+ * `useGrantDelegation` (and to `useAreDelegationsActive` when checking whether
+ * that key is still usable). It resolves the chain's contracts generation, so a
+ * multi-chain app never grants the other generation's open-leg selector.
+ *
+ * The default scope is the onboarding grant: the instant trade lifecycle plus
+ * gasless account management. Because the contract enforces that
+ * `grantDelegation` is owner-only, that single grant is the *only* wallet
+ * prompt a session key ever costs — every write it covers afterwards is
+ * promptless and gas-free.
+ *
+ * `initiateWithdraw` is **opt-out by default** (`withdraw` defaults to
+ * `false`): its calldata carries a caller-supplied `receiver`, so a key holding
+ * it can send the sub-account's collateral to an address of its own choosing.
+ * Pass `withdraw: true` only for a key that must run withdrawals unattended,
+ * and treat it as a materially larger grant.
+ *
+ * The result is referentially stable across renders while the chain and scope
+ * flags do not change, so it is safe to pass straight into a mutation's
+ * variables or another hook's parameters.
+ *
+ * @param parameters - Optional chain override, scope flags, and `config`.
+ * @returns The lowercase, de-duplicated selector set for the requested scope.
+ * @throws {SymmError} `UNSUPPORTED_CHAIN` when the chain is not configured.
+ * @throws {SymmError} `GASLESS_UNSUPPORTED_CONTRACTS_VERSION` when the `account`
+ *   or `withdraw` scope is requested on a chain whose contracts are not
+ *   `"0.8.6"`. Render a trade-only key there with `{ account: false }`.
+ *
+ * @example
+ * ```tsx
+ * const selectors = useSessionKeySelectors();
+ * const { mutate } = useGrantDelegation();
+ * mutate({ account: { addr: subAccount, isPartyB: false }, delegatedSigner, selectors, expiryTimestamp });
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // A key that also withdraws unattended — it can move the collateral out.
+ * const selectors = useSessionKeySelectors({ withdraw: true });
+ * ```
+ */
+export declare function useSessionKeySelectors(parameters?: UseSessionKeySelectorsParameters): UseSessionKeySelectorsReturnType;
+//# sourceMappingURL=use-session-key-selectors.d.ts.map

package/dist/instant-layer/use-session-key-selectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-session-key-selectors.d.ts","sourceRoot":"","sources":["../../src/instant-layer/use-session-key-selectors.ts"],"names":[],"mappings":"AAEA,OAAO,EAA0B,KAAK,eAAe,EAAE,KAAK,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAElH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAIhC,gGAAgG;AAChG,MAAM,WAAW,gCAAiC,SAAQ,eAAe,EAAE,uBAAuB;IAChG,8EAA8E;IAC9E,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,8FAA8F;AAC9F,MAAM,MAAM,gCAAgC,GAAG,SAAS,GAAG,EAAE,CAAC;AAE9D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,GAAE,gCAAqC,GAChD,gCAAgC,CAUlC"}

package/dist/instant-layer/use-session-key-selectors.js

@@ -0,0 +1,25 @@
+"use client";
+import { useSymmioChainId as e } from "../provider/use-symmio-chain-id.js";
+import { useSymmioConfig as t } from "../provider/use-symmio-config.js";
+import { getSessionKeySelectors as n } from "@symmio/trading-core";
+import { useMemo as r } from "react";
+//#region src/instant-layer/use-session-key-selectors.ts
+function i(i = {}) {
+	let a = t(i), o = e(), { trade: s, account: c, withdraw: l } = i, u = i.chainId ?? o;
+	return r(() => n(a, {
+		chainId: u,
+		trade: s,
+		account: c,
+		withdraw: l
+	}), [
+		a,
+		u,
+		s,
+		c,
+		l
+	]);
+}
+//#endregion
+export { i as useSessionKeySelectors };
+
+//# sourceMappingURL=use-session-key-selectors.js.map

package/dist/instant-layer/use-session-key-selectors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-session-key-selectors.js","names":[],"sources":["../../src/instant-layer/use-session-key-selectors.ts"],"sourcesContent":["\"use client\";\n\nimport { getSessionKeySelectors, type ConfigParameter, type SessionKeySelectorScope } from \"@symmio/trading-core\";\nimport { useMemo } from \"react\";\nimport type { Hex } from \"viem\";\nimport { useSymmioChainId } from \"../provider/use-symmio-chain-id\";\nimport { useSymmioConfig } from \"../provider/use-symmio-config\";\n\n/** Parameters for {@link useSessionKeySelectors}: the target chain plus the authority scope. */\nexport interface UseSessionKeySelectorsParameters extends ConfigParameter, SessionKeySelectorScope {\n  /** Chain to resolve the selector set for; defaults to the connected chain. */\n  chainId?: number;\n}\n\n/** Return type of {@link useSessionKeySelectors}: the de-duplicated selector set to grant. */\nexport type UseSessionKeySelectorsReturnType = readonly Hex[];\n\n/**\n * **The** selector set to hand a session key — the set to pass to\n * `useGrantDelegation` (and to `useAreDelegationsActive` when checking whether\n * that key is still usable). It resolves the chain's contracts generation, so a\n * multi-chain app never grants the other generation's open-leg selector.\n *\n * The default scope is the onboarding grant: the instant trade lifecycle plus\n * gasless account management. Because the contract enforces that\n * `grantDelegation` is owner-only, that single grant is the *only* wallet\n * prompt a session key ever costs — every write it covers afterwards is\n * promptless and gas-free.\n *\n * `initiateWithdraw` is **opt-out by default** (`withdraw` defaults to\n * `false`): its calldata carries a caller-supplied `receiver`, so a key holding\n * it can send the sub-account's collateral to an address of its own choosing.\n * Pass `withdraw: true` only for a key that must run withdrawals unattended,\n * and treat it as a materially larger grant.\n *\n * The result is referentially stable across renders while the chain and scope\n * flags do not change, so it is safe to pass straight into a mutation's\n * variables or another hook's parameters.\n *\n * @param parameters - Optional chain override, scope flags, and `config`.\n * @returns The lowercase, de-duplicated selector set for the requested scope.\n * @throws {SymmError} `UNSUPPORTED_CHAIN` when the chain is not configured.\n * @throws {SymmError} `GASLESS_UNSUPPORTED_CONTRACTS_VERSION` when the `account`\n *   or `withdraw` scope is requested on a chain whose contracts are not\n *   `\"0.8.6\"`. Render a trade-only key there with `{ account: false }`.\n *\n * @example\n * ```tsx\n * const selectors = useSessionKeySelectors();\n * const { mutate } = useGrantDelegation();\n * mutate({ account: { addr: subAccount, isPartyB: false }, delegatedSigner, selectors, expiryTimestamp });\n * ```\n *\n * @example\n * ```tsx\n * // A key that also withdraws unattended — it can move the collateral out.\n * const selectors = useSessionKeySelectors({ withdraw: true });\n * ```\n */\nexport function useSessionKeySelectors(\n  parameters: UseSessionKeySelectorsParameters = {},\n): UseSessionKeySelectorsReturnType {\n  const config = useSymmioConfig(parameters);\n  const connectedChainId = useSymmioChainId();\n  const { trade, account, withdraw } = parameters;\n  const chainId = parameters.chainId ?? connectedChainId;\n\n  return useMemo(\n    () => getSessionKeySelectors(config, { chainId, trade, account, withdraw }),\n    [config, chainId, trade, account, withdraw],\n  );\n}\n"],"mappings":";;;;;;AA2DA,SAAgB,EACd,IAA+C,CAAC,GACd;CAClC,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAmB,EAAiB,GACpC,EAAE,UAAO,YAAS,gBAAa,GAC/B,IAAU,EAAW,WAAW;CAEtC,OAAO,QACC,EAAuB,GAAQ;EAAE;EAAS;EAAO;EAAS;CAAS,CAAC,GAC1E;EAAC;EAAQ;EAAS;EAAO;EAAS;CAAQ,CAC5C;AACF"}

package/dist/margin/use-available-instant-open-margin.js

@@ -6,8 +6,8 @@ import { useSubAccount as r } from "../account-layer/use-sub-account.js";
 import { useFeeForUser as i } from "../fees/use-fee-for-user.js";
 import { useAccountUpnl as a } from "../quotes/use-account-upnl.js";
 import { SubAccountIsolationType as o, calculateAvailableForOrder as s, calculateAvailableInstantOpenMargin as c } from "@symmio/trading-core";
-import { useCallback as l, useMemo as u } from "react";
-import { formatUnits as d, zeroAddress as f } from "viem";
+import { formatUnits as l, zeroAddress as u } from "viem";
+import { useCallback as d, useMemo as f } from "react";
 //#region src/margin/use-available-instant-open-margin.ts
 function p(e) {
 	return BigInt(Math.round(e * 0x2386f26fc10000));
@@ -18,7 +18,7 @@ function h(h) {
 		chainId: S,
 		solverId: x
 	}).id === "rasa", T = r({
-		account: g ?? f,
+		account: g ?? u,
 		chainId: S,
 		config: C,
 		query: {
@@ -32,7 +32,7 @@ function h(h) {
 		live: !0,
 		query: { enabled: D && !O }
 	}), A = i({
-		user: g ?? f,
+		user: g ?? u,
 		symbolId: _ ?? 0,
 		chainId: S,
 		config: C,
@@ -50,7 +50,7 @@ function h(h) {
 		config: C,
 		enabled: O,
 		live: !0
-	}), { data: N, isLoading: P, error: F, refetch: I } = k, { data: L, isLoading: R, error: z, refetch: B } = A, { data: V, isLoading: H, error: U, refetch: W } = j, { upnl: G, isLoading: K, refetch: q } = M, J = l(async () => {
+	}), { data: N, isLoading: P, error: F, refetch: I } = k, { data: L, isLoading: R, error: z, refetch: B } = A, { data: V, isLoading: H, error: U, refetch: W } = j, { upnl: G, isLoading: K, refetch: q } = M, J = d(async () => {
 		if (O) {
 			await Promise.all([W(), q()]);
 			return;
@@ -63,7 +63,7 @@ function h(h) {
 		W,
 		q
 	]);
-	return u(() => {
+	return f(() => {
 		let e = !!g && !D;
 		if (O) {
 			let e = H || K, t = U ?? null;
@@ -80,7 +80,7 @@ function h(h) {
 			}), r = n > 0n ? n : 0n, i = w ? r * m / 10000n : r;
 			return {
 				availableMarginWei: i,
-				availableMargin: d(i, 18),
+				availableMargin: l(i, 18),
 				isLoading: e,
 				error: t,
 				refetch: J
@@ -104,7 +104,7 @@ function h(h) {
 		});
 		return {
 			availableMarginWei: r,
-			availableMargin: d(r, 18),
+			availableMargin: l(r, 18),
 			isLoading: t,
 			error: n,
 			refetch: J

package/dist/markets/index.d.ts

@@ -1,3 +1,4 @@
+export * from './use-funding-fees-of-party-b.js';
 export * from './use-markets.js';
 export * from './use-onchain-contract-markets.js';
 //# sourceMappingURL=index.d.ts.map

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

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

package/dist/markets/index.js

@@ -1,3 +1,4 @@
 import { useMarkets as e } from "./use-markets.js";
-import { useOnchainContractMarkets as t } from "./use-onchain-contract-markets.js";
-export { e as useMarkets, t as useOnchainContractMarkets };
+import { useFundingFeesOfPartyB as t } from "./use-funding-fees-of-party-b.js";
+import { useOnchainContractMarkets as n } from "./use-onchain-contract-markets.js";
+export { t as useFundingFeesOfPartyB, e as useMarkets, n as useOnchainContractMarkets };

package/dist/markets/use-funding-fees-of-party-b.d.ts

@@ -0,0 +1,47 @@
+import { ConfigParameter, GetFundingFeesOfPartyBOptions, GetFundingFeesOfPartyBReturnType } from '@symmio/trading-core';
+import { UseQueryResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error.js';
+/**
+ * Parameters for {@link useFundingFeesOfPartyB}: the core query options (symbol
+ * id, partyB, chain id, TanStack `query` overrides) plus an optional `config`.
+ */
+export type UseFundingFeesOfPartyBParameters = GetFundingFeesOfPartyBOptions & ConfigParameter;
+/** Return type of {@link useFundingFeesOfPartyB}. */
+export type UseFundingFeesOfPartyBReturnType = UseQueryResult<GetFundingFeesOfPartyBReturnType, SymmioRequestError>;
+/**
+ * Read the accumulated-funding state a solver (partyB) keeps for one symbol —
+ * the SYMMIO core diamond's `FundingFee` struct: current and weighted-average
+ * rates, epoch tracking and carried-over fee snapshots.
+ *
+ * Values are the raw contract values: rates are **cost-positive** (a positive
+ * long/short value means that side pays), the opposite of the SDK's
+ * income-positive funding amounts. `epochDuration === 0n` means accumulated
+ * funding is not configured for the pair; `startEpoch === 0n` and
+ * `startEpochTimeStamp === 0n` with a duration set mean it is configured but has
+ * not started; otherwise the pair accrues — read the per-quote amount with
+ * {@link useQuotesPendingFunding}.
+ *
+ * Delegates to core's `getFundingFeesOfPartyB`. Does not poll by default; pass
+ * `query.refetchInterval` to keep it fresh. `chainId` defaults to the connected
+ * chain. Errors are normalized to {@link SymmioRequestError}.
+ *
+ * @param parameters - Symbol id, partyB, optional chain id, TanStack `query` overrides and `config`.
+ * @returns A TanStack query result holding the pair's `FundingFee` state.
+ *
+ * A quote only has a `partyB` once a solver has locked it, so read the pair off
+ * an on-chain quote (or the solver you target) and gate the query while it is
+ * still missing.
+ *
+ * @example
+ * ```tsx
+ * const { data: quote } = useQuote({ quoteId: 7334n });
+ * const { data: fee } = useFundingFeesOfPartyB({
+ *   symbolId: quote?.symbolId ?? 0n,
+ *   partyB: quote?.partyB ?? zeroAddress,
+ *   query: { enabled: quote !== undefined && quote !== null },
+ * });
+ * const accruing = fee !== undefined && fee.epochDuration > 0n && (fee.startEpoch !== 0n || fee.startEpochTimeStamp !== 0n);
+ * ```
+ */
+export declare function useFundingFeesOfPartyB(parameters: UseFundingFeesOfPartyBParameters): UseFundingFeesOfPartyBReturnType;
+//# sourceMappingURL=use-funding-fees-of-party-b.d.ts.map

package/dist/markets/use-funding-fees-of-party-b.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-funding-fees-of-party-b.d.ts","sourceRoot":"","sources":["../../src/markets/use-funding-fees-of-party-b.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,6BAA6B,EAClC,KAAK,gCAAgC,EACtC,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,gCAAgC,GAAG,6BAA6B,GAAG,eAAe,CAAC;AAE/F,qDAAqD;AACrD,MAAM,MAAM,gCAAgC,GAAG,cAAc,CAAC,gCAAgC,EAAE,kBAAkB,CAAC,CAAC;AAEpH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,gCAAgC,GAAG,gCAAgC,CAkBrH"}

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

package/dist/markets/use-funding-fees-of-party-b.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-funding-fees-of-party-b.js","names":[],"sources":["../../src/markets/use-funding-fees-of-party-b.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getFundingFeesOfPartyBQueryOptions,\n  type ConfigParameter,\n  type GetFundingFeesOfPartyBOptions,\n  type GetFundingFeesOfPartyBReturnType,\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 useFundingFeesOfPartyB}: the core query options (symbol\n * id, partyB, chain id, TanStack `query` overrides) plus an optional `config`.\n */\nexport type UseFundingFeesOfPartyBParameters = GetFundingFeesOfPartyBOptions & ConfigParameter;\n\n/** Return type of {@link useFundingFeesOfPartyB}. */\nexport type UseFundingFeesOfPartyBReturnType = UseQueryResult<GetFundingFeesOfPartyBReturnType, SymmioRequestError>;\n\n/**\n * Read the accumulated-funding state a solver (partyB) keeps for one symbol —\n * the SYMMIO core diamond's `FundingFee` struct: current and weighted-average\n * rates, epoch tracking and carried-over fee snapshots.\n *\n * Values are the raw contract values: rates are **cost-positive** (a positive\n * long/short value means that side pays), the opposite of the SDK's\n * income-positive funding amounts. `epochDuration === 0n` means accumulated\n * funding is not configured for the pair; `startEpoch === 0n` and\n * `startEpochTimeStamp === 0n` with a duration set mean it is configured but has\n * not started; otherwise the pair accrues — read the per-quote amount with\n * {@link useQuotesPendingFunding}.\n *\n * Delegates to core's `getFundingFeesOfPartyB`. Does not poll by default; pass\n * `query.refetchInterval` to keep it fresh. `chainId` defaults to the connected\n * chain. Errors are normalized to {@link SymmioRequestError}.\n *\n * @param parameters - Symbol id, partyB, optional chain id, TanStack `query` overrides and `config`.\n * @returns A TanStack query result holding the pair's `FundingFee` state.\n *\n * A quote only has a `partyB` once a solver has locked it, so read the pair off\n * an on-chain quote (or the solver you target) and gate the query while it is\n * still missing.\n *\n * @example\n * ```tsx\n * const { data: quote } = useQuote({ quoteId: 7334n });\n * const { data: fee } = useFundingFeesOfPartyB({\n *   symbolId: quote?.symbolId ?? 0n,\n *   partyB: quote?.partyB ?? zeroAddress,\n *   query: { enabled: quote !== undefined && quote !== null },\n * });\n * const accruing = fee !== undefined && fee.epochDuration > 0n && (fee.startEpoch !== 0n || fee.startEpochTimeStamp !== 0n);\n * ```\n */\nexport function useFundingFeesOfPartyB(parameters: UseFundingFeesOfPartyBParameters): UseFundingFeesOfPartyBReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n  const options = getFundingFeesOfPartyBQueryOptions(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 UseFundingFeesOfPartyBReturnType;\n}\n"],"mappings":";;;;;;;AA0DA,SAAgB,EAAuB,GAAgF;CACrH,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB,GAC3B,IAAU,EAAmC,GAAQ;EACzD,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/provider/create-session-key-wallet-client-resolver.d.ts

@@ -0,0 +1,68 @@
+import { GetWalletClientFn } from '@symmio/trading-core';
+import { Account, Transport } from 'viem';
+import { Config as WagmiConfig } from 'wagmi';
+/**
+ * Parameters for {@link createSessionKeyWalletClientResolver}.
+ */
+export interface CreateSessionKeyWalletClientResolverParameters {
+    /** Returns the session-key account to sign with, or null when no key is loaded. */
+    getSessionAccount: () => Account | null;
+    /** The wagmi config used to resolve the connected wallet and the target chain. */
+    wagmiConfig: WagmiConfig;
+    /** Optional per-chain transport override for the session-key client. Defaults to wagmi's transport for that chain. */
+    transport?: (chainId: number) => Transport;
+}
+/**
+ * Build a {@link GetWalletClientFn} that routes the SDK's `from` hint to a
+ * session-key signer, falling back to the wagmi-connected wallet.
+ *
+ * Pass the result as `SymmioProvider`'s `getWalletClient` prop. Every SDK write
+ * that can be relayed gaslessly asks the resolver for a signer and passes the
+ * `from` address it wants; with this resolver installed, a `from` that matches
+ * the loaded session key is signed in-memory with **no wallet prompt**, while
+ * any other `from` (typically the account owner) keeps using the connected
+ * wallet.
+ *
+ * The session-key client is bound to the transport the host configured in wagmi
+ * for that chain, so it uses the app's RPCs rather than viem's public defaults.
+ *
+ * Unlike the provider's default resolver, an unresolvable `from` is a loud
+ * error: it never falls back to prompting the connected wallet, because the
+ * owner is also authorized on-chain and the write would silently succeed with
+ * the wrong signer.
+ *
+ * The factory takes a `getSessionAccount` callback rather than a session-key
+ * manager on purpose — `@symmio/trading-react` must not depend on
+ * `@symmio/session-key`, and the callback is read fresh on every call so
+ * loading, rotating, or clearing the key needs no new resolver.
+ *
+ * @param parameters - See {@link CreateSessionKeyWalletClientResolverParameters}.
+ * @returns A resolver suitable for `SymmioProvider`'s `getWalletClient` prop.
+ * @throws {SymmError} `UNSUPPORTED_CHAIN` when the requested chain is not in the
+ *   wagmi config, `SESSION_SIGNER_UNAVAILABLE` when `from` matches neither the
+ *   loaded session key nor the connected wallet, and `NO_WALLET_CONNECTED` when
+ *   the fallback path finds no connected wallet.
+ *
+ * @example
+ * ```tsx
+ * function Providers({ children }: { children: ReactNode }) {
+ *   const wagmiConfig = useConfig();
+ *   const getWalletClient = useMemo(
+ *     () =>
+ *       createSessionKeyWalletClientResolver({
+ *         wagmiConfig,
+ *         getSessionAccount: () => sessionKeyManager.getAccount(),
+ *       }),
+ *     [wagmiConfig],
+ *   );
+ *
+ *   return (
+ *     <SymmioProvider symmioConfig={symmioConfig} getWalletClient={getWalletClient}>
+ *       {children}
+ *     </SymmioProvider>
+ *   );
+ * }
+ * ```
+ */
+export declare function createSessionKeyWalletClientResolver(parameters: CreateSessionKeyWalletClientResolverParameters): GetWalletClientFn;
+//# sourceMappingURL=create-session-key-wallet-client-resolver.d.ts.map

package/dist/provider/create-session-key-wallet-client-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-session-key-wallet-client-resolver.d.ts","sourceRoot":"","sources":["../../src/provider/create-session-key-wallet-client-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,iBAAiB,EAA2B,MAAM,sBAAsB,CAAC;AAClG,OAAO,EAAoC,KAAK,OAAO,EAA4B,KAAK,SAAS,EAAE,MAAM,MAAM,CAAC;AAChH,OAAO,KAAK,EAAE,MAAM,IAAI,WAAW,EAAE,MAAM,OAAO,CAAC;AAGnD;;GAEG;AACH,MAAM,WAAW,8CAA8C;IAC7D,mFAAmF;IACnF,iBAAiB,EAAE,MAAM,OAAO,GAAG,IAAI,CAAC;IACxC,kFAAkF;IAClF,WAAW,EAAE,WAAW,CAAC;IACzB,sHAAsH;IACtH,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,SAAS,CAAC;CAC5C;AA6FD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wBAAgB,oCAAoC,CAClD,UAAU,EAAE,8CAA8C,GACzD,iBAAiB,CAyBnB"}