@symmio/trading-react 3.0.0 → 3.1.0

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

package/dist/gasless/use-gasless-wallet-creation-fee.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-gasless-wallet-creation-fee.js","names":[],"sources":["../../src/gasless/use-gasless-wallet-creation-fee.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getGaslessWalletCreationFeeQueryOptions,\n  type ConfigParameter,\n  type GetGaslessWalletCreationFeeOptions,\n  type GetGaslessWalletCreationFeeReturnType,\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/** Parameters for {@link useGaslessWalletCreationFee}. */\nexport type UseGaslessWalletCreationFeeParameters = GetGaslessWalletCreationFeeOptions & ConfigParameter;\n\n/** Return type of {@link useGaslessWalletCreationFee}. */\nexport type UseGaslessWalletCreationFeeReturnType = UseQueryResult<\n  GetGaslessWalletCreationFeeReturnType,\n  SymmioRequestError\n>;\n\n/**\n * Read the one-time fee for deploying one of an owner's GaslessWallets\n * (`getWalletCreationFee(owner, walletId)` on the GaslessLayer), in collateral\n * token units. It is the configured fee while the wallet has no code, for any\n * wallet id including `0`, and `0n` once the wallet is deployed. A deposit\n * settlement deducts it from the swept balance; a relayed wallet operation\n * charges it to the payer's SYMMIO balance.\n *\n * The relay hooks invalidate it after a wallet execute or a deposit settlement,\n * since either may deploy the wallet.\n *\n * @param parameters - Owner, optional `walletId` (default `0n`), optional chain id, config and query overrides.\n * @returns The TanStack query result, with failures normalized to {@link SymmioRequestError}.\n *\n * @example\n * ```tsx\n * const creationFee = useGaslessWalletCreationFee({ owner, walletId: 1n });\n * const chargesFirstUse = (creationFee.data ?? 0n) > 0n;\n * ```\n */\nexport function useGaslessWalletCreationFee(\n  parameters: UseGaslessWalletCreationFeeParameters,\n): UseGaslessWalletCreationFeeReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n\n  const options = getGaslessWalletCreationFeeQueryOptions(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 UseGaslessWalletCreationFeeReturnType;\n}\n"],"mappings":";;;;;;;AA2CA,SAAgB,EACd,GACuC;CACvC,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB,GAE3B,IAAU,EAAwC,GAAQ;EAC9D,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/gasless/use-gasless-wallet-execute-selectors.d.ts

@@ -0,0 +1,44 @@
+import { GaslessWalletCall } from '@symmio/trading-core';
+import { Hex } from 'viem';
+/** Parameters for {@link useGaslessWalletExecuteSelectors}. */
+export interface UseGaslessWalletExecuteSelectorsParameters {
+    /**
+     * The batch the session key must be able to run. Pass `undefined` while the
+     * UI cannot yet describe one — the hook then returns an empty set rather
+     * than a partial grant.
+     */
+    calls?: readonly GaslessWalletCall[];
+}
+/** Return type of {@link useGaslessWalletExecuteSelectors}: the selector set to grant. */
+export type UseGaslessWalletExecuteSelectorsReturnType = readonly Hex[];
+/**
+ * The selector set a session key must hold before it may sign a delegated
+ * {@link useGaslessWalletExecute} batch: the wallet-execution sentinel plus
+ * every inner call's own selector.
+ *
+ * This is **not** the set {@link useSessionKeySelectors} returns. That one
+ * covers AccountLayer and trade writes; wallet execution is checked selector by
+ * selector against the batch itself, so a key onboarded for trading and account
+ * management still holds none of the authority this needs. Grant both sets to a
+ * key that does both.
+ *
+ * The delegation must be granted on a **sub-account**, never on the owner EOA:
+ * `grantDelegation` is owner-only and the AccountLayer knows no owner for a
+ * bare EOA. Pass that same sub-account as the execute call's `signerAccount`.
+ *
+ * The result keeps its reference while the selector set is unchanged, even
+ * though the batch is typically rebuilt on every keystroke, so it is safe to
+ * pass straight into `useAreDelegationsActive` or a mutation's variables.
+ *
+ * @param parameters - The batch to derive the grant from.
+ * @returns The lowercase, de-duplicated selector set, sentinel first.
+ *
+ * @example
+ * ```tsx
+ * const selectors = useGaslessWalletExecuteSelectors({ calls });
+ * const delegation = useAreDelegationsActive({ account, delegate: sessionKey, selectors });
+ * if (!delegation.isActive) await grant({ account, delegatedSigner: sessionKey, selectors, expiryTimestamp });
+ * ```
+ */
+export declare function useGaslessWalletExecuteSelectors(parameters?: UseGaslessWalletExecuteSelectorsParameters): UseGaslessWalletExecuteSelectorsReturnType;
+//# sourceMappingURL=use-gasless-wallet-execute-selectors.d.ts.map

package/dist/gasless/use-gasless-wallet-execute-selectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-gasless-wallet-execute-selectors.d.ts","sourceRoot":"","sources":["../../src/gasless/use-gasless-wallet-execute-selectors.ts"],"names":[],"mappings":"AACA,OAAO,EAAoC,KAAK,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAEhG,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAEhC,+DAA+D;AAC/D,MAAM,WAAW,0CAA0C;IACzD;;;;OAIG;IACH,KAAK,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACtC;AAED,0FAA0F;AAC1F,MAAM,MAAM,0CAA0C,GAAG,SAAS,GAAG,EAAE,CAAC;AAKxE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,gCAAgC,CAC9C,UAAU,GAAE,0CAA+C,GAC1D,0CAA0C,CAe5C"}

package/dist/gasless/use-gasless-wallet-execute-selectors.js

@@ -0,0 +1,19 @@
+"use client";
+import { getGaslessWalletExecuteSelectors as e } from "@symmio/trading-core";
+import { useRef as t } from "react";
+//#region src/gasless/use-gasless-wallet-execute-selectors.ts
+var n = [];
+function r(r = {}) {
+	let { calls: i } = r, a = i === void 0 || i.length === 0 ? n : e(i), o = a.join(","), s = t({
+		signature: o,
+		value: a
+	});
+	return s.current.signature !== o && (s.current = {
+		signature: o,
+		value: a
+	}), s.current.value;
+}
+//#endregion
+export { r as useGaslessWalletExecuteSelectors };
+
+//# sourceMappingURL=use-gasless-wallet-execute-selectors.js.map

