@symmio/trading-core 3.0.0 → 3.1.0

package/dist/gasless/relay-gasless-batch/sign-gasless-batch.d.ts

@@ -0,0 +1,36 @@
+import { Hex } from 'viem';
+import { Config, SymmioWalletClient } from '../../core/config/index.js';
+import { SignedOperation } from '../../solvers/instant-open/shared/types.js';
+import { ResolvedGaslessBatchEntry } from '../batch/resolve-gasless-batch.js';
+/** Input of {@link signGaslessBatchOperations}. @internal */
+export interface SignGaslessBatchOperationsParameters {
+    /** The chain the batch relays on. */
+    chainId: number;
+    /** The wallet client that signs every operation. */
+    walletClient: SymmioWalletClient;
+    /** The resolved entries, in relay order — they decide each operation's signing domain. */
+    entries: readonly ResolvedGaslessBatchEntry[];
+    /** The operations to sign, aligned with `entries`. */
+    operations: readonly SignedOperation[];
+}
+/**
+ * Sign every operation of a batch, one EIP-712 prompt each, in relay order.
+ *
+ * The protocol has no batch signature: the InstantLayer verifies each
+ * operation's signature against that operation alone. Two domains are in play:
+ *
+ * - a relayable write signs the InstantLayer's seven-field `SignedOperation`
+ *   under the `SymmioInstantLayer` domain;
+ * - a GaslessWallet entry signs the **five-field** gateway struct (no
+ *   `flexFields`, no `maxUses`) under the `GaslessGateway` domain, whose
+ *   verifying contract is the GaslessLayer.
+ *
+ * The prompts run one after the other, so a rejected prompt stops the batch
+ * before anything is submitted.
+ *
+ * @returns One signature per operation, aligned with `operations`.
+ *
+ * @internal
+ */
+export declare function signGaslessBatchOperations(config: Config, parameters: SignGaslessBatchOperationsParameters): Promise<Hex[]>;
+//# sourceMappingURL=sign-gasless-batch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sign-gasless-batch.d.ts","sourceRoot":"","sources":["../../../src/gasless/relay-gasless-batch/sign-gasless-batch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAmB,MAAM,MAAM,CAAC;AACjD,OAAO,KAAK,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEpE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAC/E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAGhF,6DAA6D;AAC7D,MAAM,WAAW,oCAAoC;IACnD,qCAAqC;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,oDAAoD;IACpD,YAAY,EAAE,kBAAkB,CAAC;IACjC,0FAA0F;IAC1F,OAAO,EAAE,SAAS,yBAAyB,EAAE,CAAC;IAC9C,sDAAsD;IACtD,UAAU,EAAE,SAAS,eAAe,EAAE,CAAC;CACxC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,0BAA0B,CAC9C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,oCAAoC,GAC/C,OAAO,CAAC,GAAG,EAAE,CAAC,CA8BhB"}

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

@@ -0,0 +1,24 @@
+import { getInstantLayerEip712Domain as e, signSignedOperation as t } from "../../solvers/instant-open/shared/eip712.js";
+import { GASLESS_WALLET_OPERATION_TYPES as n, getGaslessGatewayEip712Domain as r } from "../eip712.js";
+//#region src/gasless/relay-gasless-batch/sign-gasless-batch.ts
+async function i(i, a) {
+	let { chainId: o, walletClient: s, entries: c, operations: l } = a, u, d, f = [];
+	for (let [a, p] of l.entries()) c[a]?.type === "wallet" ? (d ??= r(i, { chainId: o }), f.push(await s.signTypedData({
+		account: s.account,
+		domain: d,
+		types: n,
+		primaryType: "SignedOperation",
+		message: {
+			signer: p.signer,
+			target: p.target,
+			callData: p.callData,
+			signerAccount: p.signerAccount,
+			replayAttackHeader: p.replayAttackHeader
+		}
+	}))) : (u ??= e(i, { chainId: o }), f.push(await t(p, u, s)));
+	return f;
+}
+//#endregion
+export { i as signGaslessBatchOperations };
+
+//# sourceMappingURL=sign-gasless-batch.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sign-gasless-batch.js","names":[],"sources":["../../../src/gasless/relay-gasless-batch/sign-gasless-batch.ts"],"sourcesContent":["import type { Hex, TypedDataDomain } from \"viem\";\nimport type { Config, SymmioWalletClient } from \"../../core/config\";\nimport { getInstantLayerEip712Domain, signSignedOperation } from \"../../solvers/instant-open/shared/eip712\";\nimport type { SignedOperation } from \"../../solvers/instant-open/shared/types\";\nimport type { ResolvedGaslessBatchEntry } from \"../batch/resolve-gasless-batch\";\nimport { GASLESS_WALLET_OPERATION_TYPES, getGaslessGatewayEip712Domain } from \"../eip712\";\n\n/** Input of {@link signGaslessBatchOperations}. @internal */\nexport interface SignGaslessBatchOperationsParameters {\n  /** The chain the batch relays on. */\n  chainId: number;\n  /** The wallet client that signs every operation. */\n  walletClient: SymmioWalletClient;\n  /** The resolved entries, in relay order — they decide each operation's signing domain. */\n  entries: readonly ResolvedGaslessBatchEntry[];\n  /** The operations to sign, aligned with `entries`. */\n  operations: readonly SignedOperation[];\n}\n\n/**\n * Sign every operation of a batch, one EIP-712 prompt each, in relay order.\n *\n * The protocol has no batch signature: the InstantLayer verifies each\n * operation's signature against that operation alone. Two domains are in play:\n *\n * - a relayable write signs the InstantLayer's seven-field `SignedOperation`\n *   under the `SymmioInstantLayer` domain;\n * - a GaslessWallet entry signs the **five-field** gateway struct (no\n *   `flexFields`, no `maxUses`) under the `GaslessGateway` domain, whose\n *   verifying contract is the GaslessLayer.\n *\n * The prompts run one after the other, so a rejected prompt stops the batch\n * before anything is submitted.\n *\n * @returns One signature per operation, aligned with `operations`.\n *\n * @internal\n */\nexport async function signGaslessBatchOperations(\n  config: Config,\n  parameters: SignGaslessBatchOperationsParameters,\n): Promise<Hex[]> {\n  const { chainId, walletClient, entries, operations } = parameters;\n  let instantDomain: TypedDataDomain | undefined;\n  let gatewayDomain: TypedDataDomain | undefined;\n\n  const signatures: Hex[] = [];\n  for (const [index, operation] of operations.entries()) {\n    if (entries[index]?.type === \"wallet\") {\n      gatewayDomain ??= getGaslessGatewayEip712Domain(config, { chainId });\n      signatures.push(\n        await walletClient.signTypedData({\n          account: walletClient.account,\n          domain: gatewayDomain,\n          types: GASLESS_WALLET_OPERATION_TYPES,\n          primaryType: \"SignedOperation\",\n          message: {\n            signer: operation.signer,\n            target: operation.target,\n            callData: operation.callData,\n            signerAccount: operation.signerAccount,\n            replayAttackHeader: operation.replayAttackHeader,\n          },\n        }),\n      );\n    } else {\n      instantDomain ??= getInstantLayerEip712Domain(config, { chainId });\n      signatures.push(await signSignedOperation(operation, instantDomain, walletClient));\n    }\n  }\n  return signatures;\n}\n"],"mappings":";;;AAsCA,eAAsB,EACpB,GACA,GACgB;CAChB,IAAM,EAAE,YAAS,iBAAc,YAAS,kBAAe,GACnD,GACA,GAEE,IAAoB,CAAC;CAC3B,KAAK,IAAM,CAAC,GAAO,MAAc,EAAW,QAAQ,GAClD,AAAI,EAAQ,IAAQ,SAAS,YAC3B,MAAkB,EAA8B,GAAQ,EAAE,WAAQ,CAAC,GACnE,EAAW,KACT,MAAM,EAAa,cAAc;EAC/B,SAAS,EAAa;EACtB,QAAQ;EACR,OAAO;EACP,aAAa;EACb,SAAS;GACP,QAAQ,EAAU;GAClB,QAAQ,EAAU;GAClB,UAAU,EAAU;GACpB,eAAe,EAAU;GACzB,oBAAoB,EAAU;EAChC;CACF,CAAC,CACH,MAEA,MAAkB,EAA4B,GAAQ,EAAE,WAAQ,CAAC,GACjE,EAAW,KAAK,MAAM,EAAoB,GAAW,GAAe,CAAY,CAAC;CAGrF,OAAO;AACT"}