package/dist/gasless/use-gasless-wallet-execute-selectors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-gasless-wallet-execute-selectors.js","names":[],"sources":["../../src/gasless/use-gasless-wallet-execute-selectors.ts"],"sourcesContent":["\"use client\";\nimport { getGaslessWalletExecuteSelectors, type GaslessWalletCall } from \"@symmio/trading-core\";\nimport { useRef } from \"react\";\nimport type { Hex } from \"viem\";\n\n/** Parameters for {@link useGaslessWalletExecuteSelectors}. */\nexport interface UseGaslessWalletExecuteSelectorsParameters {\n  /**\n   * The batch the session key must be able to run. Pass `undefined` while the\n   * UI cannot yet describe one — the hook then returns an empty set rather\n   * than a partial grant.\n   */\n  calls?: readonly GaslessWalletCall[];\n}\n\n/** Return type of {@link useGaslessWalletExecuteSelectors}: the selector set to grant. */\nexport type UseGaslessWalletExecuteSelectorsReturnType = readonly Hex[];\n\n/** Shared empty result, so \"no batch yet\" keeps one stable reference. */\nconst EMPTY_SELECTORS: readonly Hex[] = [];\n\n/**\n * The selector set a session key must hold before it may sign a delegated\n * {@link useGaslessWalletExecute} batch: the wallet-execution sentinel plus\n * every inner call's own selector.\n *\n * This is **not** the set {@link useSessionKeySelectors} returns. That one\n * covers AccountLayer and trade writes; wallet execution is checked selector by\n * selector against the batch itself, so a key onboarded for trading and account\n * management still holds none of the authority this needs. Grant both sets to a\n * key that does both.\n *\n * The delegation must be granted on a **sub-account**, never on the owner EOA:\n * `grantDelegation` is owner-only and the AccountLayer knows no owner for a\n * bare EOA. Pass that same sub-account as the execute call's `signerAccount`.\n *\n * The result keeps its reference while the selector set is unchanged, even\n * though the batch is typically rebuilt on every keystroke, so it is safe to\n * pass straight into `useAreDelegationsActive` or a mutation's variables.\n *\n * @param parameters - The batch to derive the grant from.\n * @returns The lowercase, de-duplicated selector set, sentinel first.\n *\n * @example\n * ```tsx\n * const selectors = useGaslessWalletExecuteSelectors({ calls });\n * const delegation = useAreDelegationsActive({ account, delegate: sessionKey, selectors });\n * if (!delegation.isActive) await grant({ account, delegatedSigner: sessionKey, selectors, expiryTimestamp });\n * ```\n */\nexport function useGaslessWalletExecuteSelectors(\n  parameters: UseGaslessWalletExecuteSelectorsParameters = {},\n): UseGaslessWalletExecuteSelectorsReturnType {\n  const { calls } = parameters;\n  const selectors =\n    calls === undefined || calls.length === 0 ? EMPTY_SELECTORS : getGaslessWalletExecuteSelectors(calls);\n  const signature = selectors.join(\",\");\n\n  /**\n   * Selectors are canonical lowercase `bytes4` hex, so their join is a faithful\n   * identity for the set. Holding the previous array while that identity is\n   * unchanged keeps a caller's query from refetching on every render.\n   */\n  const cache = useRef<{ signature: string; value: readonly Hex[] }>({ signature, value: selectors });\n  if (cache.current.signature !== signature) cache.current = { signature, value: selectors };\n\n  return cache.current.value;\n}\n"],"mappings":";;;;AAmBA,IAAM,IAAkC,CAAC;AA+BzC,SAAgB,EACd,IAAyD,CAAC,GACd;CAC5C,IAAM,EAAE,aAAU,GACZ,IACJ,MAAU,KAAA,KAAa,EAAM,WAAW,IAAI,IAAkB,EAAiC,CAAK,GAChG,IAAY,EAAU,KAAK,GAAG,GAO9B,IAAQ,EAAqD;EAAE;EAAW,OAAO;CAAU,CAAC;CAGlG,OAFI,EAAM,QAAQ,cAAc,MAAW,EAAM,UAAU;EAAE;EAAW,OAAO;CAAU,IAElF,EAAM,QAAQ;AACvB"}

package/dist/gasless/use-gasless-wallet-execute.d.ts

@@ -0,0 +1,51 @@
+import { GaslessWalletExecuteParameters, GaslessWalletExecuteReturnType } from '@symmio/trading-core';
+import { UseMutationResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error.js';
+import { GaslessRelayParameters, GaslessRelayProgress, GaslessRelayResult } from './gasless-relay-types.js';
+/** Parameters for {@link useGaslessWalletExecute}. */
+export type UseGaslessWalletExecuteParameters = GaslessRelayParameters;
+/** Mutation variables of {@link useGaslessWalletExecute}: the core action's parameters. */
+export type GaslessWalletExecuteVariables = GaslessWalletExecuteParameters;
+/** What {@link useGaslessWalletExecute} resolves with. */
+export type GaslessWalletExecuteResult = GaslessRelayResult<GaslessWalletExecuteReturnType>;
+/** Return type of {@link useGaslessWalletExecute}. */
+export type UseGaslessWalletExecuteReturnType = UseMutationResult<GaslessWalletExecuteResult, SymmioRequestError, GaslessWalletExecuteVariables> & {
+    /** Live relay progress — `queued` → `submitted` → `confirmed`. */
+    relay: GaslessRelayProgress;
+};
+/**
+ * Run **any contract call from the deterministic gasless wallet**, with no
+ * native gas — an atomic batch of arbitrary calls, each given either as raw
+ * `data` or as an `{ abi, functionName, args }` triple the SDK encodes.
+ *
+ * The wallet's own balance never pays the fee: the GaslessLayer prices the
+ * operation from the inner call selectors and charges the SYMMIO account,
+ * bounded by its operational-fee allowance. See `gaslessWalletExecute`.
+ *
+ * **Resolves when the operation has landed, not when the relayer accepts it.**
+ * A submit returns `202` in milliseconds while the transaction lands seconds
+ * later, so resolving on acceptance would resolve before the effect exists. By
+ * default this waits for the terminal `succeeded` and then for the receipt on
+ * your own client, then invalidates the reads below.
+ *
+ * Set `confirmation: "none"` to resolve on acceptance instead; you then own the
+ * polling and the invalidation. A non-succeeded terminal rejects with the
+ * record attached to the error's `responseData`.
+ *
+ * On success the wallet-operation nonce of the signer account, the wallet's
+ * collateral balance, the fee allowance, and the owner's deposit policy and
+ * wallet creation fee (a first use deploys the wallet) are invalidated.
+ *
+ * @example
+ * ```tsx
+ * const relay = useGaslessWalletExecute();
+ * const receipt = await relay.mutateAsync({
+ *   calls: [
+ *     { target: usdc, abi: erc20Abi, functionName: "approve", args: [router, amount] },
+ *     { target: router, data: routeCalldata },
+ *   ],
+ * });
+ * ```
+ */
+export declare function useGaslessWalletExecute(parameters?: UseGaslessWalletExecuteParameters): UseGaslessWalletExecuteReturnType;
+//# sourceMappingURL=use-gasless-wallet-execute.d.ts.map

package/dist/gasless/use-gasless-wallet-execute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-gasless-wallet-execute.d.ts","sourceRoot":"","sources":["../../src/gasless/use-gasless-wallet-execute.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,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;AAGzE,OAAO,KAAK,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAI9G,sDAAsD;AACtD,MAAM,MAAM,iCAAiC,GAAG,sBAAsB,CAAC;AAEvE,2FAA2F;AAC3F,MAAM,MAAM,6BAA6B,GAAG,8BAA8B,CAAC;AAE3E,0DAA0D;AAC1D,MAAM,MAAM,0BAA0B,GAAG,kBAAkB,CAAC,8BAA8B,CAAC,CAAC;AAE5F,sDAAsD;AACtD,MAAM,MAAM,iCAAiC,GAAG,iBAAiB,CAC/D,0BAA0B,EAC1B,kBAAkB,EAClB,6BAA6B,CAC9B,GAAG;IACF,kEAAkE;IAClE,KAAK,EAAE,oBAAoB,CAAC;CAC7B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,GAAE,iCAAsC,GACjD,iCAAiC,CA+CnC"}

package/dist/gasless/use-gasless-wallet-execute.js

@@ -0,0 +1,44 @@
+"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 { invalidateGaslessWalletExecuteReads as r } from "./invalidate-relay-reads.js";
+import { useGaslessRelayConfirmation as i } from "./use-gasless-relay-confirmation.js";
+import { gaslessWalletExecuteMutationOptions as a } from "@symmio/trading-core";
+import { useMutation as o } from "@tanstack/react-query";
+//#region src/gasless/use-gasless-wallet-execute.ts
+function s(s = {}) {
+	let c = t(s), l = e(), u = i(s, c), d = a(c), f = o({
+		...d,
+		mutationFn: async (e) => {
+			let t = e.chainId ?? l;
+			try {
+				let n = await u.submit(() => d.mutationFn({
+					...e,
+					chainId: t
+				}));
+				return {
+					accepted: n,
+					confirmed: await u.confirm(n, {
+						chainId: t,
+						service: "operations",
+						operationType: e.operationType,
+						invalidate: (n) => r(n, { configKey: c.getChainConfigKey(t) }, e)
+					})
+				};
+			} catch (e) {
+				throw n(e);
+			}
+		}
+	}), p = f.reset;
+	return Object.assign(f, {
+		relay: u.progress,
+		reset: () => {
+			u.reset(), p();
+		}
+	});
+}
+//#endregion
+export { s as useGaslessWalletExecute };
+
+//# sourceMappingURL=use-gasless-wallet-execute.js.map

package/dist/gasless/use-gasless-wallet-execute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-gasless-wallet-execute.js","names":[],"sources":["../../src/gasless/use-gasless-wallet-execute.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  gaslessWalletExecuteMutationOptions,\n  type GaslessWalletExecuteParameters,\n  type GaslessWalletExecuteReturnType,\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\";\nimport type { GaslessRelayParameters, GaslessRelayProgress, GaslessRelayResult } from \"./gasless-relay-types\";\nimport { invalidateGaslessWalletExecuteReads } from \"./invalidate-relay-reads\";\nimport { useGaslessRelayConfirmation } from \"./use-gasless-relay-confirmation\";\n\n/** Parameters for {@link useGaslessWalletExecute}. */\nexport type UseGaslessWalletExecuteParameters = GaslessRelayParameters;\n\n/** Mutation variables of {@link useGaslessWalletExecute}: the core action's parameters. */\nexport type GaslessWalletExecuteVariables = GaslessWalletExecuteParameters;\n\n/** What {@link useGaslessWalletExecute} resolves with. */\nexport type GaslessWalletExecuteResult = GaslessRelayResult<GaslessWalletExecuteReturnType>;\n\n/** Return type of {@link useGaslessWalletExecute}. */\nexport type UseGaslessWalletExecuteReturnType = UseMutationResult<\n  GaslessWalletExecuteResult,\n  SymmioRequestError,\n  GaslessWalletExecuteVariables\n> & {\n  /** Live relay progress — `queued` → `submitted` → `confirmed`. */\n  relay: GaslessRelayProgress;\n};\n\n/**\n * Run **any contract call from the deterministic gasless wallet**, with no\n * native gas — an atomic batch of arbitrary calls, each given either as raw\n * `data` or as an `{ abi, functionName, args }` triple the SDK encodes.\n *\n * The wallet's own balance never pays the fee: the GaslessLayer prices the\n * operation from the inner call selectors and charges the SYMMIO account,\n * bounded by its operational-fee allowance. See `gaslessWalletExecute`.\n *\n * **Resolves when the operation has landed, not when the relayer accepts it.**\n * A submit returns `202` in milliseconds while the transaction lands seconds\n * later, so resolving on acceptance would resolve before the effect exists. By\n * default this waits for the terminal `succeeded` and then for the receipt on\n * your own client, then invalidates the reads below.\n *\n * Set `confirmation: \"none\"` to resolve on acceptance instead; you then own the\n * polling and the invalidation. A non-succeeded terminal rejects with the\n * record attached to the error's `responseData`.\n *\n * On success the wallet-operation nonce of the signer account, the wallet's\n * collateral balance, the fee allowance, and the owner's deposit policy and\n * wallet creation fee (a first use deploys the wallet) are invalidated.\n *\n * @example\n * ```tsx\n * const relay = useGaslessWalletExecute();\n * const receipt = await relay.mutateAsync({\n *   calls: [\n *     { target: usdc, abi: erc20Abi, functionName: \"approve\", args: [router, amount] },\n *     { target: router, data: routeCalldata },\n *   ],\n * });\n * ```\n */\nexport function useGaslessWalletExecute(\n  parameters: UseGaslessWalletExecuteParameters = {},\n): UseGaslessWalletExecuteReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n  const confirmation = useGaslessRelayConfirmation(parameters, config);\n\n  const options = gaslessWalletExecuteMutationOptions(config);\n\n  const mutation = useMutation({\n    ...options,\n    mutationFn: async (variables: GaslessWalletExecuteVariables): Promise<GaslessWalletExecuteResult> => {\n      const resolvedChainId = variables.chainId ?? chainId;\n      try {\n        const accepted = await confirmation.submit(() =>\n          options.mutationFn({ ...variables, chainId: resolvedChainId }),\n        );\n        const confirmed = await confirmation.confirm(accepted, {\n          chainId: resolvedChainId,\n          service: \"operations\",\n          operationType: variables.operationType,\n          invalidate: (queryClient) =>\n            invalidateGaslessWalletExecuteReads(\n              queryClient,\n              { configKey: config.getChainConfigKey(resolvedChainId) },\n              variables,\n            ),\n        });\n        return { accepted, confirmed };\n      } catch (err) {\n        throw normalizeSymmError(err);\n      }\n    },\n  }) as UseMutationResult<GaslessWalletExecuteResult, SymmioRequestError, GaslessWalletExecuteVariables>;\n\n  /**\n   * Capture the observer's own `reset` before merging: `Object.assign` writes\n   * onto `mutation` itself, so a wrapper that called `mutation.reset()` would\n   * resolve to the wrapper and recurse until the stack blew.\n   */\n  const resetMutation = mutation.reset;\n\n  return Object.assign(mutation, {\n    relay: confirmation.progress,\n    reset: () => {\n      confirmation.reset();\n      resetMutation();\n    },\n  });\n}\n"],"mappings":";;;;;;;;;AAqEA,SAAgB,EACd,IAAgD,CAAC,GACd;CACnC,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB,GAC3B,IAAe,EAA4B,GAAY,CAAM,GAE7D,IAAU,EAAoC,CAAM,GAEpD,IAAW,EAAY;EAC3B,GAAG;EACH,YAAY,OAAO,MAAkF;GACnG,IAAM,IAAkB,EAAU,WAAW;GAC7C,IAAI;IACF,IAAM,IAAW,MAAM,EAAa,aAClC,EAAQ,WAAW;KAAE,GAAG;KAAW,SAAS;IAAgB,CAAC,CAC/D;IAYA,OAAO;KAAE;KAAU,WAAA,MAXK,EAAa,QAAQ,GAAU;MACrD,SAAS;MACT,SAAS;MACT,eAAe,EAAU;MACzB,aAAa,MACX,EACE,GACA,EAAE,WAAW,EAAO,kBAAkB,CAAe,EAAE,GACvD,CACF;KACJ,CAAC;IAC4B;GAC/B,SAAS,GAAK;IACZ,MAAM,EAAmB,CAAG;GAC9B;EACF;CACF,CAAC,GAOK,IAAgB,EAAS;CAE/B,OAAO,OAAO,OAAO,GAAU;EAC7B,OAAO,EAAa;EACpB,aAAa;GAEX,AADA,EAAa,MAAM,GACnB,EAAc;EAChB;CACF,CAAC;AACH"}