package/dist/gasless/relay-grant-delegation/index.d.ts

@@ -0,0 +1,3 @@
+export * from './query.js';
+export * from './relay-grant-delegation.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/gasless/relay-grant-delegation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/gasless/relay-grant-delegation/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,0BAA0B,CAAC"}

package/dist/gasless/relay-grant-delegation/query.d.ts

@@ -0,0 +1,18 @@
+import { Config } from '../../core/config/index.js';
+import { RelayGrantDelegationParameters, RelayGrantDelegationReturnType } from './relay-grant-delegation.js';
+/**
+ * Build TanStack Mutation options for {@link relayGrantDelegation}.
+ *
+ * @param config - The SDK config.
+ * @returns Options to pass to `useMutation`.
+ *
+ * @example
+ * ```ts
+ * useMutation(relayGrantDelegationMutationOptions(config));
+ * ```
+ */
+export declare function relayGrantDelegationMutationOptions(config: Config): {
+    mutationKey: readonly ["relayGrantDelegation"];
+    mutationFn: (variables: RelayGrantDelegationParameters) => Promise<RelayGrantDelegationReturnType>;
+};
+//# sourceMappingURL=query.d.ts.map

package/dist/gasless/relay-grant-delegation/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../src/gasless/relay-grant-delegation/query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAEL,KAAK,8BAA8B,EACnC,KAAK,8BAA8B,EACpC,MAAM,0BAA0B,CAAC;AAElC;;;;;;;;;;GAUG;AACH,wBAAgB,mCAAmC,CAAC,MAAM,EAAE,MAAM;;4BAGtC,8BAA8B,KAAG,OAAO,CAAC,8BAA8B,CAAC;EAGnG"}

package/dist/gasless/relay-grant-delegation/query.js

@@ -0,0 +1,12 @@
+import { relayGrantDelegation as e } from "./relay-grant-delegation.js";
+//#region src/gasless/relay-grant-delegation/query.ts
+function t(t) {
+	return {
+		mutationKey: ["relayGrantDelegation"],
+		mutationFn: (n) => e(t, n)
+	};
+}
+//#endregion
+export { t as relayGrantDelegationMutationOptions };
+
+//# sourceMappingURL=query.js.map

package/dist/gasless/relay-grant-delegation/query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.js","names":[],"sources":["../../../src/gasless/relay-grant-delegation/query.ts"],"sourcesContent":["import type { Config } from \"../../core/config\";\nimport {\n  relayGrantDelegation,\n  type RelayGrantDelegationParameters,\n  type RelayGrantDelegationReturnType,\n} from \"./relay-grant-delegation\";\n\n/**\n * Build TanStack Mutation options for {@link relayGrantDelegation}.\n *\n * @param config - The SDK config.\n * @returns Options to pass to `useMutation`.\n *\n * @example\n * ```ts\n * useMutation(relayGrantDelegationMutationOptions(config));\n * ```\n */\nexport function relayGrantDelegationMutationOptions(config: Config) {\n  return {\n    mutationKey: [\"relayGrantDelegation\"] as const,\n    mutationFn: (variables: RelayGrantDelegationParameters): Promise<RelayGrantDelegationReturnType> =>\n      relayGrantDelegation(config, variables),\n  };\n}\n"],"mappings":";;AAkBA,SAAgB,EAAoC,GAAgB;CAClE,OAAO;EACL,aAAa,CAAC,sBAAsB;EACpC,aAAa,MACX,EAAqB,GAAQ,CAAS;CAC1C;AACF"}

package/dist/gasless/relay-grant-delegation/relay-grant-delegation.d.ts