package/dist/gasless/use-gasless-wallet-nonce.d.ts

@@ -0,0 +1,27 @@
+import { ConfigParameter, GetGaslessWalletNonceOptions, GetGaslessWalletNonceReturnType } from '@symmio/trading-core';
+import { UseQueryResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error.js';
+/** Parameters for {@link useGaslessWalletNonce}. */
+export type UseGaslessWalletNonceParameters = GetGaslessWalletNonceOptions & ConfigParameter;
+/** Return type of {@link useGaslessWalletNonce}. */
+export type UseGaslessWalletNonceReturnType = UseQueryResult<GetGaslessWalletNonceReturnType, SymmioRequestError>;
+/**
+ * Read the GaslessLayer's wallet-operation replay nonce
+ * (`walletOperationNonces(owner, walletId, signerAccount)`) — the last nonce a
+ * GaslessWallet consumed for one signer account. Each `(walletId, account)` pair
+ * is its own stream, separate from InstantLayer nonces.
+ *
+ * Use it to display a wallet's state. Do not sign from a cached value:
+ * `useGaslessWalletExecute` reads the nonce itself immediately before signing,
+ * and invalidates this query once the operation lands.
+ *
+ * @param parameters - Owner, optional `walletId` (default `0n`), signer `account`, optional chain id, config and query overrides.
+ * @returns The TanStack query result, with failures normalized to {@link SymmioRequestError}.
+ *
+ * @example
+ * ```tsx
+ * const nonce = useGaslessWalletNonce({ owner, walletId: 1n, account: subAccount });
+ * ```
+ */
+export declare function useGaslessWalletNonce(parameters: UseGaslessWalletNonceParameters): UseGaslessWalletNonceReturnType;
+//# sourceMappingURL=use-gasless-wallet-nonce.d.ts.map

package/dist/gasless/use-gasless-wallet-nonce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-gasless-wallet-nonce.d.ts","sourceRoot":"","sources":["../../src/gasless/use-gasless-wallet-nonce.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;AAIzE,oDAAoD;AACpD,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;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,+BAA+B,GAAG,+BAA+B,CAmBlH"}

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

package/dist/gasless/use-gasless-wallet-nonce.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-gasless-wallet-nonce.js","names":[],"sources":["../../src/gasless/use-gasless-wallet-nonce.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getGaslessWalletNonceQueryOptions,\n  type ConfigParameter,\n  type GetGaslessWalletNonceOptions,\n  type GetGaslessWalletNonceReturnType,\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/** Parameters for {@link useGaslessWalletNonce}. */\nexport type UseGaslessWalletNonceParameters = GetGaslessWalletNonceOptions & ConfigParameter;\n\n/** Return type of {@link useGaslessWalletNonce}. */\nexport type UseGaslessWalletNonceReturnType = UseQueryResult<GetGaslessWalletNonceReturnType, SymmioRequestError>;\n\n/**\n * Read the GaslessLayer's wallet-operation replay nonce\n * (`walletOperationNonces(owner, walletId, signerAccount)`) — the last nonce a\n * GaslessWallet consumed for one signer account. Each `(walletId, account)` pair\n * is its own stream, separate from InstantLayer nonces.\n *\n * Use it to display a wallet's state. Do not sign from a cached value:\n * `useGaslessWalletExecute` reads the nonce itself immediately before signing,\n * and invalidates this query once the operation lands.\n *\n * @param parameters - Owner, optional `walletId` (default `0n`), signer `account`, optional chain id, config and query overrides.\n * @returns The TanStack query result, with failures normalized to {@link SymmioRequestError}.\n *\n * @example\n * ```tsx\n * const nonce = useGaslessWalletNonce({ owner, walletId: 1n, account: subAccount });\n * ```\n */\nexport function useGaslessWalletNonce(parameters: UseGaslessWalletNonceParameters): UseGaslessWalletNonceReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n\n  const options = getGaslessWalletNonceQueryOptions(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 UseGaslessWalletNonceReturnType;\n}\n"],"mappings":";;;;;;;AAsCA,SAAgB,EAAsB,GAA8E;CAClH,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB,GAE3B,IAAU,EAAkC,GAAQ;EACxD,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/gasless/use-operational-fee-allowance.d.ts

@@ -0,0 +1,23 @@
+import { ConfigParameter, GetOperationalFeeAllowanceOptions, GetOperationalFeeAllowanceReturnType } from '@symmio/trading-core';
+import { UseQueryResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error.js';
+/** Parameters for {@link useOperationalFeeAllowance}. */
+export type UseOperationalFeeAllowanceParameters = GetOperationalFeeAllowanceOptions & ConfigParameter;
+/** Return type of {@link useOperationalFeeAllowance}. */
+export type UseOperationalFeeAllowanceReturnType = UseQueryResult<GetOperationalFeeAllowanceReturnType, SymmioRequestError>;
+/**
+ * Read a payer's operational-fee allowance for the gasless charger from the
+ * SYMMIO core diamond. Allowance reductions can be delayed on-chain - surface
+ * `pendingAllowance` and `reductionReadyAt` in any revoke UX.
+ *
+ * The amounts are **18-decimal Core units**, like the Core balance the fee is
+ * drawn from. The allowance only caps the charge and adds no balance, so show
+ * it next to the payer's Core balance, never as spendable funds.
+ *
+ * @example
+ * ```tsx
+ * const query = useOperationalFeeAllowance({ payer });
+ * ```
+ */
+export declare function useOperationalFeeAllowance(parameters: UseOperationalFeeAllowanceParameters): UseOperationalFeeAllowanceReturnType;
+//# sourceMappingURL=use-operational-fee-allowance.d.ts.map

package/dist/gasless/use-operational-fee-allowance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-operational-fee-allowance.d.ts","sourceRoot":"","sources":["../../src/gasless/use-operational-fee-allowance.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,iCAAiC,EACtC,KAAK,oCAAoC,EAC1C,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAIzE,yDAAyD;AACzD,MAAM,MAAM,oCAAoC,GAAG,iCAAiC,GAAG,eAAe,CAAC;AAEvG,yDAAyD;AACzD,MAAM,MAAM,oCAAoC,GAAG,cAAc,CAC/D,oCAAoC,EACpC,kBAAkB,CACnB,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,oCAAoC,GAC/C,oCAAoC,CAmBtC"}

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

package/dist/gasless/use-operational-fee-allowance.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-operational-fee-allowance.js","names":[],"sources":["../../src/gasless/use-operational-fee-allowance.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getOperationalFeeAllowanceQueryOptions,\n  type ConfigParameter,\n  type GetOperationalFeeAllowanceOptions,\n  type GetOperationalFeeAllowanceReturnType,\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/** Parameters for {@link useOperationalFeeAllowance}. */\nexport type UseOperationalFeeAllowanceParameters = GetOperationalFeeAllowanceOptions & ConfigParameter;\n\n/** Return type of {@link useOperationalFeeAllowance}. */\nexport type UseOperationalFeeAllowanceReturnType = UseQueryResult<\n  GetOperationalFeeAllowanceReturnType,\n  SymmioRequestError\n>;\n\n/**\n * Read a payer's operational-fee allowance for the gasless charger from the\n * SYMMIO core diamond. Allowance reductions can be delayed on-chain - surface\n * `pendingAllowance` and `reductionReadyAt` in any revoke UX.\n *\n * The amounts are **18-decimal Core units**, like the Core balance the fee is\n * drawn from. The allowance only caps the charge and adds no balance, so show\n * it next to the payer's Core balance, never as spendable funds.\n *\n * @example\n * ```tsx\n * const query = useOperationalFeeAllowance({ payer });\n * ```\n */\nexport function useOperationalFeeAllowance(\n  parameters: UseOperationalFeeAllowanceParameters,\n): UseOperationalFeeAllowanceReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n\n  const options = getOperationalFeeAllowanceQueryOptions(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 UseOperationalFeeAllowanceReturnType;\n}\n"],"mappings":";;;;;;;AAqCA,SAAgB,EACd,GACsC;CACtC,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB,GAE3B,IAAU,EAAuC,GAAQ;EAC7D,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/gasless/use-relay-gasless-batch.d.ts

@@ -0,0 +1,48 @@
+import { RelayGaslessBatchParameters, RelayGaslessBatchReturnType } from '@symmio/trading-core';
+import { UseMutationResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error.js';
+import { GaslessRelayParameters, GaslessRelayProgress, GaslessRelayResult } from './gasless-relay-types.js';
+/** Parameters for {@link useRelayGaslessBatch}. */
+export type UseRelayGaslessBatchParameters = GaslessRelayParameters;
+/** Mutation variables of {@link useRelayGaslessBatch}: the core action's parameters. */
+export type RelayGaslessBatchVariables = RelayGaslessBatchParameters;
+/** What {@link useRelayGaslessBatch} resolves with. */
+export type RelayGaslessBatchResult = GaslessRelayResult<RelayGaslessBatchReturnType>;
+/** Return type of {@link useRelayGaslessBatch}. */
+export type UseRelayGaslessBatchReturnType = UseMutationResult<RelayGaslessBatchResult, SymmioRequestError, RelayGaslessBatchVariables> & {
+    /** Live relay progress — `queued` → `submitted` → `confirmed`. */
+    relay: GaslessRelayProgress;
+};
+/**
+ * Relay **several gasless actions as one request** — one atomic transaction,
+ * no native gas. Give relayable writes as `{ functionName, args }` (optional
+ * `abi`) or raw `{ data }`, and GaslessWallet calls as `{ walletCalls, walletId }`;
+ * see `relayGaslessBatch`.
+ *
+ * Every call is signed separately — the protocol has no batch signature — so
+ * a browser wallet shows one prompt per call, in order, while a session key
+ * (`from`) signs them silently. Nothing is submitted until every prompt is
+ * signed. Preview the same batch with {@link useGaslessBatchFeeQuote}.
+ *
+ * **Resolves when the batch has landed, not when the relayer accepts it.** By
+ * default this waits for the terminal `succeeded` and then for the receipt on
+ * your own client, then invalidates what the batch's calls changed — the
+ * account's nonce, balances and fee allowance always, plus the withdrawal,
+ * quote, sub-account, deposit, delegation and GaslessWallet reads of the calls
+ * it actually carried. Set `confirmation: "none"` to resolve on acceptance and
+ * own the polling and invalidation yourself.
+ *
+ * @example
+ * ```tsx
+ * const batch = useRelayGaslessBatch();
+ * await batch.mutateAsync({
+ *   account: subAccount,
+ *   calls: [
+ *     { functionName: "approveOperationalFeeWithMultiplier", args: [[gaslessLayer], [budget18], [10_000n]] },
+ *     { functionName: "allocate", args: [amount] },
+ *   ],
+ * });
+ * ```
+ */
+export declare function useRelayGaslessBatch(parameters?: UseRelayGaslessBatchParameters): UseRelayGaslessBatchReturnType;
+//# sourceMappingURL=use-relay-gasless-batch.d.ts.map

package/dist/gasless/use-relay-gasless-batch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-relay-gasless-batch.d.ts","sourceRoot":"","sources":["../../src/gasless/use-relay-gasless-batch.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,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;AAGzE,OAAO,KAAK,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAI9G,mDAAmD;AACnD,MAAM,MAAM,8BAA8B,GAAG,sBAAsB,CAAC;AAEpE,wFAAwF;AACxF,MAAM,MAAM,0BAA0B,GAAG,2BAA2B,CAAC;AAErE,uDAAuD;AACvD,MAAM,MAAM,uBAAuB,GAAG,kBAAkB,CAAC,2BAA2B,CAAC,CAAC;AAEtF,mDAAmD;AACnD,MAAM,MAAM,8BAA8B,GAAG,iBAAiB,CAC5D,uBAAuB,EACvB,kBAAkB,EAClB,0BAA0B,CAC3B,GAAG;IACF,kEAAkE;IAClE,KAAK,EAAE,oBAAoB,CAAC;CAC7B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,GAAE,8BAAmC,GAAG,8BAA8B,CA+CpH"}

package/dist/gasless/use-relay-gasless-batch.js

@@ -0,0 +1,44 @@
+"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 { invalidateGaslessBatchReads as r } from "./invalidate-relay-reads.js";
+import { useGaslessRelayConfirmation as i } from "./use-gasless-relay-confirmation.js";
+import { relayGaslessBatchMutationOptions as a } from "@symmio/trading-core";
+import { useMutation as o } from "@tanstack/react-query";
+//#region src/gasless/use-relay-gasless-batch.ts
+function s(s = {}) {
+	let c = t(s), l = e(), u = i(s, c), d = a(c), f = o({
+		...d,
+		mutationFn: async (e) => {
+			let t = e.chainId ?? l;
+			try {
+				let n = await u.submit(() => d.mutationFn({
+					...e,
+					chainId: t
+				}));
+				return {
+					accepted: n,
+					confirmed: await u.confirm(n, {
+						chainId: t,
+						service: "operations",
+						operationType: e.operationType,
+						invalidate: (n) => r(n, { configKey: c.getChainConfigKey(t) }, e)
+					})
+				};
+			} catch (e) {
+				throw n(e);
+			}
+		}
+	}), p = f.reset;
+	return Object.assign(f, {
+		relay: u.progress,
+		reset: () => {
+			u.reset(), p();
+		}
+	});
+}
+//#endregion
+export { s as useRelayGaslessBatch };
+
+//# sourceMappingURL=use-relay-gasless-batch.js.map

package/dist/gasless/use-relay-gasless-batch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-relay-gasless-batch.js","names":[],"sources":["../../src/gasless/use-relay-gasless-batch.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  relayGaslessBatchMutationOptions,\n  type RelayGaslessBatchParameters,\n  type RelayGaslessBatchReturnType,\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\";\nimport type { GaslessRelayParameters, GaslessRelayProgress, GaslessRelayResult } from \"./gasless-relay-types\";\nimport { invalidateGaslessBatchReads } from \"./invalidate-relay-reads\";\nimport { useGaslessRelayConfirmation } from \"./use-gasless-relay-confirmation\";\n\n/** Parameters for {@link useRelayGaslessBatch}. */\nexport type UseRelayGaslessBatchParameters = GaslessRelayParameters;\n\n/** Mutation variables of {@link useRelayGaslessBatch}: the core action's parameters. */\nexport type RelayGaslessBatchVariables = RelayGaslessBatchParameters;\n\n/** What {@link useRelayGaslessBatch} resolves with. */\nexport type RelayGaslessBatchResult = GaslessRelayResult<RelayGaslessBatchReturnType>;\n\n/** Return type of {@link useRelayGaslessBatch}. */\nexport type UseRelayGaslessBatchReturnType = UseMutationResult<\n  RelayGaslessBatchResult,\n  SymmioRequestError,\n  RelayGaslessBatchVariables\n> & {\n  /** Live relay progress — `queued` → `submitted` → `confirmed`. */\n  relay: GaslessRelayProgress;\n};\n\n/**\n * Relay **several gasless actions as one request** — one atomic transaction,\n * no native gas. Give relayable writes as `{ functionName, args }` (optional\n * `abi`) or raw `{ data }`, and GaslessWallet calls as `{ walletCalls, walletId }`;\n * see `relayGaslessBatch`.\n *\n * Every call is signed separately — the protocol has no batch signature — so\n * a browser wallet shows one prompt per call, in order, while a session key\n * (`from`) signs them silently. Nothing is submitted until every prompt is\n * signed. Preview the same batch with {@link useGaslessBatchFeeQuote}.\n *\n * **Resolves when the batch has landed, not when the relayer accepts it.** By\n * default this waits for the terminal `succeeded` and then for the receipt on\n * your own client, then invalidates what the batch's calls changed — the\n * account's nonce, balances and fee allowance always, plus the withdrawal,\n * quote, sub-account, deposit, delegation and GaslessWallet reads of the calls\n * it actually carried. Set `confirmation: \"none\"` to resolve on acceptance and\n * own the polling and invalidation yourself.\n *\n * @example\n * ```tsx\n * const batch = useRelayGaslessBatch();\n * await batch.mutateAsync({\n *   account: subAccount,\n *   calls: [\n *     { functionName: \"approveOperationalFeeWithMultiplier\", args: [[gaslessLayer], [budget18], [10_000n]] },\n *     { functionName: \"allocate\", args: [amount] },\n *   ],\n * });\n * ```\n */\nexport function useRelayGaslessBatch(parameters: UseRelayGaslessBatchParameters = {}): UseRelayGaslessBatchReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n  const confirmation = useGaslessRelayConfirmation(parameters, config);\n\n  const options = relayGaslessBatchMutationOptions(config);\n\n  const mutation = useMutation({\n    ...options,\n    mutationFn: async (variables: RelayGaslessBatchVariables): Promise<RelayGaslessBatchResult> => {\n      const resolvedChainId = variables.chainId ?? chainId;\n      try {\n        const accepted = await confirmation.submit(() =>\n          options.mutationFn({ ...variables, chainId: resolvedChainId }),\n        );\n        const confirmed = await confirmation.confirm(accepted, {\n          chainId: resolvedChainId,\n          service: \"operations\",\n          operationType: variables.operationType,\n          invalidate: (queryClient) =>\n            invalidateGaslessBatchReads(\n              queryClient,\n              { configKey: config.getChainConfigKey(resolvedChainId) },\n              variables,\n            ),\n        });\n        return { accepted, confirmed };\n      } catch (err) {\n        throw normalizeSymmError(err);\n      }\n    },\n  }) as UseMutationResult<RelayGaslessBatchResult, SymmioRequestError, RelayGaslessBatchVariables>;\n\n  /**\n   * Capture the observer's own `reset` before merging: `Object.assign` writes\n   * onto `mutation` itself, so a wrapper that called `mutation.reset()` would\n   * resolve to the wrapper and recurse until the stack blew.\n   */\n  const resetMutation = mutation.reset;\n\n  return Object.assign(mutation, {\n    relay: confirmation.progress,\n    reset: () => {\n      confirmation.reset();\n      resetMutation();\n    },\n  });\n}\n"],"mappings":";;;;;;;;;AAkEA,SAAgB,EAAqB,IAA6C,CAAC,GAAmC;CACpH,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB,GAC3B,IAAe,EAA4B,GAAY,CAAM,GAE7D,IAAU,EAAiC,CAAM,GAEjD,IAAW,EAAY;EAC3B,GAAG;EACH,YAAY,OAAO,MAA4E;GAC7F,IAAM,IAAkB,EAAU,WAAW;GAC7C,IAAI;IACF,IAAM,IAAW,MAAM,EAAa,aAClC,EAAQ,WAAW;KAAE,GAAG;KAAW,SAAS;IAAgB,CAAC,CAC/D;IAYA,OAAO;KAAE;KAAU,WAAA,MAXK,EAAa,QAAQ,GAAU;MACrD,SAAS;MACT,SAAS;MACT,eAAe,EAAU;MACzB,aAAa,MACX,EACE,GACA,EAAE,WAAW,EAAO,kBAAkB,CAAe,EAAE,GACvD,CACF;KACJ,CAAC;IAC4B;GAC/B,SAAS,GAAK;IACZ,MAAM,EAAmB,CAAG;GAC9B;EACF;CACF,CAAC,GAOK,IAAgB,EAAS;CAE/B,OAAO,OAAO,OAAO,GAAU;EAC7B,OAAO,EAAa;EACpB,aAAa;GAEX,AADA,EAAa,MAAM,GACnB,EAAc;EAChB;CACF,CAAC;AACH"}

package/dist/gasless/use-relay-instant-operations.d.ts

@@ -0,0 +1,43 @@
+import { RelayInstantOperationsParameters, RelayInstantOperationsReturnType } from '@symmio/trading-core';
+import { UseMutationResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error.js';
+import { GaslessRelayParameters, GaslessRelayProgress, GaslessRelayResult } from './gasless-relay-types.js';
+/** Parameters for {@link useRelayInstantOperations}. */
+export type UseRelayInstantOperationsParameters = GaslessRelayParameters;
+/** Mutation variables of {@link useRelayInstantOperations}: the core action's parameters. */
+export type RelayInstantOperationsVariables = RelayInstantOperationsParameters;
+/** What {@link useRelayInstantOperations} resolves with. */
+export type RelayInstantOperationsResult = GaslessRelayResult<RelayInstantOperationsReturnType>;
+/** Return type of {@link useRelayInstantOperations}. */
+export type UseRelayInstantOperationsReturnType = UseMutationResult<RelayInstantOperationsResult, SymmioRequestError, RelayInstantOperationsVariables> & {
+    /** Live relay progress — `queued` → `submitted` → `confirmed`. */
+    relay: GaslessRelayProgress;
+};
+/**
+ * Submit pre-signed InstantLayer operations to the GaslessQ relayer - the
+ * explicit escape hatch under the transparent gasless execution mode.
+ *
+ * **Resolves when the operation has landed, not when the relayer accepts it.**
+ * A submit returns `202` in milliseconds while the transaction lands seconds
+ * later, so resolving on acceptance would resolve before the effect exists. By
+ * default this waits for the terminal `succeeded` and then for the receipt on
+ * your own client, then invalidates the reads below.
+ *
+ * Set `confirmation: "none"` to resolve on acceptance instead; you then own the
+ * polling and the invalidation. A non-succeeded terminal rejects with the
+ * record attached to the error's `responseData`.
+ *
+ * Only transport-level reads are invalidated — the InstantLayer nonce, the
+ * operational-fee allowance and account balances. `operationType` is a
+ * free-form label the fee policy ignores, so the SDK cannot know which domain
+ * reads a batch touched and must not guess: pass your own `onSuccess` to
+ * `mutate`, which now runs after confirmation.
+ *
+ * @example
+ * ```tsx
+ * const relay = useRelayInstantOperations();
+ * const receipt = await relay.mutateAsync({ userAddress, operationType, operations });
+ * ```
+ */
+export declare function useRelayInstantOperations(parameters?: UseRelayInstantOperationsParameters): UseRelayInstantOperationsReturnType;
+//# sourceMappingURL=use-relay-instant-operations.d.ts.map

package/dist/gasless/use-relay-instant-operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-relay-instant-operations.d.ts","sourceRoot":"","sources":["../../src/gasless/use-relay-instant-operations.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,gCAAgC,EACrC,KAAK,gCAAgC,EACtC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAe,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAE5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAGzE,OAAO,KAAK,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAI9G,wDAAwD;AACxD,MAAM,MAAM,mCAAmC,GAAG,sBAAsB,CAAC;AAEzE,6FAA6F;AAC7F,MAAM,MAAM,+BAA+B,GAAG,gCAAgC,CAAC;AAE/E,4DAA4D;AAC5D,MAAM,MAAM,4BAA4B,GAAG,kBAAkB,CAAC,gCAAgC,CAAC,CAAC;AAEhG,wDAAwD;AACxD,MAAM,MAAM,mCAAmC,GAAG,iBAAiB,CACjE,4BAA4B,EAC5B,kBAAkB,EAClB,+BAA+B,CAChC,GAAG;IACF,kEAAkE;IAClE,KAAK,EAAE,oBAAoB,CAAC;CAC7B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,yBAAyB,CACvC,UAAU,GAAE,mCAAwC,GACnD,mCAAmC,CA+CrC"}

package/dist/gasless/use-relay-instant-operations.js

@@ -0,0 +1,44 @@
+"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 { invalidateRelayInstantOperationsReads as r } from "./invalidate-relay-reads.js";
+import { useGaslessRelayConfirmation as i } from "./use-gasless-relay-confirmation.js";
+import { relayInstantOperationsMutationOptions as a } from "@symmio/trading-core";
+import { useMutation as o } from "@tanstack/react-query";
+//#region src/gasless/use-relay-instant-operations.ts
+function s(s = {}) {
+	let c = t(s), l = e(), u = i(s, c), d = a(c), f = o({
+		...d,
+		mutationFn: async (e) => {
+			let t = e.chainId ?? l;
+			try {
+				let n = await u.submit(() => d.mutationFn({
+					...e,
+					chainId: t
+				}));
+				return {
+					accepted: n,
+					confirmed: await u.confirm(n, {
+						chainId: t,
+						service: "operations",
+						operationType: e.operationType,
+						invalidate: (n) => r(n, { configKey: c.getChainConfigKey(t) }, e.operations.map((e) => e.operation.signerAccount.addr))
+					})
+				};
+			} catch (e) {
+				throw n(e);
+			}
+		}
+	}), p = f.reset;
+	return Object.assign(f, {
+		relay: u.progress,
+		reset: () => {
+			u.reset(), p();
+		}
+	});
+}
+//#endregion
+export { s as useRelayInstantOperations };
+
+//# sourceMappingURL=use-relay-instant-operations.js.map

package/dist/gasless/use-relay-instant-operations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-relay-instant-operations.js","names":[],"sources":["../../src/gasless/use-relay-instant-operations.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  relayInstantOperationsMutationOptions,\n  type RelayInstantOperationsParameters,\n  type RelayInstantOperationsReturnType,\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\";\nimport type { GaslessRelayParameters, GaslessRelayProgress, GaslessRelayResult } from \"./gasless-relay-types\";\nimport { invalidateRelayInstantOperationsReads } from \"./invalidate-relay-reads\";\nimport { useGaslessRelayConfirmation } from \"./use-gasless-relay-confirmation\";\n\n/** Parameters for {@link useRelayInstantOperations}. */\nexport type UseRelayInstantOperationsParameters = GaslessRelayParameters;\n\n/** Mutation variables of {@link useRelayInstantOperations}: the core action's parameters. */\nexport type RelayInstantOperationsVariables = RelayInstantOperationsParameters;\n\n/** What {@link useRelayInstantOperations} resolves with. */\nexport type RelayInstantOperationsResult = GaslessRelayResult<RelayInstantOperationsReturnType>;\n\n/** Return type of {@link useRelayInstantOperations}. */\nexport type UseRelayInstantOperationsReturnType = UseMutationResult<\n  RelayInstantOperationsResult,\n  SymmioRequestError,\n  RelayInstantOperationsVariables\n> & {\n  /** Live relay progress — `queued` → `submitted` → `confirmed`. */\n  relay: GaslessRelayProgress;\n};\n\n/**\n * Submit pre-signed InstantLayer operations to the GaslessQ relayer - the\n * explicit escape hatch under the transparent gasless execution mode.\n *\n * **Resolves when the operation has landed, not when the relayer accepts it.**\n * A submit returns `202` in milliseconds while the transaction lands seconds\n * later, so resolving on acceptance would resolve before the effect exists. By\n * default this waits for the terminal `succeeded` and then for the receipt on\n * your own client, then invalidates the reads below.\n *\n * Set `confirmation: \"none\"` to resolve on acceptance instead; you then own the\n * polling and the invalidation. A non-succeeded terminal rejects with the\n * record attached to the error's `responseData`.\n *\n * Only transport-level reads are invalidated — the InstantLayer nonce, the\n * operational-fee allowance and account balances. `operationType` is a\n * free-form label the fee policy ignores, so the SDK cannot know which domain\n * reads a batch touched and must not guess: pass your own `onSuccess` to\n * `mutate`, which now runs after confirmation.\n *\n * @example\n * ```tsx\n * const relay = useRelayInstantOperations();\n * const receipt = await relay.mutateAsync({ userAddress, operationType, operations });\n * ```\n */\nexport function useRelayInstantOperations(\n  parameters: UseRelayInstantOperationsParameters = {},\n): UseRelayInstantOperationsReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n  const confirmation = useGaslessRelayConfirmation(parameters, config);\n\n  const options = relayInstantOperationsMutationOptions(config);\n\n  const mutation = useMutation({\n    ...options,\n    mutationFn: async (variables: RelayInstantOperationsVariables): Promise<RelayInstantOperationsResult> => {\n      const resolvedChainId = variables.chainId ?? chainId;\n      try {\n        const accepted = await confirmation.submit(() =>\n          options.mutationFn({ ...variables, chainId: resolvedChainId }),\n        );\n        const confirmed = await confirmation.confirm(accepted, {\n          chainId: resolvedChainId,\n          service: \"operations\",\n          operationType: variables.operationType,\n          invalidate: (queryClient) =>\n            invalidateRelayInstantOperationsReads(\n              queryClient,\n              { configKey: config.getChainConfigKey(resolvedChainId) },\n              variables.operations.map((entry) => entry.operation.signerAccount.addr),\n            ),\n        });\n        return { accepted, confirmed };\n      } catch (err) {\n        throw normalizeSymmError(err);\n      }\n    },\n  }) as UseMutationResult<RelayInstantOperationsResult, SymmioRequestError, RelayInstantOperationsVariables>;\n\n  /**\n   * Capture the observer's own `reset` before merging: `Object.assign` writes\n   * onto `mutation` itself, so a wrapper that called `mutation.reset()` would\n   * resolve to the wrapper and recurse until the stack blew.\n   */\n  const resetMutation = mutation.reset;\n\n  return Object.assign(mutation, {\n    relay: confirmation.progress,\n    reset: () => {\n      confirmation.reset();\n      resetMutation();\n    },\n  });\n}\n"],"mappings":";;;;;;;;;AA6DA,SAAgB,EACd,IAAkD,CAAC,GACd;CACrC,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB,GAC3B,IAAe,EAA4B,GAAY,CAAM,GAE7D,IAAU,EAAsC,CAAM,GAEtD,IAAW,EAAY;EAC3B,GAAG;EACH,YAAY,OAAO,MAAsF;GACvG,IAAM,IAAkB,EAAU,WAAW;GAC7C,IAAI;IACF,IAAM,IAAW,MAAM,EAAa,aAClC,EAAQ,WAAW;KAAE,GAAG;KAAW,SAAS;IAAgB,CAAC,CAC/D;IAYA,OAAO;KAAE;KAAU,WAAA,MAXK,EAAa,QAAQ,GAAU;MACrD,SAAS;MACT,SAAS;MACT,eAAe,EAAU;MACzB,aAAa,MACX,EACE,GACA,EAAE,WAAW,EAAO,kBAAkB,CAAe,EAAE,GACvD,EAAU,WAAW,KAAK,MAAU,EAAM,UAAU,cAAc,IAAI,CACxE;KACJ,CAAC;IAC4B;GAC/B,SAAS,GAAK;IACZ,MAAM,EAAmB,CAAG;GAC9B;EACF;CACF,CAAC,GAOK,IAAgB,EAAS;CAE/B,OAAO,OAAO,OAAO,GAAU;EAC7B,OAAO,EAAa;EACpB,aAAa;GAEX,AADA,EAAa,MAAM,GACnB,EAAc;EAChB;CACF,CAAC;AACH"}