@@ -0,0 +1,69 @@
+import { Address, Hex } from 'viem';
+import { Config } from '../../core/config/index.js';
+import { ChainIdParameter, Compute, FromParameter } from '../../shared/types/properties.js';
+import { GaslessSubmitReceipt } from '../types.js';
+/**
+ * Parameters for {@link relayGrantDelegation}.
+ */
+export type RelayGrantDelegationParameters = Compute<ChainIdParameter & FromParameter & {
+    /**
+     * The sub-account granting the delegation. The account **owner's** wallet
+     * signs the operation — a delegation grant is always owner-signed.
+     */
+    account: Address;
+    /** The signer being delegated to (e.g. a session key address). */
+    delegatedSigner: Address;
+    /** Function selectors the delegate may sign for. */
+    selectors: readonly Hex[];
+    /** Unix timestamp (seconds) when the delegation expires. */
+    expiryTimestamp: bigint;
+}>;
+/** Return type of {@link relayGrantDelegation}. */
+export type RelayGrantDelegationReturnType = GaslessSubmitReceipt;
+/**
+ * Grant an Instant Layer delegation **through the gasless relayer** — no
+ * native gas needed.
+ *
+ * **Prefer `grantDelegation` with `gasless: true`.** A grant is a relayable
+ * write, so the ordinary action relays it and returns a transaction hash, with
+ * no separate code path and no separate result shape. This stays as the
+ * low-level escape hatch, for when you want the `requestId` and the fee figures
+ * off the acceptance receipt — the same relationship `relayInstantOperations`
+ * has with the transparent path.
+ *
+ * A delegation grant is an ordinary owner-signed InstantLayer operation:
+ * `grantDelegation(DelegationInfo)` calldata targeting the InstantLayer,
+ * signed under the InstantLayer EIP-712 domain with a fresh sequential nonce,
+ * submitted through `relay-instant`. (The old standalone delegation-relay
+ * endpoint and `SignedDelegation` payload no longer exist.) Combine with
+ * `GASLESS_SESSION_KEY_SELECTORS` to onboard a session key that can then sign
+ * gasless account management without further wallet prompts.
+ *
+ * Fire-and-forget like every relay: persist the returned `requestId` and poll
+ * `getGaslessRequest` (or `waitForGaslessRequest`) to a terminal status. The
+ * wallet-paid alternative is the plain `grantDelegation` write.
+ *
+ * The idempotency key is minted per call and is not a parameter: every call
+ * signs a fresh operation, so one key can only ever describe one signature.
+ * Replaying a submit whose response was lost is `resubmitGaslessRequest`'s job.
+ *
+ * @param config - The SDK config (must have a `getWalletClient` resolver).
+ * @param parameters - Delegation fields, optional chain id / signer override.
+ * @returns The acceptance receipt; persist `requestId` immediately.
+ * @throws {SymmError} `GASLESS_NOT_CONFIGURED` / `GASLESS_UNSUPPORTED_CONTRACTS_VERSION`.
+ * @throws {SymmApiError} `GASLESS_RELAY_SUBMIT_FAILED` on HTTP failure.
+ * @throws {SymmApiError} `GASLESS_SUBMIT_UNCONFIRMED` when the outcome could not be
+ *   established; replay it with `resubmitGaslessRequest` rather than signing a new grant.
+ *
+ * @example
+ * ```ts
+ * const receipt = await relayGrantDelegation(config, {
+ *   account: subAccount,
+ *   delegatedSigner: sessionKeyAddress,
+ *   selectors: GASLESS_SESSION_KEY_SELECTORS,
+ *   expiryTimestamp: BigInt(Math.floor(Date.now() / 1000) + 30 * 24 * 3600),
+ * });
+ * ```
+ */
+export declare function relayGrantDelegation(config: Config, parameters: RelayGrantDelegationParameters): Promise<RelayGrantDelegationReturnType>;
+//# sourceMappingURL=relay-grant-delegation.d.ts.map

package/dist/gasless/relay-grant-delegation/relay-grant-delegation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-grant-delegation.d.ts","sourceRoot":"","sources":["../../../src/gasless/relay-grant-delegation/relay-grant-delegation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,MAAM,CAAC;AAClE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAa9F,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAErD;;GAEG;AACH,MAAM,MAAM,8BAA8B,GAAG,OAAO,CAClD,gBAAgB,GACd,aAAa,GAAG;IACd;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB,kEAAkE;IAClE,eAAe,EAAE,OAAO,CAAC;IACzB,oDAAoD;IACpD,SAAS,EAAE,SAAS,GAAG,EAAE,CAAC;IAC1B,4DAA4D;IAC5D,eAAe,EAAE,MAAM,CAAC;CACzB,CACJ,CAAC;AAEF,mDAAmD;AACnD,MAAM,MAAM,8BAA8B,GAAG,oBAAoB,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,8BAA8B,GACzC,OAAO,CAAC,8BAA8B,CAAC,CAqDzC"}

package/dist/gasless/relay-grant-delegation/relay-grant-delegation.js

@@ -0,0 +1,57 @@
+import { instantLayerAbi as e } from "../../symmio-contracts/abi/v0.8.6/instant-layer.js";
+import { getInstantLayerEip712Domain as t, signSignedOperation as n } from "../../solvers/instant-open/shared/eip712.js";
+import { buildSignedOperation as r } from "../../solvers/instant-open/shared/operations.js";
+import { getInstantLayerNonce as i } from "../../symmio-contracts/instant-layer/actions/get-instant-layer-nonce.js";
+import { blocksGaslessNonceStream as a, gaslessInstantNonceStreamKey as o, readGaslessStreamNonce as s, submitOnGaslessNonceStream as c, withGaslessNonceLock as l } from "../nonce-lock.js";
+import { relayInstantOperations as u } from "../relay-instant-operations/relay-instant-operations.js";
+import { encodeFunctionData as d } from "viem";
+//#region src/gasless/relay-grant-delegation/relay-grant-delegation.ts
+async function f(f, p) {
+	let { chainId: m, account: h, delegatedSigner: g, selectors: _, expiryTimestamp: v, from: y } = p, b = f.getChainConfig(m), x = await f.getWalletClient({
+		chainId: m,
+		from: y
+	}), S = t(f, { chainId: m }), C = d({
+		abi: e,
+		functionName: "grantDelegation",
+		args: [{
+			account: {
+				addr: h,
+				isPartyB: !1
+			},
+			delegatedSigner: g,
+			selectors: [..._],
+			expiryTimestamp: v
+		}]
+	}), w = o(b.chainId, h);
+	return l(f, w, async () => {
+		let e = await s(f, w, () => i(f, {
+			chainId: m,
+			account: h
+		})), t = BigInt(Math.floor(Date.now() / 1e3) + 1200), o = r({
+			signer: x.account.address,
+			target: b.addresses.instantLayerAddress,
+			callData: C,
+			signerAccount: h,
+			deadline: t,
+			nonce: e + 1n
+		}), l = await n(o, S, x);
+		return c(f, w, {
+			signedNonce: e + 1n,
+			service: "operations",
+			chainId: b.chainId,
+			deadline: t
+		}, () => u(f, {
+			chainId: m,
+			userAddress: x.account.address,
+			operationType: "grantDelegation",
+			operations: [{
+				operation: o,
+				signature: l
+			}]
+		}), a);
+	});
+}
+//#endregion
+export { f as relayGrantDelegation };
+
+//# sourceMappingURL=relay-grant-delegation.js.map

package/dist/gasless/relay-grant-delegation/relay-grant-delegation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-grant-delegation.js","names":[],"sources":["../../../src/gasless/relay-grant-delegation/relay-grant-delegation.ts"],"sourcesContent":["import { encodeFunctionData, type Address, type Hex } from \"viem\";\nimport type { Config } from \"../../core/config\";\nimport type { ChainIdParameter, Compute, FromParameter } from \"../../shared/types/properties\";\nimport { getInstantLayerEip712Domain, signSignedOperation } from \"../../solvers/instant-open/shared/eip712\";\nimport { buildSignedOperation } from \"../../solvers/instant-open/shared/operations\";\nimport { instantLayerAbi } from \"../../symmio-contracts/abi/v0.8.6/instant-layer\";\nimport { getInstantLayerNonce } from \"../../symmio-contracts/instant-layer/actions/get-instant-layer-nonce\";\nimport {\n  blocksGaslessNonceStream,\n  gaslessInstantNonceStreamKey,\n  readGaslessStreamNonce,\n  submitOnGaslessNonceStream,\n  withGaslessNonceLock,\n} from \"../nonce-lock\";\nimport { relayInstantOperations } from \"../relay-instant-operations/relay-instant-operations\";\nimport type { GaslessSubmitReceipt } from \"../types\";\n\n/**\n * Parameters for {@link relayGrantDelegation}.\n */\nexport type RelayGrantDelegationParameters = Compute<\n  ChainIdParameter &\n    FromParameter & {\n      /**\n       * The sub-account granting the delegation. The account **owner's** wallet\n       * signs the operation — a delegation grant is always owner-signed.\n       */\n      account: Address;\n      /** The signer being delegated to (e.g. a session key address). */\n      delegatedSigner: Address;\n      /** Function selectors the delegate may sign for. */\n      selectors: readonly Hex[];\n      /** Unix timestamp (seconds) when the delegation expires. */\n      expiryTimestamp: bigint;\n    }\n>;\n\n/** Return type of {@link relayGrantDelegation}. */\nexport type RelayGrantDelegationReturnType = GaslessSubmitReceipt;\n\n/**\n * Grant an Instant Layer delegation **through the gasless relayer** — no\n * native gas needed.\n *\n * **Prefer `grantDelegation` with `gasless: true`.** A grant is a relayable\n * write, so the ordinary action relays it and returns a transaction hash, with\n * no separate code path and no separate result shape. This stays as the\n * low-level escape hatch, for when you want the `requestId` and the fee figures\n * off the acceptance receipt — the same relationship `relayInstantOperations`\n * has with the transparent path.\n *\n * A delegation grant is an ordinary owner-signed InstantLayer operation:\n * `grantDelegation(DelegationInfo)` calldata targeting the InstantLayer,\n * signed under the InstantLayer EIP-712 domain with a fresh sequential nonce,\n * submitted through `relay-instant`. (The old standalone delegation-relay\n * endpoint and `SignedDelegation` payload no longer exist.) Combine with\n * `GASLESS_SESSION_KEY_SELECTORS` to onboard a session key that can then sign\n * gasless account management without further wallet prompts.\n *\n * Fire-and-forget like every relay: persist the returned `requestId` and poll\n * `getGaslessRequest` (or `waitForGaslessRequest`) to a terminal status. The\n * wallet-paid alternative is the plain `grantDelegation` write.\n *\n * The idempotency key is minted per call and is not a parameter: every call\n * signs a fresh operation, so one key can only ever describe one signature.\n * Replaying a submit whose response was lost is `resubmitGaslessRequest`'s job.\n *\n * @param config - The SDK config (must have a `getWalletClient` resolver).\n * @param parameters - Delegation fields, optional chain id / signer override.\n * @returns The acceptance receipt; persist `requestId` immediately.\n * @throws {SymmError} `GASLESS_NOT_CONFIGURED` / `GASLESS_UNSUPPORTED_CONTRACTS_VERSION`.\n * @throws {SymmApiError} `GASLESS_RELAY_SUBMIT_FAILED` on HTTP failure.\n * @throws {SymmApiError} `GASLESS_SUBMIT_UNCONFIRMED` when the outcome could not be\n *   established; replay it with `resubmitGaslessRequest` rather than signing a new grant.\n *\n * @example\n * ```ts\n * const receipt = await relayGrantDelegation(config, {\n *   account: subAccount,\n *   delegatedSigner: sessionKeyAddress,\n *   selectors: GASLESS_SESSION_KEY_SELECTORS,\n *   expiryTimestamp: BigInt(Math.floor(Date.now() / 1000) + 30 * 24 * 3600),\n * });\n * ```\n */\nexport async function relayGrantDelegation(\n  config: Config,\n  parameters: RelayGrantDelegationParameters,\n): Promise<RelayGrantDelegationReturnType> {\n  const { chainId, account, delegatedSigner, selectors, expiryTimestamp, from } = parameters;\n\n  const chain = config.getChainConfig(chainId);\n  const walletClient = await config.getWalletClient({ chainId, from });\n  const domain = getInstantLayerEip712Domain(config, { chainId });\n\n  const callData = encodeFunctionData({\n    abi: instantLayerAbi,\n    functionName: \"grantDelegation\",\n    args: [\n      {\n        account: { addr: account, isPartyB: false },\n        delegatedSigner,\n        selectors: [...selectors],\n        expiryTimestamp,\n      },\n    ],\n  });\n\n  const streamKey = gaslessInstantNonceStreamKey(chain.chainId, account);\n\n  return withGaslessNonceLock(config, streamKey, async () => {\n    const currentNonce = await readGaslessStreamNonce(config, streamKey, () =>\n      getInstantLayerNonce(config, { chainId, account }),\n    );\n    const deadline = BigInt(Math.floor(Date.now() / 1000) + 20 * 60);\n\n    const operation = buildSignedOperation({\n      signer: walletClient.account.address,\n      target: chain.addresses.instantLayerAddress,\n      callData,\n      signerAccount: account,\n      deadline,\n      nonce: currentNonce + 1n,\n    });\n    const signature = await signSignedOperation(operation, domain, walletClient);\n\n    return submitOnGaslessNonceStream(\n      config,\n      streamKey,\n      { signedNonce: currentNonce + 1n, service: \"operations\", chainId: chain.chainId, deadline },\n      () =>\n        relayInstantOperations(config, {\n          chainId,\n          userAddress: walletClient.account.address,\n          operationType: \"grantDelegation\",\n          /** A delegation grant is an ordinary InstantLayer operation: wallet 0. */\n          operations: [{ operation, signature }],\n        }),\n      blocksGaslessNonceStream,\n    );\n  });\n}\n"],"mappings":";;;;;;;;AAqFA,eAAsB,EACpB,GACA,GACyC;CACzC,IAAM,EAAE,YAAS,YAAS,oBAAiB,cAAW,oBAAiB,YAAS,GAE1E,IAAQ,EAAO,eAAe,CAAO,GACrC,IAAe,MAAM,EAAO,gBAAgB;EAAE;EAAS;CAAK,CAAC,GAC7D,IAAS,EAA4B,GAAQ,EAAE,WAAQ,CAAC,GAExD,IAAW,EAAmB;EAClC,KAAK;EACL,cAAc;EACd,MAAM,CACJ;GACE,SAAS;IAAE,MAAM;IAAS,UAAU;GAAM;GAC1C;GACA,WAAW,CAAC,GAAG,CAAS;GACxB;EACF,CACF;CACF,CAAC,GAEK,IAAY,EAA6B,EAAM,SAAS,CAAO;CAErE,OAAO,EAAqB,GAAQ,GAAW,YAAY;EACzD,IAAM,IAAe,MAAM,EAAuB,GAAQ,SACxD,EAAqB,GAAQ;GAAE;GAAS;EAAQ,CAAC,CACnD,GACM,IAAW,OAAO,KAAK,MAAM,KAAK,IAAI,IAAI,GAAI,IAAI,IAAO,GAEzD,IAAY,EAAqB;GACrC,QAAQ,EAAa,QAAQ;GAC7B,QAAQ,EAAM,UAAU;GACxB;GACA,eAAe;GACf;GACA,OAAO,IAAe;EACxB,CAAC,GACK,IAAY,MAAM,EAAoB,GAAW,GAAQ,CAAY;EAE3E,OAAO,EACL,GACA,GACA;GAAE,aAAa,IAAe;GAAI,SAAS;GAAc,SAAS,EAAM;GAAS;EAAS,SAExF,EAAuB,GAAQ;GAC7B;GACA,aAAa,EAAa,QAAQ;GAClC,eAAe;GAEf,YAAY,CAAC;IAAE;IAAW;GAAU,CAAC;EACvC,CAAC,GACH,CACF;CACF,CAAC;AACH"}

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

@@ -0,0 +1,3 @@
+export * from './query.js';
+export * from './relay-instant-operations.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/gasless/relay-instant-operations/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,4BAA4B,CAAC"}

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

@@ -0,0 +1,18 @@
+import { Config } from '../../core/config/index.js';
+import { RelayInstantOperationsParameters, RelayInstantOperationsReturnType } from './relay-instant-operations.js';
+/**
+ * Build TanStack Mutation options for {@link relayInstantOperations}.
+ *
+ * @param config - The SDK config.
+ * @returns Options to pass to `useMutation` / `queryClient.getMutationCache`.
+ *
+ * @example
+ * ```ts
+ * useMutation(relayInstantOperationsMutationOptions(config));
+ * ```
+ */
+export declare function relayInstantOperationsMutationOptions(config: Config): {
+    mutationKey: readonly ["relayInstantOperations"];
+    mutationFn: (variables: RelayInstantOperationsParameters) => Promise<RelayInstantOperationsReturnType>;
+};
+//# sourceMappingURL=query.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../src/gasless/relay-instant-operations/query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAEL,KAAK,gCAAgC,EACrC,KAAK,gCAAgC,EACtC,MAAM,4BAA4B,CAAC;AAEpC;;;;;;;;;;GAUG;AACH,wBAAgB,qCAAqC,CAAC,MAAM,EAAE,MAAM;;4BAGxC,gCAAgC,KAAG,OAAO,CAAC,gCAAgC,CAAC;EAGvG"}

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

@@ -0,0 +1,12 @@
+import { relayInstantOperations as e } from "./relay-instant-operations.js";
+//#region src/gasless/relay-instant-operations/query.ts
+function t(t) {
+	return {
+		mutationKey: ["relayInstantOperations"],
+		mutationFn: (n) => e(t, n)
+	};
+}
+//#endregion
+export { t as relayInstantOperationsMutationOptions };
+
+//# sourceMappingURL=query.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"query.js","names":[],"sources":["../../../src/gasless/relay-instant-operations/query.ts"],"sourcesContent":["import type { Config } from \"../../core/config\";\nimport {\n  relayInstantOperations,\n  type RelayInstantOperationsParameters,\n  type RelayInstantOperationsReturnType,\n} from \"./relay-instant-operations\";\n\n/**\n * Build TanStack Mutation options for {@link relayInstantOperations}.\n *\n * @param config - The SDK config.\n * @returns Options to pass to `useMutation` / `queryClient.getMutationCache`.\n *\n * @example\n * ```ts\n * useMutation(relayInstantOperationsMutationOptions(config));\n * ```\n */\nexport function relayInstantOperationsMutationOptions(config: Config) {\n  return {\n    mutationKey: [\"relayInstantOperations\"] as const,\n    mutationFn: (variables: RelayInstantOperationsParameters): Promise<RelayInstantOperationsReturnType> =>\n      relayInstantOperations(config, variables),\n  };\n}\n"],"mappings":";;AAkBA,SAAgB,EAAsC,GAAgB;CACpE,OAAO;EACL,aAAa,CAAC,wBAAwB;EACtC,aAAa,MACX,EAAuB,GAAQ,CAAS;CAC5C;AACF"}

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

@@ -0,0 +1,127 @@
+import { Address, Hex } from 'viem';
+import { Config } from '../../core/config/index.js';
+import { ChainIdParameter, Compute } from '../../shared/types/properties.js';
+import { SignedOperation } from '../../solvers/instant-open/shared/types.js';
+import { GaslessSubmitReceipt } from '../types.js';
+/**
+ * One pre-signed InstantLayer operation for a relay batch: the struct exactly
+ * as it was EIP-712 signed, plus the 65-byte signature. Optional flex fills
+ * and their filler signatures ride alongside when a flex-field flow uses them.
+ */
+export interface GaslessSignedOperationInput {
+    /** The operation struct exactly as signed. */
+    operation: SignedOperation;
+    /** 65-byte EIP-712 signature over the operation. */
+    signature: Hex;
+    /** Flex fill payloads for this operation (rare; defaults to none). */
+    fills?: readonly Hex[];
+    /** Signatures authorizing the flex fills (parallel to `fills`). */
+    flexFillerSignatures?: readonly Hex[];
+    /**
+     * Which of the owner's GaslessWallets this operation executes from. Defaults
+     * to `0n`, which is what every ordinary InstantLayer operation and every
+     * delegation grant uses.
+     *
+     * Only a **gasless-wallet `execute`** operation names a positive id, and the
+     * id must match the wallet the operation was signed against: the signed
+     * `target` is that wallet's address, so changing the id without re-signing
+     * relays the signature against the wrong wallet and the batch reverts.
+     */
+    walletId?: bigint;
+}
+/**
+ * Parameters for {@link relayInstantOperations}.
+ */
+export type RelayInstantOperationsParameters = Compute<ChainIdParameter & {
+    /**
+     * The signed operations, in execution order. The batch is **atomic** — one
+     * revert rolls back every operation and every fee — so only bundle
+     * operations that must share fate. Replay nonces must be strictly
+     * sequential in this order (`current + 1`, `current + 2`, …).
+     */
+    operations: readonly GaslessSignedOperationInput[];
+    /**
+     * Workflow label stored with the request (display, metrics, idempotency).
+     * Free-form, 1–128 chars; fees are derived on-chain from calldata
+     * selectors, never from this. Keep it stable per action.
+     */
+    operationType: string;
+    /** Wallet the workflow is tracked under (not necessarily the raw signer). */
+    userAddress: Address;
+    /** Optional client accounting id stored with the request. */
+    accountId?: string;
+    /**
+     * Registered result-chained template id; omit for independent batches.
+     *
+     * The contract's `relayInstantTemplate` takes no wallet ids, so a template
+     * batch must leave every operation on wallet `0`.
+     */
+    templateId?: number;
+    /**
+     * Stable retry key (max 128 chars). Defaults to a random UUID.
+     *
+     * **One key per signature.** The signed operations are built by the caller
+     * here, so the key is a parameter: pass the same one to replay a submit
+     * whose response was lost, and the service returns the existing record
+     * instead of duplicating work. Change anything in the batch — re-sign, add
+     * an operation, move a wallet id — and the key must change too, or the
+     * service answers `409 IDEMPOTENCY_KEY_CONFLICT`
+     * (`isGaslessIdempotencyConflictError`).
+     */
+    idempotencyKey?: string;
+    /** Non-secret client correlation data stored with the request. */
+    metadata?: Record<string, unknown>;
+}>;
+/** Return type of {@link relayInstantOperations}. */
+export type RelayInstantOperationsReturnType = GaslessSubmitReceipt;
+/**
+ * Submit signed InstantLayer operations to the GaslessQ relayer.
+ *
+ * Fire-and-forget: the service validates and simulates the batch, returns
+ * `202` with a `request_id`, and broadcasts asynchronously — poll
+ * `getGaslessRequest` (or await `waitForGaslessRequest`) to a terminal status.
+ *
+ * Transport failures are dispositioned before they reach you: a `429` or a
+ * gateway-`503` is resent under the same key (it never reached the service),
+ * an ambiguous failure is resent once and then thrown as
+ * `GASLESS_SUBMIT_UNCONFIRMED` with the exact bytes to replay
+ * (`getGaslessUnconfirmedSubmit` → `resubmitGaslessRequest`), and a definitive
+ * 4xx is thrown as-is — inspect it with `parseGaslessErrorDetail` or
+ * `classifyGaslessFailure`, and treat only `isConfirmedGaslessFeeLimitError` /
+ * `isConfirmedGaslessUnavailableError` as safe grounds for a wallet-paid retry.
+ *
+ * **A 202 is the point of no return**: the workflow exists server-side and the
+ * transaction may execute even if polling later fails — never re-submit the
+ * same intent through the wallet afterwards.
+ *
+ * The batch always carries an explicit `walletIds` array, one decimal id per
+ * operation, taken from each entry's `walletId` (default `0n`). Persist the
+ * receipt's `owner`, `walletIds` and `idempotencyKey` with its `requestId`: a
+ * bare request id is not enough context to reconcile a workflow after a reload.
+ *
+ * @param config - The SDK config.
+ * @param parameters - Signed operations, workflow labels, retry key.
+ * @returns The acceptance receipt; persist `requestId` immediately.
+ * @throws {SymmError} `GASLESS_NOT_CONFIGURED` / `GASLESS_UNSUPPORTED_CONTRACTS_VERSION`.
+ * @throws {SymmError} `GASLESS_EMPTY_BATCH` for an empty `operations` array.
+ * @throws {SymmError} `GASLESS_TEMPLATE_ID_INVALID` for a `templateId` that is not a non-negative safe integer.
+ * @throws {SymmError} `GASLESS_TEMPLATE_WALLET_ID_UNSUPPORTED` when a template batch names a non-zero wallet id.
+ * @throws {SymmError} `GASLESS_WALLET_ID_INVALID` for a wallet id outside the `uint256` range.
+ * @throws {SymmApiError} `GASLESS_RELAY_SUBMIT_FAILED` on HTTP failure.
+ * @throws {SymmApiError} `GASLESS_SUBMIT_UNCONFIRMED` when the outcome could not be
+ *   established; `responseData` is the replayable submit.
+ * @throws {SymmApiError} `GASLESS_INSTANCE_MISMATCH` when a `2xx` came from another
+ *   protocol instance; the accepted body (its `request_id`) stays in `responseData`.
+ *
+ * @example
+ * ```ts
+ * const receipt = await relayInstantOperations(config, {
+ *   userAddress: owner,
+ *   operationType: "initiateWithdraw",
+ *   operations: [{ operation, signature }],
+ * });
+ * const record = await waitForGaslessRequest(config, { requestId: receipt.requestId });
+ * ```
+ */
+export declare function relayInstantOperations(config: Config, parameters: RelayInstantOperationsParameters): Promise<RelayInstantOperationsReturnType>;
+//# sourceMappingURL=relay-instant-operations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"relay-instant-operations.d.ts","sourceRoot":"","sources":["../../../src/gasless/relay-instant-operations/relay-instant-operations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AACzC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AAC/E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAI/E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAIrD;;;;GAIG;AACH,MAAM,WAAW,2BAA2B;IAC1C,8CAA8C;IAC9C,SAAS,EAAE,eAAe,CAAC;IAC3B,oDAAoD;IACpD,SAAS,EAAE,GAAG,CAAC;IACf,sEAAsE;IACtE,KAAK,CAAC,EAAE,SAAS,GAAG,EAAE,CAAC;IACvB,mEAAmE;IACnE,oBAAoB,CAAC,EAAE,SAAS,GAAG,EAAE,CAAC;IACtC;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,MAAM,gCAAgC,GAAG,OAAO,CACpD,gBAAgB,GAAG;IACjB;;;;;OAKG;IACH,UAAU,EAAE,SAAS,2BAA2B,EAAE,CAAC;IACnD;;;;OAIG;IACH,aAAa,EAAE,MAAM,CAAC;IACtB,6EAA6E;IAC7E,WAAW,EAAE,OAAO,CAAC;IACrB,6DAA6D;IAC7D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;;;;;;OAUG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,kEAAkE;IAClE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC,CACF,CAAC;AAEF,qDAAqD;AACrD,MAAM,MAAM,gCAAgC,GAAG,oBAAoB,CAAC;AA4BpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,gCAAgC,GAC3C,OAAO,CAAC,gCAAgC,CAAC,CAgD3C"}

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

@@ -0,0 +1,42 @@
+import { SymmError as e } from "../../shared/errors/symm-error.js";
+import { generateGaslessIdempotencyKey as t, postGaslessSubmit as n, resolveGaslessHttp as r } from "../http.js";
+import { assertGaslessWalletId as i, toGaslessWalletIdWire as a } from "../wallet-id.js";
+import { toGaslessSubmitReceipt as o } from "../to-gasless-submit-receipt.js";
+import { formatGaslessOperation as s } from "../format-gasless-operation.js";
+//#region src/gasless/relay-instant-operations/relay-instant-operations.ts
+function c(t, n) {
+	let r = t.map((e, t) => i(e.walletId ?? 0n, `operations[${t}].walletId`));
+	if (n !== void 0 && r.some((e) => e !== 0n)) throw new e("validation", "GASLESS_TEMPLATE_WALLET_ID_UNSUPPORTED", `Gasless: templateId ${n} relays through relayInstantTemplate, which takes no wallet ids — every operation in a template batch must use wallet 0. Relay gasless-wallet operations as an ordinary batch instead.`);
+	return r;
+}
+async function l(i, l) {
+	let { chainId: u, operations: d, operationType: f, userAddress: p, accountId: m, templateId: h, metadata: g } = l;
+	if (d.length === 0) throw new e("validation", "GASLESS_EMPTY_BATCH", "Gasless: relayInstantOperations needs at least one signed operation — the service rejects an empty batch.");
+	if (h !== void 0 && (!Number.isSafeInteger(h) || h < 0)) throw new e("validation", "GASLESS_TEMPLATE_ID_INVALID", `Gasless: templateId ${h} is not a non-negative safe integer. An unguarded value serializes to JSON \`null\`, which the service reads as "no template" and relays as a plain batch.`);
+	let _ = c(d, h), v = r(i, {
+		chainId: u,
+		service: "operations"
+	}), y = l.idempotencyKey ?? t();
+	return o(await n(v, "/gateway/relay-instant", {
+		idempotencyKey: y,
+		userAddress: p,
+		...m === void 0 ? {} : { accountId: m },
+		operationType: f,
+		...h === void 0 ? {} : { templateId: h },
+		signedOps: d.map((e) => s(e.operation)),
+		signatures: d.map((e) => e.signature),
+		walletIds: _.map(a),
+		fills: d.map((e) => [...e.fills ?? []]),
+		flexFillerSignatures: d.map((e) => [...e.flexFillerSignatures ?? []]),
+		...g === void 0 ? {} : { metadata: g }
+	}, y), {
+		owner: p,
+		walletIds: _,
+		idempotencyKey: y,
+		protocolInstance: v.protocolInstance
+	});
+}
+//#endregion
+export { l as relayInstantOperations };
+
+//# sourceMappingURL=relay-instant-operations.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"relay-instant-operations.js","names":[],"sources":["../../../src/gasless/relay-instant-operations/relay-instant-operations.ts"],"sourcesContent":["import type { Address, Hex } from \"viem\";\nimport type { Config } from \"../../core/config\";\nimport { SymmError } from \"../../shared/errors/symm-error\";\nimport type { ChainIdParameter, Compute } from \"../../shared/types/properties\";\nimport type { SignedOperation } from \"../../solvers/instant-open/shared/types\";\nimport { formatGaslessOperation } from \"../format-gasless-operation\";\nimport { generateGaslessIdempotencyKey, postGaslessSubmit, resolveGaslessHttp } from \"../http\";\nimport { toGaslessSubmitReceipt } from \"../to-gasless-submit-receipt\";\nimport type { GaslessSubmitReceipt } from \"../types\";\nimport { assertGaslessWalletId, toGaslessWalletIdWire } from \"../wallet-id\";\nimport type { GaslessWireOperationAccepted, GaslessWireRelayInstantRequest } from \"../wire-types\";\n\n/**\n * One pre-signed InstantLayer operation for a relay batch: the struct exactly\n * as it was EIP-712 signed, plus the 65-byte signature. Optional flex fills\n * and their filler signatures ride alongside when a flex-field flow uses them.\n */\nexport interface GaslessSignedOperationInput {\n  /** The operation struct exactly as signed. */\n  operation: SignedOperation;\n  /** 65-byte EIP-712 signature over the operation. */\n  signature: Hex;\n  /** Flex fill payloads for this operation (rare; defaults to none). */\n  fills?: readonly Hex[];\n  /** Signatures authorizing the flex fills (parallel to `fills`). */\n  flexFillerSignatures?: readonly Hex[];\n  /**\n   * Which of the owner's GaslessWallets this operation executes from. Defaults\n   * to `0n`, which is what every ordinary InstantLayer operation and every\n   * delegation grant uses.\n   *\n   * Only a **gasless-wallet `execute`** operation names a positive id, and the\n   * id must match the wallet the operation was signed against: the signed\n   * `target` is that wallet's address, so changing the id without re-signing\n   * relays the signature against the wrong wallet and the batch reverts.\n   */\n  walletId?: bigint;\n}\n\n/**\n * Parameters for {@link relayInstantOperations}.\n */\nexport type RelayInstantOperationsParameters = Compute<\n  ChainIdParameter & {\n    /**\n     * The signed operations, in execution order. The batch is **atomic** — one\n     * revert rolls back every operation and every fee — so only bundle\n     * operations that must share fate. Replay nonces must be strictly\n     * sequential in this order (`current + 1`, `current + 2`, …).\n     */\n    operations: readonly GaslessSignedOperationInput[];\n    /**\n     * Workflow label stored with the request (display, metrics, idempotency).\n     * Free-form, 1–128 chars; fees are derived on-chain from calldata\n     * selectors, never from this. Keep it stable per action.\n     */\n    operationType: string;\n    /** Wallet the workflow is tracked under (not necessarily the raw signer). */\n    userAddress: Address;\n    /** Optional client accounting id stored with the request. */\n    accountId?: string;\n    /**\n     * Registered result-chained template id; omit for independent batches.\n     *\n     * The contract's `relayInstantTemplate` takes no wallet ids, so a template\n     * batch must leave every operation on wallet `0`.\n     */\n    templateId?: number;\n    /**\n     * Stable retry key (max 128 chars). Defaults to a random UUID.\n     *\n     * **One key per signature.** The signed operations are built by the caller\n     * here, so the key is a parameter: pass the same one to replay a submit\n     * whose response was lost, and the service returns the existing record\n     * instead of duplicating work. Change anything in the batch — re-sign, add\n     * an operation, move a wallet id — and the key must change too, or the\n     * service answers `409 IDEMPOTENCY_KEY_CONFLICT`\n     * (`isGaslessIdempotencyConflictError`).\n     */\n    idempotencyKey?: string;\n    /** Non-secret client correlation data stored with the request. */\n    metadata?: Record<string, unknown>;\n  }\n>;\n\n/** Return type of {@link relayInstantOperations}. */\nexport type RelayInstantOperationsReturnType = GaslessSubmitReceipt;\n\n/**\n * The wallet ids a batch relays under, one per operation, validated.\n *\n * Always sent explicitly, never left to the service's zero-filling default:\n * an omitted array is a legacy-client affordance, and relying on it would make\n * a dropped or reordered id indistinguishable from \"no wallets selected\".\n *\n * @internal\n */\nfunction toGaslessBatchWalletIds(\n  operations: readonly GaslessSignedOperationInput[],\n  templateId: number | undefined,\n): bigint[] {\n  const walletIds = operations.map((entry, index) =>\n    assertGaslessWalletId(entry.walletId ?? 0n, `operations[${index}].walletId`),\n  );\n  if (templateId !== undefined && walletIds.some((walletId) => walletId !== 0n)) {\n    throw new SymmError(\n      \"validation\",\n      \"GASLESS_TEMPLATE_WALLET_ID_UNSUPPORTED\",\n      `Gasless: templateId ${templateId} relays through relayInstantTemplate, which takes no wallet ids — every operation in a template batch must use wallet 0. Relay gasless-wallet operations as an ordinary batch instead.`,\n    );\n  }\n  return walletIds;\n}\n\n/**\n * Submit signed InstantLayer operations to the GaslessQ relayer.\n *\n * Fire-and-forget: the service validates and simulates the batch, returns\n * `202` with a `request_id`, and broadcasts asynchronously — poll\n * `getGaslessRequest` (or await `waitForGaslessRequest`) to a terminal status.\n *\n * Transport failures are dispositioned before they reach you: a `429` or a\n * gateway-`503` is resent under the same key (it never reached the service),\n * an ambiguous failure is resent once and then thrown as\n * `GASLESS_SUBMIT_UNCONFIRMED` with the exact bytes to replay\n * (`getGaslessUnconfirmedSubmit` → `resubmitGaslessRequest`), and a definitive\n * 4xx is thrown as-is — inspect it with `parseGaslessErrorDetail` or\n * `classifyGaslessFailure`, and treat only `isConfirmedGaslessFeeLimitError` /\n * `isConfirmedGaslessUnavailableError` as safe grounds for a wallet-paid retry.\n *\n * **A 202 is the point of no return**: the workflow exists server-side and the\n * transaction may execute even if polling later fails — never re-submit the\n * same intent through the wallet afterwards.\n *\n * The batch always carries an explicit `walletIds` array, one decimal id per\n * operation, taken from each entry's `walletId` (default `0n`). Persist the\n * receipt's `owner`, `walletIds` and `idempotencyKey` with its `requestId`: a\n * bare request id is not enough context to reconcile a workflow after a reload.\n *\n * @param config - The SDK config.\n * @param parameters - Signed operations, workflow labels, retry key.\n * @returns The acceptance receipt; persist `requestId` immediately.\n * @throws {SymmError} `GASLESS_NOT_CONFIGURED` / `GASLESS_UNSUPPORTED_CONTRACTS_VERSION`.\n * @throws {SymmError} `GASLESS_EMPTY_BATCH` for an empty `operations` array.\n * @throws {SymmError} `GASLESS_TEMPLATE_ID_INVALID` for a `templateId` that is not a non-negative safe integer.\n * @throws {SymmError} `GASLESS_TEMPLATE_WALLET_ID_UNSUPPORTED` when a template batch names a non-zero wallet id.\n * @throws {SymmError} `GASLESS_WALLET_ID_INVALID` for a wallet id outside the `uint256` range.\n * @throws {SymmApiError} `GASLESS_RELAY_SUBMIT_FAILED` on HTTP failure.\n * @throws {SymmApiError} `GASLESS_SUBMIT_UNCONFIRMED` when the outcome could not be\n *   established; `responseData` is the replayable submit.\n * @throws {SymmApiError} `GASLESS_INSTANCE_MISMATCH` when a `2xx` came from another\n *   protocol instance; the accepted body (its `request_id`) stays in `responseData`.\n *\n * @example\n * ```ts\n * const receipt = await relayInstantOperations(config, {\n *   userAddress: owner,\n *   operationType: \"initiateWithdraw\",\n *   operations: [{ operation, signature }],\n * });\n * const record = await waitForGaslessRequest(config, { requestId: receipt.requestId });\n * ```\n */\nexport async function relayInstantOperations(\n  config: Config,\n  parameters: RelayInstantOperationsParameters,\n): Promise<RelayInstantOperationsReturnType> {\n  const { chainId, operations, operationType, userAddress, accountId, templateId, metadata } = parameters;\n  if (operations.length === 0) {\n    throw new SymmError(\n      \"validation\",\n      \"GASLESS_EMPTY_BATCH\",\n      \"Gasless: relayInstantOperations needs at least one signed operation — the service rejects an empty batch.\",\n    );\n  }\n  if (templateId !== undefined && (!Number.isSafeInteger(templateId) || templateId < 0)) {\n    throw new SymmError(\n      \"validation\",\n      \"GASLESS_TEMPLATE_ID_INVALID\",\n      `Gasless: templateId ${templateId} is not a non-negative safe integer. An unguarded value serializes to JSON \\`null\\`, which the service reads as \"no template\" and relays as a plain batch.`,\n    );\n  }\n  const walletIds = toGaslessBatchWalletIds(operations, templateId);\n\n  const context = resolveGaslessHttp(config, { chainId, service: \"operations\" });\n  const idempotencyKey = parameters.idempotencyKey ?? generateGaslessIdempotencyKey();\n\n  const body: GaslessWireRelayInstantRequest = {\n    idempotencyKey,\n    userAddress,\n    ...(accountId !== undefined ? { accountId } : {}),\n    operationType,\n    ...(templateId !== undefined ? { templateId } : {}),\n    signedOps: operations.map((entry) => formatGaslessOperation(entry.operation)),\n    signatures: operations.map((entry) => entry.signature),\n    walletIds: walletIds.map(toGaslessWalletIdWire),\n    fills: operations.map((entry) => [...(entry.fills ?? [])]),\n    flexFillerSignatures: operations.map((entry) => [...(entry.flexFillerSignatures ?? [])]),\n    ...(metadata !== undefined ? { metadata } : {}),\n  };\n\n  const raw = await postGaslessSubmit<GaslessWireOperationAccepted>(\n    context,\n    \"/gateway/relay-instant\",\n    body,\n    idempotencyKey,\n  );\n\n  return toGaslessSubmitReceipt(raw, {\n    owner: userAddress,\n    walletIds,\n    idempotencyKey,\n    protocolInstance: context.protocolInstance,\n  });\n}\n"],"mappings":";;;;;;AAiGA,SAAS,EACP,GACA,GACU;CACV,IAAM,IAAY,EAAW,KAAK,GAAO,MACvC,EAAsB,EAAM,YAAY,IAAI,cAAc,EAAM,WAAW,CAC7E;CACA,IAAI,MAAe,KAAA,KAAa,EAAU,MAAM,MAAa,MAAa,EAAE,GAC1E,MAAM,IAAI,EACR,cACA,0CACA,uBAAuB,EAAW,uLACpC;CAEF,OAAO;AACT;AAmDA,eAAsB,EACpB,GACA,GAC2C;CAC3C,IAAM,EAAE,YAAS,eAAY,kBAAe,gBAAa,cAAW,eAAY,gBAAa;CAC7F,IAAI,EAAW,WAAW,GACxB,MAAM,IAAI,EACR,cACA,uBACA,2GACF;CAEF,IAAI,MAAe,KAAA,MAAc,CAAC,OAAO,cAAc,CAAU,KAAK,IAAa,IACjF,MAAM,IAAI,EACR,cACA,+BACA,uBAAuB,EAAW,2JACpC;CAEF,IAAM,IAAY,EAAwB,GAAY,CAAU,GAE1D,IAAU,EAAmB,GAAQ;EAAE;EAAS,SAAS;CAAa,CAAC,GACvE,IAAiB,EAAW,kBAAkB,EAA8B;CAuBlF,OAAO,EAAuB,MAPZ,EAChB,GACA,0BACA;EAhBA;EACA;EACA,GAAI,MAAc,KAAA,IAA4B,CAAC,IAAjB,EAAE,aAAU;EAC1C;EACA,GAAI,MAAe,KAAA,IAA6B,CAAC,IAAlB,EAAE,cAAW;EAC5C,WAAW,EAAW,KAAK,MAAU,EAAuB,EAAM,SAAS,CAAC;EAC5E,YAAY,EAAW,KAAK,MAAU,EAAM,SAAS;EACrD,WAAW,EAAU,IAAI,CAAqB;EAC9C,OAAO,EAAW,KAAK,MAAU,CAAC,GAAI,EAAM,SAAS,CAAC,CAAE,CAAC;EACzD,sBAAsB,EAAW,KAAK,MAAU,CAAC,GAAI,EAAM,wBAAwB,CAAC,CAAE,CAAC;EACvF,GAAI,MAAa,KAAA,IAA2B,CAAC,IAAhB,EAAE,YAAS;CAMxC,GACA,CACF,GAEmC;EACjC,OAAO;EACP;EACA;EACA,kBAAkB,EAAQ;CAC5B,CAAC;AACH"}