@symmio/trading-core 3.0.0 → 3.1.0

package/dist/gasless/nonce-lock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nonce-lock.js","names":[],"sources":["../../src/gasless/nonce-lock.ts"],"sourcesContent":["import type { Config } from \"../core/config\";\nimport { SymmError } from \"../shared/errors/symm-error\";\nimport { isGaslessAcceptedInstanceMismatchError } from \"./http\";\nimport { isGaslessAcceptanceInvalidError } from \"./to-gasless-submit-receipt\";\nimport { GaslessRequestStatus, type GaslessRequest, type GaslessService } from \"./types\";\nimport { getGaslessUnconfirmedSubmit } from \"./unconfirmed-submit\";\nimport { waitForGaslessRequest } from \"./wait-for-gasless-request/wait-for-gasless-request\";\n\n/**\n * Per-config serialization of gasless relays by **nonce stream**.\n *\n * Replay nonces are sequential and read fresh immediately before signing; two\n * concurrent relays built from the same read would sign the same nonce and one\n * would be rejected in simulation. This chains each stream's relays behind a\n * promise so the read-sign-submit critical section never overlaps. Keyed off\n * the `Config` object with a `WeakMap` so locks die with the config.\n *\n * @internal\n */\nconst locks = new WeakMap<Config, Map<string, Promise<unknown>>>();\n\n/**\n * The lock/stream key of an account's **InstantLayer** operation nonces, which\n * the contract counts per `signerAccount`.\n *\n * @param chainId - The chain the operation relays on.\n * @param signerAccount - The operation's `signerAccount.addr`.\n * @returns The stream key.\n *\n * @internal\n */\nexport function gaslessInstantNonceStreamKey(chainId: number, signerAccount: string): string {\n  return `${chainId}:instant:${signerAccount.toLowerCase()}`;\n}\n\n/**\n * The lock/stream key of a **gasless-wallet operation** nonce stream.\n *\n * The two shapes mirror the contract's own storage. Wallet `0` counts in\n * `_legacyWalletOperationNonces[signerAccount]`, one stream per signer account\n * across every owner, so its key deliberately omits the owner — keying it by\n * owner would let two owners' relays sign the same legacy nonce. Every positive\n * id counts in `walletNonces[wallet][signerAccount]`, so its key carries both\n * the id and the owner that derives the wallet.\n *\n * @param chainId - The chain the operation relays on.\n * @param walletId - The selected wallet id.\n * @param owner - The wallet's owner.\n * @param signerAccount - The operation's `signerAccount.addr`.\n * @returns The stream key.\n *\n * @internal\n */\nexport function gaslessWalletNonceStreamKey(\n  chainId: number,\n  walletId: bigint,\n  owner: string,\n  signerAccount: string,\n): string {\n  const signer = signerAccount.toLowerCase();\n  return walletId === 0n\n    ? `${chainId}:wallet:0:${signer}`\n    : `${chainId}:wallet:${walletId}:${owner.toLowerCase()}:${signer}`;\n}\n\n/**\n * Run `task` exclusively for one nonce stream. Queued tasks run in FIFO order;\n * a failed task never blocks the next one, and the map entry is cleared once\n * the last queued task settles.\n *\n * @param config - The SDK config the locks belong to.\n * @param key - A stream key from {@link gaslessInstantNonceStreamKey} or {@link gaslessWalletNonceStreamKey}.\n * @param task - The read-sign-submit critical section.\n *\n * @internal\n */\nexport function withGaslessNonceLock<result>(\n  config: Config,\n  key: string,\n  task: () => Promise<result>,\n): Promise<result> {\n  return withGaslessNonceLocks(config, [key], task);\n}\n\n/**\n * Run `task` exclusively for **several** nonce streams at once — a batch that\n * signs on more than one stream (an account's InstantLayer stream plus one\n * stream per GaslessWallet id). The single-stream {@link withGaslessNonceLock}\n * is the one-key case.\n *\n * The task joins every stream's queue in the same synchronous step and starts\n * once all of their earlier tasks have settled. A task therefore only ever\n * waits on tasks queued before it, so two batches that share streams — in any\n * order — can never each hold one stream while waiting for the other's.\n *\n * @param config - The SDK config the locks belong to.\n * @param keys - The stream keys the task signs on; duplicates are ignored.\n * @param task - The read-sign-submit critical section.\n *\n * @internal\n */\nexport function withGaslessNonceLocks<result>(\n  config: Config,\n  keys: readonly string[],\n  task: () => Promise<result>,\n): Promise<result> {\n  let byKey = locks.get(config);\n  if (!byKey) {\n    byKey = new Map();\n    locks.set(config, byKey);\n  }\n  const queues = byKey;\n  const streams = [...new Set(keys)];\n\n  const previous = Promise.all(streams.map((key) => queues.get(key) ?? Promise.resolve()));\n  const run = previous.then(task, task);\n\n  const settled = run.then(\n    () => undefined,\n    () => undefined,\n  );\n  for (const key of streams) queues.set(key, settled);\n  void settled.then(() => {\n    for (const key of streams) {\n      if (queues.get(key) === settled) queues.delete(key);\n    }\n  });\n\n  return run;\n}\n\n/**\n * A signature that left this SDK on one nonce stream and has not been seen\n * consumed on-chain yet.\n *\n * @internal\n */\ninterface GaslessPendingNonce {\n  /** The highest nonce the submitted batch signed on this stream. */\n  signedNonce: bigint;\n  /** The accepted request's id, or `null` when the submit's outcome is unknown. */\n  requestId: string | null;\n  /** Which service stores the request. */\n  service: GaslessService;\n  /** The chain the request was submitted on. */\n  chainId: number;\n  /** When the signature expires (ms since epoch) — after that it can never land. */\n  expiresAtMs: number;\n}\n\n/** The pending signature per stream, per config. @internal */\nconst pendingNonces = new WeakMap<Config, Map<string, GaslessPendingNonce>>();\n\n/**\n * The highest nonce a `succeeded` relay consumed, per stream, per config.\n *\n * `succeeded` is the relayer's node's view, and a public RPC can trail it by a\n * few blocks — long enough for the next write to read the old nonce and sign\n * it again. A consumed nonce stays consumed, so every read on the stream is\n * raised to this floor for as long as the config lives.\n *\n * @internal\n */\nconst consumedFloors = new WeakMap<Config, Map<string, bigint>>();\n\n/** How long a new caller may wait for a pending signature to resolve, whatever its deadline says. */\nconst GASLESS_NONCE_STREAM_WAIT_MS = 120_000;\n/** Cadence of the on-chain nonce re-read while waiting for an unconfirmed submit. */\nconst GASLESS_NONCE_STREAM_POLL_MS = 1_500;\n\nfunction pendingFor(config: Config): Map<string, GaslessPendingNonce> {\n  let byKey = pendingNonces.get(config);\n  if (!byKey) {\n    byKey = new Map();\n    pendingNonces.set(config, byKey);\n  }\n  return byKey;\n}\n\n/** Forget a stream's pending signature. @internal */\nexport function clearGaslessPendingNonce(config: Config, key: string): void {\n  pendingNonces.get(config)?.delete(key);\n}\n\n/** Record that a stream has consumed at least `nonce`, whatever this config's RPC still reports. */\nfunction raiseConsumedFloor(config: Config, key: string, nonce: bigint): void {\n  let byKey = consumedFloors.get(config);\n  if (!byKey) {\n    byKey = new Map();\n    consumedFloors.set(config, byKey);\n  }\n  const floor = byKey.get(key);\n  if (floor === undefined || nonce > floor) byKey.set(key, nonce);\n}\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\n/**\n * Whether a thrown submit error leaves the stream's signed nonce **possibly or\n * certainly consumed**, so the next caller must wait for it instead of signing\n * it again.\n *\n * Three shapes qualify, and the submit path narrows every ambiguity down to\n * them before they get here:\n *\n * - `GASLESS_SUBMIT_UNCONFIRMED` — the transport failed ambiguously, or a\n *   `202` carried no `request_id`. Either way the batch may be executing.\n * - `GASLESS_ACCEPTANCE_INVALID` — the parser's own guard for that second case;\n *   acceptance is certain and only the handle was lost, which makes the nonce\n *   more likely to be consumed, not less.\n * - A `2xx` from the wrong protocol instance — accepted somewhere, so the\n *   signature must be treated as spent.\n *\n * Every other failure is a rejection that consumed nothing: the gateway refused\n * the request before the service saw it, or the service answered with a verdict.\n *\n * @param err - Anything caught from a gasless submit.\n * @returns `true` when the stream must stay blocked until the nonce moves or the signature expires.\n *\n * @internal\n */\nexport function blocksGaslessNonceStream(err: unknown): boolean {\n  return (\n    getGaslessUnconfirmedSubmit(err) !== null ||\n    isGaslessAcceptanceInvalidError(err) ||\n    isGaslessAcceptedInstanceMismatchError(err)\n  );\n}\n\n/**\n * Submit a relay while keeping the stream's pending-signature record honest.\n *\n * The lock only spans the submit, so the nonce a released lock leaves behind is\n * still unconsumed on-chain for as long as the relayer takes to broadcast. This\n * records what was signed so the **next** caller on the stream can wait for it\n * instead of signing the same nonce again.\n *\n * A blocking failure records `requestId: null`: the batch may have been\n * accepted (an ambiguous transport failure) or is known to have been accepted\n * without a trackable id, so the stream stays blocked until the nonce is seen\n * consumed or the signature expires. A definitive rejection records nothing —\n * nothing was accepted, so the nonce is free immediately.\n *\n * @param config - The SDK config.\n * @param key - The stream key the submit was signed on.\n * @param pending - What was signed: the highest nonce, the service, the chain and the signature deadline (seconds).\n * @param submit - Performs the POST and returns the acceptance receipt.\n * @param blocksStream - Whether a thrown error leaves the signed nonce possibly or certainly consumed; pass {@link blocksGaslessNonceStream}.\n * @returns Whatever `submit` resolved with.\n *\n * @internal\n */\nexport function submitOnGaslessNonceStream<result extends { requestId: string }>(\n  config: Config,\n  key: string,\n  pending: { signedNonce: bigint; service: GaslessService; chainId: number; deadline: bigint },\n  submit: () => Promise<result>,\n  blocksStream: (err: unknown) => boolean,\n): Promise<result> {\n  return submitOnGaslessNonceStreams(\n    config,\n    [{ key, signedNonce: pending.signedNonce }],\n    pending,\n    submit,\n    blocksStream,\n  );\n}\n\n/**\n * {@link submitOnGaslessNonceStream} for a submit that signed on **several**\n * streams — one relay request carrying an InstantLayer operation and a\n * GaslessWallet operation, say. Every stream records the same request, because\n * one request consumes all of them or none; each keeps its own highest signed\n * nonce.\n *\n * @param config - The SDK config.\n * @param streams - Each stream the submit signed on, with the highest nonce it signed there.\n * @param pending - The service, the chain and the signature deadline (seconds), shared by every stream.\n * @param submit - Performs the POST and returns the acceptance receipt.\n * @param blocksStream - Whether a thrown error leaves the signed nonces possibly or certainly consumed; pass {@link blocksGaslessNonceStream}.\n * @returns Whatever `submit` resolved with.\n *\n * @internal\n */\nexport async function submitOnGaslessNonceStreams<result extends { requestId: string }>(\n  config: Config,\n  streams: readonly { key: string; signedNonce: bigint }[],\n  pending: { service: GaslessService; chainId: number; deadline: bigint },\n  submit: () => Promise<result>,\n  blocksStream: (err: unknown) => boolean,\n): Promise<result> {\n  const expiresAtMs = Number(pending.deadline) * 1_000;\n  const record = (requestId: string | null) => {\n    for (const stream of streams) {\n      pendingFor(config).set(stream.key, {\n        signedNonce: stream.signedNonce,\n        requestId,\n        service: pending.service,\n        chainId: pending.chainId,\n        expiresAtMs,\n      });\n    }\n  };\n\n  let receipt: result;\n  try {\n    receipt = await submit();\n  } catch (err) {\n    if (blocksStream(err)) record(null);\n    throw err;\n  }\n\n  record(receipt.requestId);\n  return receipt;\n}\n\n/**\n * Read a stream's consumed nonce, waiting first for anything this SDK already\n * signed on it and has not seen land.\n *\n * The relayer forwards signed nonces; it never reserves, replaces or repairs\n * them. So signing `consumed + 1` while an earlier signature for that same\n * nonce is still in flight guarantees that one of the two reverts. Rather than\n * hold the lock for the whole broadcast (which would stall every later write\n * behind a slow relay), the lock is released at the `202` and the wait happens\n * lazily here, only when a new caller actually needs the stream.\n *\n * Waiting ends as soon as the pending request reaches **any** terminal status —\n * a failed one frees the nonce, a successful one advances it — or as soon as\n * the nonce is observed to have moved past what was signed. The budget is\n * `min(signature deadline, 120 s)`: past the deadline the signature can never\n * land, so the nonce is free.\n *\n * A successful terminal advances the stream without waiting for this RPC to\n * see the block. `succeeded` is the relayer's node's view and a public RPC can\n * trail it, so the signed nonce becomes a floor under every later read on the\n * stream; the relayer simulates the next submit against its own node, which\n * already has the block.\n *\n * @param config - The SDK config.\n * @param key - The stream key.\n * @param readConsumedNonce - Reads the stream's consumed nonce on-chain.\n * @returns The consumed nonce to sign from (sign `+ 1n`).\n * @throws {SymmError} `GASLESS_NONCE_STREAM_BUSY` when the budget runs out with a signature\n *   still unaccounted for — signing now would collide with it.\n *\n * @internal\n */\nexport async function readGaslessStreamNonce(\n  config: Config,\n  key: string,\n  readConsumedNonce: () => Promise<bigint>,\n): Promise<bigint> {\n  /** Every read is raised to the nonce a `succeeded` relay on this stream is known to have consumed. */\n  const readFloored = async () => {\n    const read = await readConsumedNonce();\n    const floor = consumedFloors.get(config)?.get(key);\n    return floor !== undefined && floor > read ? floor : read;\n  };\n\n  const consumed = await readFloored();\n  const pending = pendingFor(config).get(key);\n  if (!pending) return consumed;\n\n  const budgetEndsAt = Math.min(pending.expiresAtMs, Date.now() + GASLESS_NONCE_STREAM_WAIT_MS);\n  /** Already consumed, or expired past any chance of landing: the stream is free. */\n  if (pending.signedNonce <= consumed || budgetEndsAt <= Date.now()) {\n    clearGaslessPendingNonce(config, key);\n    return consumed;\n  }\n\n  if (pending.requestId !== null) {\n    let terminal: GaslessRequest | null = null;\n    try {\n      terminal = await waitForGaslessRequest(config, {\n        chainId: pending.chainId,\n        requestId: pending.requestId,\n        service: pending.service,\n        until: \"terminal\",\n        timeoutMs: budgetEndsAt - Date.now(),\n      });\n    } catch {\n      /**\n       * The wait timed out or the status read kept failing. The signature is\n       * still unaccounted for, so fall through to watching the nonce itself —\n       * the one fact that settles it without the service.\n       */\n    }\n\n    if (terminal !== null) {\n      /**\n       * `succeeded` proves every signed nonce consumed — a relay that fails any\n       * operation reverts whole — even while this RPC still reports the old one.\n       * Any other terminal frees the nonce: `reverted` and `rejected` consumed\n       * nothing, and since two signatures on one nonce never both execute, even\n       * a `failed` transaction that mines late costs one rejection, never a\n       * double run.\n       */\n      if (terminal.status === GaslessRequestStatus.SUCCEEDED) raiseConsumedFloor(config, key, pending.signedNonce);\n      clearGaslessPendingNonce(config, key);\n      return await readFloored();\n    }\n  }\n\n  while (Date.now() < budgetEndsAt) {\n    await sleep(GASLESS_NONCE_STREAM_POLL_MS);\n    const latest = await readFloored();\n    if (latest >= pending.signedNonce) {\n      clearGaslessPendingNonce(config, key);\n      return latest;\n    }\n  }\n\n  throw new SymmError(\n    \"api\",\n    \"GASLESS_NONCE_STREAM_BUSY\",\n    `Gasless: nonce ${pending.signedNonce} was signed on this stream${pending.requestId ? ` for request ${pending.requestId}` : \" for a submit that returned no trackable request id\"} and has not landed yet. Signing now would collide with it — wait for that request to finish, or for its deadline to pass, before retrying.`,\n  );\n}\n"],"mappings":";;;;;;;AAmBA,IAAM,oBAAQ,IAAI,QAA+C;AAYjE,SAAgB,EAA6B,GAAiB,GAA+B;CAC3F,OAAO,GAAG,EAAQ,WAAW,EAAc,YAAY;AACzD;AAoBA,SAAgB,EACd,GACA,GACA,GACA,GACQ;CACR,IAAM,IAAS,EAAc,YAAY;CACzC,OAAO,MAAa,KAChB,GAAG,EAAQ,YAAY,MACvB,GAAG,EAAQ,UAAU,EAAS,GAAG,EAAM,YAAY,EAAE,GAAG;AAC9D;AAaA,SAAgB,EACd,GACA,GACA,GACiB;CACjB,OAAO,EAAsB,GAAQ,CAAC,CAAG,GAAG,CAAI;AAClD;AAmBA,SAAgB,EACd,GACA,GACA,GACiB;CACjB,IAAI,IAAQ,EAAM,IAAI,CAAM;CAC5B,AAAK,MACH,oBAAQ,IAAI,IAAI,GAChB,EAAM,IAAI,GAAQ,CAAK;CAEzB,IAAM,IAAS,GACT,IAAU,CAAC,GAAG,IAAI,IAAI,CAAI,CAAC,GAG3B,IADW,QAAQ,IAAI,EAAQ,KAAK,MAAQ,EAAO,IAAI,CAAG,KAAK,QAAQ,QAAQ,CAAC,CAC1E,EAAS,KAAK,GAAM,CAAI,GAE9B,IAAU,EAAI,WACZ,KAAA,SACA,KAAA,CACR;CACA,KAAK,IAAM,KAAO,GAAS,EAAO,IAAI,GAAK,CAAO;CAOlD,OANA,EAAa,WAAW;EACtB,KAAK,IAAM,KAAO,GAChB,AAAI,EAAO,IAAI,CAAG,MAAM,KAAS,EAAO,OAAO,CAAG;CAEtD,CAAC,GAEM;AACT;AAsBA,IAAM,oBAAgB,IAAI,QAAkD,GAYtE,oBAAiB,IAAI,QAAqC,GAG1D,IAA+B,MAE/B,IAA+B;AAErC,SAAS,EAAW,GAAkD;CACpE,IAAI,IAAQ,EAAc,IAAI,CAAM;CAKpC,OAJK,MACH,oBAAQ,IAAI,IAAI,GAChB,EAAc,IAAI,GAAQ,CAAK,IAE1B;AACT;AAGA,SAAgB,EAAyB,GAAgB,GAAmB;CAC1E,EAAc,IAAI,CAAM,GAAG,OAAO,CAAG;AACvC;AAGA,SAAS,EAAmB,GAAgB,GAAa,GAAqB;CAC5E,IAAI,IAAQ,EAAe,IAAI,CAAM;CACrC,AAAK,MACH,oBAAQ,IAAI,IAAI,GAChB,EAAe,IAAI,GAAQ,CAAK;CAElC,IAAM,IAAQ,EAAM,IAAI,CAAG;CAC3B,CAAI,MAAU,KAAA,KAAa,IAAQ,MAAO,EAAM,IAAI,GAAK,CAAK;AAChE;AAEA,SAAS,EAAM,GAA2B;CACxC,OAAO,IAAI,SAAS,MAAY,WAAW,GAAS,CAAE,CAAC;AACzD;AA0BA,SAAgB,EAAyB,GAAuB;CAC9D,OACE,EAA4B,CAAG,MAAM,QACrC,EAAgC,CAAG,KACnC,EAAuC,CAAG;AAE9C;AAyBA,SAAgB,EACd,GACA,GACA,GACA,GACA,GACiB;CACjB,OAAO,EACL,GACA,CAAC;EAAE;EAAK,aAAa,EAAQ;CAAY,CAAC,GAC1C,GACA,GACA,CACF;AACF;AAkBA,eAAsB,EACpB,GACA,GACA,GACA,GACA,GACiB;CACjB,IAAM,IAAc,OAAO,EAAQ,QAAQ,IAAI,KACzC,KAAU,MAA6B;EAC3C,KAAK,IAAM,KAAU,GACnB,EAAW,CAAM,EAAE,IAAI,EAAO,KAAK;GACjC,aAAa,EAAO;GACpB;GACA,SAAS,EAAQ;GACjB,SAAS,EAAQ;GACjB;EACF,CAAC;CAEL,GAEI;CACJ,IAAI;EACF,IAAU,MAAM,EAAO;CACzB,SAAS,GAAK;EAEZ,MADI,EAAa,CAAG,KAAG,EAAO,IAAI,GAC5B;CACR;CAGA,OADA,EAAO,EAAQ,SAAS,GACjB;AACT;AAkCA,eAAsB,EACpB,GACA,GACA,GACiB;CAEjB,IAAM,IAAc,YAAY;EAC9B,IAAM,IAAO,MAAM,EAAkB,GAC/B,IAAQ,EAAe,IAAI,CAAM,GAAG,IAAI,CAAG;EACjD,OAAO,MAAU,KAAA,KAAa,IAAQ,IAAO,IAAQ;CACvD,GAEM,IAAW,MAAM,EAAY,GAC7B,IAAU,EAAW,CAAM,EAAE,IAAI,CAAG;CAC1C,IAAI,CAAC,GAAS,OAAO;CAErB,IAAM,IAAe,KAAK,IAAI,EAAQ,aAAa,KAAK,IAAI,IAAI,CAA4B;CAE5F,IAAI,EAAQ,eAAe,KAAY,KAAgB,KAAK,IAAI,GAE9D,OADA,EAAyB,GAAQ,CAAG,GAC7B;CAGT,IAAI,EAAQ,cAAc,MAAM;EAC9B,IAAI,IAAkC;EACtC,IAAI;GACF,IAAW,MAAM,EAAsB,GAAQ;IAC7C,SAAS,EAAQ;IACjB,WAAW,EAAQ;IACnB,SAAS,EAAQ;IACjB,OAAO;IACP,WAAW,IAAe,KAAK,IAAI;GACrC,CAAC;EACH,QAAQ,CAMR;EAEA,IAAI,MAAa,MAWf,OAFI,EAAS,WAAW,EAAqB,aAAW,EAAmB,GAAQ,GAAK,EAAQ,WAAW,GAC3G,EAAyB,GAAQ,CAAG,GAC7B,MAAM,EAAY;CAE7B;CAEA,OAAO,KAAK,IAAI,IAAI,IAAc;EAChC,MAAM,EAAM,CAA4B;EACxC,IAAM,IAAS,MAAM,EAAY;EACjC,IAAI,KAAU,EAAQ,aAEpB,OADA,EAAyB,GAAQ,CAAG,GAC7B;CAEX;CAEA,MAAM,IAAI,EACR,OACA,6BACA,kBAAkB,EAAQ,YAAY,4BAA4B,EAAQ,YAAY,gBAAgB,EAAQ,cAAc,sDAAsD,4IACpL;AACF"}

package/dist/gasless/observe-gasless-request.d.ts

@@ -0,0 +1,65 @@
+import { Config } from '../core/config/index.js';
+import { SymmError } from '../shared/errors/symm-error.js';
+import { GaslessRequest, GaslessService } from './types.js';
+/**
+ * How a status wait follows a workflow.
+ *
+ * - `"auto"` (default): subscribe to the gateway's status stream when the
+ *   deployment enables it, and poll only while the stream is not delivering.
+ * - `"poll"`: HTTP polling only — the transport the SDK has always used.
+ */
+export type GaslessStatusTransport = "auto" | "poll";
+/**
+ * What the stream is doing for one workflow, from a status wait's point of view.
+ *
+ * - `"pending"` — dialing, or subscribed and waiting for the first record. The
+ *   wait holds its first HTTP read for a moment, since the answer is coming.
+ * - `"live"` — delivering; polling stands down.
+ * - `"unavailable"` — it will not deliver for now (unreachable, not on this
+ *   instance, over the subscription cap, disabled). Poll, and do not wait.
+ *
+ * @internal
+ */
+export type GaslessObserverState = "pending" | "live" | "unavailable";
+/**
+ * A live view of one workflow, fed by the status stream.
+ *
+ * The wait loop owns the HTTP polling; this only tells it what the stream is
+ * doing for the workflow and hands over the records it delivered. The split
+ * keeps one rule intact: a `watch*` never issues HTTP, and a poller never
+ * pretends to be a subscription.
+ *
+ * @internal
+ */
+export interface GaslessStatusObserver {
+    /** What the stream is doing for this workflow right now. */
+    state(): GaslessObserverState;
+    /** Take the newest record the stream delivered since the last call, if any. */
+    take(): GaslessRequest | null;
+    /**
+     * Resolve on the next stream delivery, on a change in {@link state}, or after
+     * `timeoutMs` — whichever comes first. The wait loop uses it instead of a
+     * blind sleep, so a stream update is acted on the moment it lands and a
+     * stream that gives up is not waited on for the full window.
+     */
+    wait(timeoutMs: number, signal?: AbortSignal): Promise<void>;
+    /** Release the subscription. */
+    close(): void;
+}
+/**
+ * Subscribe to a workflow's status stream, when the deployment has one.
+ *
+ * Returns `null` when the chain cannot stream (no gasless block, streams not
+ * enabled, a proxy with no declared gateway origin) or when the subscription
+ * throws, so the caller simply keeps polling. Stream errors are reported
+ * through `onTransportIssue` and never surface as workflow failures.
+ *
+ * @internal
+ */
+export declare function createGaslessStatusObserver(config: Config, parameters: {
+    chainId?: number;
+    requestId: string;
+    service: GaslessService;
+    onTransportIssue?: (error: SymmError) => void;
+}): GaslessStatusObserver | null;
+//# sourceMappingURL=observe-gasless-request.d.ts.map

package/dist/gasless/observe-gasless-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observe-gasless-request.d.ts","sourceRoot":"","sources":["../../src/gasless/observe-gasless-request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAE7D,OAAO,KAAK,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9D;;;;;;GAMG;AACH,MAAM,MAAM,sBAAsB,GAAG,MAAM,GAAG,MAAM,CAAC;AAErD;;;;;;;;;;GAUG;AACH,MAAM,MAAM,oBAAoB,GAAG,SAAS,GAAG,MAAM,GAAG,aAAa,CAAC;AAEtE;;;;;;;;;GASG;AACH,MAAM,WAAW,qBAAqB;IACpC,4DAA4D;IAC5D,KAAK,IAAI,oBAAoB,CAAC;IAC9B,+EAA+E;IAC/E,IAAI,IAAI,cAAc,GAAG,IAAI,CAAC;IAC9B;;;;;OAKG;IACH,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7D,gCAAgC;IAChC,KAAK,IAAI,IAAI,CAAC;CACf;AAED;;;;;;;;;GASG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE;IACV,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,cAAc,CAAC;IACxB,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;CAC/C,GACA,qBAAqB,GAAG,IAAI,CA8E9B"}

package/dist/gasless/observe-gasless-request.js

@@ -0,0 +1,56 @@
+import { supportsGaslessStatusStream as e, watchGaslessRequest as t } from "../websocket/gasless/watch-gasless-request.js";
+//#region src/gasless/observe-gasless-request.ts
+function n(n, r) {
+	let { chainId: i, requestId: a, service: o, onTransportIssue: s } = r;
+	if (!e(n, {
+		chainId: i,
+		service: o
+	})) return null;
+	let c = "pending", l = null, u = null;
+	function d() {
+		let e = u;
+		u = null, e?.();
+	}
+	let f;
+	try {
+		f = t(n, {
+			chainId: i,
+			requestId: a,
+			service: o,
+			onUpdate: (e) => {
+				e.request && (l = e.request), d();
+			},
+			onStatusChange: (e) => {
+				let t = e === "live" ? "live" : e === "idle" || e === "connecting" ? "pending" : "unavailable";
+				t !== c && (c = t, d());
+			},
+			onError: (e) => {
+				try {
+					s?.(e);
+				} catch {}
+			}
+		});
+	} catch {
+		return null;
+	}
+	return {
+		state: () => c,
+		take: () => {
+			let e = l;
+			return l = null, e;
+		},
+		wait: (e, t) => new Promise((n) => {
+			let r = !1, i = () => {
+				r || (r = !0, clearTimeout(a), t?.removeEventListener("abort", i), u = null, n());
+			}, a = setTimeout(i, e);
+			u = i, t?.addEventListener("abort", i, { once: !0 });
+		}),
+		close: () => {
+			u = null, f();
+		}
+	};
+}
+//#endregion
+export { n as createGaslessStatusObserver };
+
+//# sourceMappingURL=observe-gasless-request.js.map

package/dist/gasless/observe-gasless-request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observe-gasless-request.js","names":[],"sources":["../../src/gasless/observe-gasless-request.ts"],"sourcesContent":["import type { Config } from \"../core/config\";\nimport type { SymmError } from \"../shared/errors/symm-error\";\nimport { supportsGaslessStatusStream, watchGaslessRequest } from \"../websocket/gasless/watch-gasless-request\";\nimport type { GaslessRequest, GaslessService } from \"./types\";\n\n/**\n * How a status wait follows a workflow.\n *\n * - `\"auto\"` (default): subscribe to the gateway's status stream when the\n *   deployment enables it, and poll only while the stream is not delivering.\n * - `\"poll\"`: HTTP polling only — the transport the SDK has always used.\n */\nexport type GaslessStatusTransport = \"auto\" | \"poll\";\n\n/**\n * What the stream is doing for one workflow, from a status wait's point of view.\n *\n * - `\"pending\"` — dialing, or subscribed and waiting for the first record. The\n *   wait holds its first HTTP read for a moment, since the answer is coming.\n * - `\"live\"` — delivering; polling stands down.\n * - `\"unavailable\"` — it will not deliver for now (unreachable, not on this\n *   instance, over the subscription cap, disabled). Poll, and do not wait.\n *\n * @internal\n */\nexport type GaslessObserverState = \"pending\" | \"live\" | \"unavailable\";\n\n/**\n * A live view of one workflow, fed by the status stream.\n *\n * The wait loop owns the HTTP polling; this only tells it what the stream is\n * doing for the workflow and hands over the records it delivered. The split\n * keeps one rule intact: a `watch*` never issues HTTP, and a poller never\n * pretends to be a subscription.\n *\n * @internal\n */\nexport interface GaslessStatusObserver {\n  /** What the stream is doing for this workflow right now. */\n  state(): GaslessObserverState;\n  /** Take the newest record the stream delivered since the last call, if any. */\n  take(): GaslessRequest | null;\n  /**\n   * Resolve on the next stream delivery, on a change in {@link state}, or after\n   * `timeoutMs` — whichever comes first. The wait loop uses it instead of a\n   * blind sleep, so a stream update is acted on the moment it lands and a\n   * stream that gives up is not waited on for the full window.\n   */\n  wait(timeoutMs: number, signal?: AbortSignal): Promise<void>;\n  /** Release the subscription. */\n  close(): void;\n}\n\n/**\n * Subscribe to a workflow's status stream, when the deployment has one.\n *\n * Returns `null` when the chain cannot stream (no gasless block, streams not\n * enabled, a proxy with no declared gateway origin) or when the subscription\n * throws, so the caller simply keeps polling. Stream errors are reported\n * through `onTransportIssue` and never surface as workflow failures.\n *\n * @internal\n */\nexport function createGaslessStatusObserver(\n  config: Config,\n  parameters: {\n    chainId?: number;\n    requestId: string;\n    service: GaslessService;\n    onTransportIssue?: (error: SymmError) => void;\n  },\n): GaslessStatusObserver | null {\n  const { chainId, requestId, service, onTransportIssue } = parameters;\n  if (!supportsGaslessStatusStream(config, { chainId, service })) return null;\n\n  let state: GaslessObserverState = \"pending\";\n  let pending: GaslessRequest | null = null;\n  let wake: (() => void) | null = null;\n\n  function notify(): void {\n    const resume = wake;\n    wake = null;\n    resume?.();\n  }\n\n  let unwatch: () => void;\n  try {\n    unwatch = watchGaslessRequest(config, {\n      chainId,\n      requestId,\n      service,\n      onUpdate: (update) => {\n        if (update.request) pending = update.request;\n        notify();\n      },\n      onStatusChange: (status) => {\n        /**\n         * Waking on the `live` flag alone would sleep through the one\n         * transition a settling wait most needs: `connecting -> degraded`, the\n         * stream saying it cannot answer. Both are \"not live\", so a wait would\n         * burn its whole settle window before reading over HTTP.\n         */\n        const next: GaslessObserverState =\n          status === \"live\" ? \"live\" : status === \"idle\" || status === \"connecting\" ? \"pending\" : \"unavailable\";\n        if (next !== state) {\n          state = next;\n          notify();\n        }\n      },\n      onError: (error) => {\n        try {\n          onTransportIssue?.(error);\n        } catch {\n          /** An observer must never break the wait it is observing. */\n        }\n      },\n    });\n  } catch {\n    /** An unsupported or misconfigured stream is not a wait failure: poll instead. */\n    return null;\n  }\n\n  return {\n    state: () => state,\n    take: () => {\n      const record = pending;\n      pending = null;\n      return record;\n    },\n    wait: (timeoutMs, signal) =>\n      new Promise<void>((resolve) => {\n        let settled = false;\n        const finish = (): void => {\n          if (settled) return;\n          settled = true;\n          clearTimeout(timer);\n          signal?.removeEventListener(\"abort\", finish);\n          wake = null;\n          resolve();\n        };\n        const timer = setTimeout(finish, timeoutMs);\n        wake = finish;\n        signal?.addEventListener(\"abort\", finish, { once: true });\n      }),\n    close: () => {\n      wake = null;\n      unwatch();\n    },\n  };\n}\n"],"mappings":";;AA+DA,SAAgB,EACd,GACA,GAM8B;CAC9B,IAAM,EAAE,YAAS,cAAW,YAAS,wBAAqB;CAC1D,IAAI,CAAC,EAA4B,GAAQ;EAAE;EAAS;CAAQ,CAAC,GAAG,OAAO;CAEvE,IAAI,IAA8B,WAC9B,IAAiC,MACjC,IAA4B;CAEhC,SAAS,IAAe;EACtB,IAAM,IAAS;EAEf,AADA,IAAO,MACP,IAAS;CACX;CAEA,IAAI;CACJ,IAAI;EACF,IAAU,EAAoB,GAAQ;GACpC;GACA;GACA;GACA,WAAW,MAAW;IAEpB,AADI,EAAO,YAAS,IAAU,EAAO,UACrC,EAAO;GACT;GACA,iBAAiB,MAAW;IAO1B,IAAM,IACJ,MAAW,SAAS,SAAS,MAAW,UAAU,MAAW,eAAe,YAAY;IAC1F,AAAI,MAAS,MACX,IAAQ,GACR,EAAO;GAEX;GACA,UAAU,MAAU;IAClB,IAAI;KACF,IAAmB,CAAK;IAC1B,QAAQ,CAER;GACF;EACF,CAAC;CACH,QAAQ;EAEN,OAAO;CACT;CAEA,OAAO;EACL,aAAa;EACb,YAAY;GACV,IAAM,IAAS;GAEf,OADA,IAAU,MACH;EACT;EACA,OAAO,GAAW,MAChB,IAAI,SAAe,MAAY;GAC7B,IAAI,IAAU,IACR,UAAqB;IACrB,MACJ,IAAU,IACV,aAAa,CAAK,GAClB,GAAQ,oBAAoB,SAAS,CAAM,GAC3C,IAAO,MACP,EAAQ;GACV,GACM,IAAQ,WAAW,GAAQ,CAAS;GAE1C,AADA,IAAO,GACP,GAAQ,iBAAiB,SAAS,GAAQ,EAAE,MAAM,GAAK,CAAC;EAC1D,CAAC;EACH,aAAa;GAEX,AADA,IAAO,MACP,EAAQ;EACV;CACF;AACF"}

package/dist/gasless/query-poll-delay.d.ts

@@ -0,0 +1,39 @@
+import { GaslessRequestStatus } from './types.js';
+/**
+ * The slice of a TanStack query's state the poll jitter is seeded from. Both
+ * fields are millisecond timestamps that move on every settled fetch.
+ */
+interface GaslessPollSeedState {
+    dataUpdatedAt?: number;
+    errorUpdatedAt?: number;
+}
+/**
+ * The jittered poll delay for a query's current state: stable between renders,
+ * redrawn after every fetch.
+ *
+ * A `refetchInterval` callback must **not** return a fresh random number on
+ * every call. TanStack recomputes it inside `QueryObserver.setOptions` and
+ * restarts the countdown whenever the value differs from the running one, and
+ * React calls `setOptions` on every render. A `Math.random()` delay therefore
+ * restarts the timer on each render, so a component that re-renders faster than
+ * the band — a price tick, a relay-progress publish, StrictMode — fetches once
+ * and never polls again: exactly the frozen-at-`queued` UI this cadence exists
+ * to prevent.
+ *
+ * Seeding the draw with the timestamps of the last settled fetch keeps the
+ * jitter that the shared anonymous budget needs — every fetch moves the seed,
+ * so every poll draws again — while the value stays constant for as long as
+ * nothing has been fetched.
+ *
+ * @param status - The last known request status, or `undefined` before the first fetch.
+ * @param state - The query's `state`; only its update timestamps are read.
+ * @returns Milliseconds until the next poll, or `false` once the record is terminal.
+ *
+ * @example
+ * ```ts
+ * refetchInterval: (query) => gaslessQueryPollDelay(query.state.data?.status, query.state);
+ * ```
+ */
+export declare function gaslessQueryPollDelay(status: GaslessRequestStatus | undefined, state: GaslessPollSeedState): number | false;
+export {};
+//# sourceMappingURL=query-poll-delay.d.ts.map

package/dist/gasless/query-poll-delay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-poll-delay.d.ts","sourceRoot":"","sources":["../../src/gasless/query-poll-delay.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEtE;;;GAGG;AACH,UAAU,oBAAoB;IAC5B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,oBAAoB,GAAG,SAAS,EACxC,KAAK,EAAE,oBAAoB,GAC1B,MAAM,GAAG,KAAK,CAGhB"}

package/dist/gasless/query-poll-delay.js

@@ -0,0 +1,14 @@
+import { gaslessPollDelay as e } from "./types.js";
+//#region src/gasless/query-poll-delay.ts
+function t(e) {
+	let t = e + 1831565813 | 0;
+	return t = Math.imul(t ^ t >>> 15, t | 1), t ^= t + Math.imul(t ^ t >>> 7, t | 61), ((t ^ t >>> 14) >>> 0) / 4294967296;
+}
+function n(n, r) {
+	let i = t((r.dataUpdatedAt ?? 0) ^ (r.errorUpdatedAt ?? 0));
+	return e(n, () => i);
+}
+//#endregion
+export { n as gaslessQueryPollDelay };
+
+//# sourceMappingURL=query-poll-delay.js.map

package/dist/gasless/query-poll-delay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-poll-delay.js","names":[],"sources":["../../src/gasless/query-poll-delay.ts"],"sourcesContent":["import { gaslessPollDelay, type GaslessRequestStatus } from \"./types\";\n\n/**\n * The slice of a TanStack query's state the poll jitter is seeded from. Both\n * fields are millisecond timestamps that move on every settled fetch.\n */\ninterface GaslessPollSeedState {\n  dataUpdatedAt?: number;\n  errorUpdatedAt?: number;\n}\n\n/**\n * One deterministic draw in `[0, 1)` from an integer seed — a single mulberry32\n * mixing step. The same seed always yields the same number, which is the whole\n * point here.\n */\nfunction seededDraw(seed: number): number {\n  let t = (seed + 0x6d2b79f5) | 0;\n  t = Math.imul(t ^ (t >>> 15), t | 1);\n  t ^= t + Math.imul(t ^ (t >>> 7), t | 61);\n  return ((t ^ (t >>> 14)) >>> 0) / 4_294_967_296;\n}\n\n/**\n * The jittered poll delay for a query's current state: stable between renders,\n * redrawn after every fetch.\n *\n * A `refetchInterval` callback must **not** return a fresh random number on\n * every call. TanStack recomputes it inside `QueryObserver.setOptions` and\n * restarts the countdown whenever the value differs from the running one, and\n * React calls `setOptions` on every render. A `Math.random()` delay therefore\n * restarts the timer on each render, so a component that re-renders faster than\n * the band — a price tick, a relay-progress publish, StrictMode — fetches once\n * and never polls again: exactly the frozen-at-`queued` UI this cadence exists\n * to prevent.\n *\n * Seeding the draw with the timestamps of the last settled fetch keeps the\n * jitter that the shared anonymous budget needs — every fetch moves the seed,\n * so every poll draws again — while the value stays constant for as long as\n * nothing has been fetched.\n *\n * @param status - The last known request status, or `undefined` before the first fetch.\n * @param state - The query's `state`; only its update timestamps are read.\n * @returns Milliseconds until the next poll, or `false` once the record is terminal.\n *\n * @example\n * ```ts\n * refetchInterval: (query) => gaslessQueryPollDelay(query.state.data?.status, query.state);\n * ```\n */\nexport function gaslessQueryPollDelay(\n  status: GaslessRequestStatus | undefined,\n  state: GaslessPollSeedState,\n): number | false {\n  const draw = seededDraw((state.dataUpdatedAt ?? 0) ^ (state.errorUpdatedAt ?? 0));\n  return gaslessPollDelay(status, () => draw);\n}\n"],"mappings":";;AAgBA,SAAS,EAAW,GAAsB;CACxC,IAAI,IAAK,IAAO,aAAc;CAG9B,OAFA,IAAI,KAAK,KAAK,IAAK,MAAM,IAAK,IAAI,CAAC,GACnC,KAAK,IAAI,KAAK,KAAK,IAAK,MAAM,GAAI,IAAI,EAAE,KAC/B,IAAK,MAAM,QAAS,KAAK;AACpC;AA6BA,SAAgB,EACd,GACA,GACgB;CAChB,IAAM,IAAO,GAAY,EAAM,iBAAiB,MAAM,EAAM,kBAAkB,EAAE;CAChF,OAAO,EAAiB,SAAc,CAAI;AAC5C"}

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

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

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../src/gasless/relay-gasless-batch/query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAEL,KAAK,2BAA2B,EAChC,KAAK,2BAA2B,EACjC,MAAM,uBAAuB,CAAC;AAE/B;;;;;;;;;;GAUG;AACH,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,MAAM;;4BAGnC,2BAA2B,KAAG,OAAO,CAAC,2BAA2B,CAAC;EAG7F"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"query.js","names":[],"sources":["../../../src/gasless/relay-gasless-batch/query.ts"],"sourcesContent":["import type { Config } from \"../../core/config\";\nimport {\n  relayGaslessBatch,\n  type RelayGaslessBatchParameters,\n  type RelayGaslessBatchReturnType,\n} from \"./relay-gasless-batch\";\n\n/**\n * Build TanStack Mutation options for {@link relayGaslessBatch}.\n *\n * @param config - The SDK config.\n * @returns Options to pass to `useMutation`.\n *\n * @example\n * ```ts\n * useMutation(relayGaslessBatchMutationOptions(config));\n * ```\n */\nexport function relayGaslessBatchMutationOptions(config: Config) {\n  return {\n    mutationKey: [\"relayGaslessBatch\"] as const,\n    mutationFn: (variables: RelayGaslessBatchParameters): Promise<RelayGaslessBatchReturnType> =>\n      relayGaslessBatch(config, variables),\n  };\n}\n"],"mappings":";;AAkBA,SAAgB,EAAiC,GAAgB;CAC/D,OAAO;EACL,aAAa,CAAC,mBAAmB;EACjC,aAAa,MACX,EAAkB,GAAQ,CAAS;CACvC;AACF"}

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

@@ -0,0 +1,106 @@
+import { Address } from 'viem';
+import { Config } from '../../core/config/index.js';
+import { ChainIdParameter, Compute, FromParameter } from '../../shared/types/properties.js';
+import { GaslessBatchCall } from '../batch/calls.js';
+import { GaslessSubmitReceipt } from '../types.js';
+/**
+ * Parameters for {@link relayGaslessBatch}.
+ */
+export type RelayGaslessBatchParameters = Compute<ChainIdParameter & FromParameter & {
+    /**
+     * The sub-account every operation runs under: the `signerAccount` of each
+     * relayable write, whose InstantLayer nonces the batch consumes and whose
+     * delegations authorize a session key; the billing account (a virtual
+     * account bills its parent); and, for GaslessWallet entries, the account
+     * whose owner's wallets execute — `ownerOf(account)`, so a sub-account
+     * resolves to its owner's wallets.
+     *
+     * Margin writes run under the virtual account's **parent** sub-account,
+     * with the virtual account as a calldata argument.
+     */
+    account: Address;
+    /**
+     * The calls, in execution order. The batch is **atomic**: one revert rolls
+     * back every call and every fee. Each is signed separately — the protocol
+     * has no batch signature — so a browser wallet shows one prompt per call,
+     * while a session key signs them silently.
+     */
+    calls: readonly GaslessBatchCall[];
+    /**
+     * Free-form workflow label (1-128 characters) stored with the request for
+     * metrics and vendor support. Defaults to the calls' own labels joined with
+     * `+` (`"approveOperationalFee+allocate"`), or `"gaslessBatch"` when that is
+     * too long. Fees are **not** keyed from it.
+     */
+    operationType?: string;
+    /** Non-secret client correlation data stored with the request. */
+    metadata?: Record<string, unknown>;
+}>;
+/** Return type of {@link relayGaslessBatch}. */
+export type RelayGaslessBatchReturnType = GaslessSubmitReceipt;
+/**
+ * Relay **several gasless actions as one request** — one atomic transaction the
+ * GaslessQ relayer broadcasts and pays gas for.
+ *
+ * Give each relayable write as `{ functionName, args }` (with an optional
+ * `abi`) or raw `{ data }` — the target contract is resolved from its selector —
+ * and calls the owner's GaslessWallet makes as `{ walletCalls, walletId }`. The
+ * forms mix freely:
+ *
+ * 1. every call is encoded and checked before any network call — a write the
+ *    relayer cannot carry throws `GASLESS_NOT_RELAYABLE`;
+ * 2. a session key's delegations are checked before any prompt
+ *    (`execution.preflightDelegation`, default on);
+ * 3. fresh nonces are read and sequenced per stream — the account's InstantLayer
+ *    nonces for the writes, each wallet id's own nonces for its entries;
+ * 4. the batch is priced on-chain before any prompt (`execution.preflightFee`,
+ *    default on) — a quote the contract refuses throws, a quote that fails for
+ *    transport reasons does not block;
+ * 5. each operation is signed — one EIP-712 prompt per call, in order;
+ * 6. one `relay-instant` request carries them all, with one wallet id per
+ *    operation (`0` for every write).
+ *
+ * The fee is collected **after** the whole batch executes, so an operational-fee
+ * approval earlier in the batch already covers the calls after it. Preview the
+ * same calls with {@link getGaslessBatchFeeQuote}.
+ *
+ * Fire-and-forget, like {@link relayInstantOperations}: persist the receipt's
+ * `requestId`, `owner`, `walletIds` and `idempotencyKey`, then follow the
+ * request to a terminal status. A `202` is the point of no return. React
+ * consumers should reach for `useRelayGaslessBatch`, which confirms the request
+ * before it resolves.
+ *
+ * @param config - The SDK config (must have a `getWalletClient` resolver).
+ * @param parameters - The account, the calls, and optional chain / signer / label overrides.
+ * @returns The acceptance receipt; persist it immediately.
+ * @throws {SymmError} `GASLESS_NOT_CONFIGURED` / `GASLESS_UNSUPPORTED_CONTRACTS_VERSION`.
+ * @throws {SymmError} `GASLESS_EMPTY_BATCH`, `GASLESS_NOT_RELAYABLE` or `GASLESS_WALLET_ID_INVALID`
+ *   before any network call.
+ * @throws {SymmError} `GASLESS_CONFIG_INCOHERENT` when the GaslessLayer verifies another InstantLayer.
+ * @throws {SymmError} `GASLESS_SIGNER_NOT_DELEGATED` when a session key is missing a selector —
+ *   grant `getGaslessBatchSelectors(calls)` on `account`.
+ * @throws {SymmError} `GASLESS_FREE_QUOTA_EXHAUSTED`, `GASLESS_FEE_QUOTE_REVERTED` or
+ *   `GASLESS_LAYER_INTERFACE_UNSUPPORTED` from the fee pre-flight, before any prompt.
+ * @throws {SymmError} `GASLESS_NONCE_STREAM_BUSY` when an earlier relay on one of the
+ *   batch's nonce streams is still unaccounted for.
+ * @throws {SymmApiError} `GASLESS_RELAY_SUBMIT_FAILED` on HTTP failure, and
+ *   `GASLESS_SUBMIT_UNCONFIRMED` when the outcome could not be established — replay it with
+ *   `resubmitGaslessRequest`, never by signing the batch again.
+ * @throws The wallet's own error when the user rejects a prompt; nothing is submitted.
+ *
+ * @example
+ * ```ts
+ * import { relayGaslessBatch } from "@symmio/trading-core";
+ *
+ * // Approve the gateway's fee allowance and use it in the same request.
+ * const receipt = await relayGaslessBatch(config, {
+ *   account: subAccount,
+ *   calls: [
+ *     { functionName: "approveOperationalFeeWithMultiplier", args: [[gaslessLayer], [budget18], [10_000n]] },
+ *     { functionName: "allocate", args: [amount] },
+ *   ],
+ * });
+ * ```
+ */
+export declare function relayGaslessBatch(config: Config, parameters: RelayGaslessBatchParameters): Promise<RelayGaslessBatchReturnType>;
+//# sourceMappingURL=relay-gasless-batch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"relay-gasless-batch.d.ts","sourceRoot":"","sources":["../../../src/gasless/relay-gasless-batch/relay-gasless-batch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,OAAO,EAAY,MAAM,MAAM,CAAC;AAC9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAK9F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AA0BvD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAQrD;;GAEG;AACH,MAAM,MAAM,2BAA2B,GAAG,OAAO,CAC/C,gBAAgB,GACd,aAAa,GAAG;IACd;;;;;;;;;;OAUG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;;;OAKG;IACH,KAAK,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACnC;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,kEAAkE;IAClE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC,CACJ,CAAC;AAEF,gDAAgD;AAChD,MAAM,MAAM,2BAA2B,GAAG,oBAAoB,CAAC;AAE/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,2BAA2B,GACtC,OAAO,CAAC,2BAA2B,CAAC,CAyKtC"}

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

@@ -0,0 +1,145 @@
+import { SymmError as e } from "../../shared/errors/symm-error.js";
+import { generateSalt as t } from "../../solvers/instant-open/shared/operations.js";
+import { getInstantLayerNonce as n } from "../../symmio-contracts/instant-layer/actions/get-instant-layer-nonce.js";
+import { assertGaslessGatewayCoherence as r } from "../assert-gateway-coherence.js";
+import { getIsDelegationActive as i } from "../../symmio-contracts/instant-layer/actions/get-is-delegation-active.js";
+import { findUndelegatedGaslessSelectors as a, getCachedGaslessAccountOwner as o } from "../delegation-preflight.js";
+import { resolveGaslessService as s } from "../resolve-gasless.js";
+import { generateGaslessIdempotencyKey as c, postGaslessSubmit as l, resolveGaslessHttp as u } from "../http.js";
+import { toGaslessWalletIdWire as d } from "../wallet-id.js";
+import { getGaslessFeeQuote as f } from "../get-gasless-fee-quote/get-gasless-fee-quote.js";
+import { toGaslessSubmitReceipt as p } from "../to-gasless-submit-receipt.js";
+import { blocksGaslessNonceStream as m, gaslessInstantNonceStreamKey as h, gaslessWalletNonceStreamKey as g, readGaslessStreamNonce as _, submitOnGaslessNonceStreams as v, withGaslessNonceLocks as y } from "../nonce-lock.js";
+import { formatGaslessOperation as b } from "../format-gasless-operation.js";
+import { getGaslessWalletExecuteSelectors as x } from "../gasless-wallet-execute/selectors.js";
+import { getGaslessWalletNonce as S } from "../get-gasless-wallet-nonce/get-gasless-wallet-nonce.js";
+import { resolveGaslessWalletIdentities as C } from "../resolve-wallet-identities.js";
+import { buildGaslessBatchOperations as w, defaultGaslessBatchOperationType as T, distinctGaslessBatchWalletIds as E, readGaslessBatchWalletTargets as D, resolveGaslessBatchEntries as O } from "../batch/resolve-gasless-batch.js";
+import { signGaslessBatchOperations as k } from "./sign-gasless-batch.js";
+import { isAddressEqual as A } from "viem";
+//#region src/gasless/relay-gasless-batch/relay-gasless-batch.ts
+var j = 1200;
+async function M(i, x) {
+	let { account: S, calls: A, from: M, metadata: F } = x, I = s(i, { chainId: x.chainId }), L = i.getChainConfig(x.chainId), R = L.chainId, z = O(L.addresses, A), B = x.operationType ?? T(z), V = u(i, {
+		chainId: R,
+		service: "operations"
+	}), H = I.execution ?? {}, U = z.flatMap((e) => e.type === "instant" ? [e.selector] : []), W = E(z);
+	U.length > 0 && await r(i, R, I);
+	let G = await i.getWalletClient({
+		chainId: R,
+		from: M
+	}), K = G.account.address, q = W.length > 0 ? await C(i, {
+		chainId: R,
+		account: S
+	}) : null;
+	if (H.preflightDelegation ?? !0) {
+		let t = [...U.length > 0 ? await a(i, {
+			chainId: R,
+			signer: K,
+			signerAccount: S,
+			selectors: U
+		}) : [], ...q ? await P(i, {
+			chainId: R,
+			signer: K,
+			identities: q,
+			entries: z
+		}) : []];
+		if (t.length > 0) throw new e("validation", "GASLESS_SIGNER_NOT_DELEGATED", `Gasless: signer ${K} holds no active InstantLayer delegation from ${S} for selector(s) ${[...new Set(t)].join(", ")}. Grant getGaslessBatchSelectors(calls) to the session key on ${S}, or sign the batch with the account's owner.`);
+	}
+	let J = q?.ownerWallet ?? await o(i, R, S).catch(() => null) ?? K, Y = U.length > 0 ? h(R, S) : null, X = new Map(W.map((e) => [e, g(R, e, J, S)]));
+	return y(i, [...Y === null ? [] : [Y], ...X.values()], async () => {
+		let [r, a, o] = await Promise.all([
+			Y === null ? 0n : _(i, Y, () => n(i, {
+				chainId: R,
+				account: S
+			})),
+			D(i, {
+				chainId: R,
+				owner: J,
+				walletIds: W
+			}),
+			N(i, {
+				chainId: R,
+				owner: J,
+				account: S,
+				walletKeys: X
+			})
+		]), s = BigInt(Math.floor(Date.now() / 1e3) + j), u = w(z, {
+			signer: K,
+			account: S,
+			deadline: s,
+			instantNonce: r,
+			walletTargets: a,
+			walletNonces: o,
+			salt: t
+		});
+		if (H.preflightFee ?? !0) try {
+			await f(i, {
+				chainId: R,
+				operations: u.operations.map((e, t) => ({
+					operation: e,
+					walletId: u.walletIds[t]
+				}))
+			});
+		} catch (t) {
+			if (t instanceof e) throw t;
+		}
+		let h = await k(i, {
+			chainId: R,
+			walletClient: G,
+			entries: z,
+			operations: u.operations
+		}), g = c(), y = {
+			idempotencyKey: g,
+			userAddress: J,
+			accountId: S,
+			operationType: B,
+			signedOps: u.operations.map(b),
+			signatures: h,
+			walletIds: u.walletIds.map(d),
+			fills: u.operations.map(() => []),
+			flexFillerSignatures: u.operations.map(() => []),
+			...F === void 0 ? {} : { metadata: F }
+		};
+		return v(i, [...Y === null || u.lastInstantNonce === null ? [] : [{
+			key: Y,
+			signedNonce: u.lastInstantNonce
+		}], ...[...X].map(([e, t]) => ({
+			key: t,
+			signedNonce: u.lastWalletNonces.get(e) ?? 0n
+		}))], {
+			service: "operations",
+			chainId: R,
+			deadline: s
+		}, async () => p(await l(V, "/gateway/relay-instant", y, g), {
+			owner: J,
+			walletIds: u.walletIds,
+			idempotencyKey: g,
+			protocolInstance: V.protocolInstance
+		}), m);
+	});
+}
+async function N(e, t) {
+	let { chainId: n, owner: r, account: i, walletKeys: a } = t, o = await Promise.all([...a].map(async ([t, a]) => [t, await _(e, a, () => S(e, {
+		chainId: n,
+		owner: r,
+		walletId: t,
+		account: i
+	}))]));
+	return new Map(o);
+}
+async function P(e, t) {
+	let { chainId: n, signer: r, identities: a, entries: o } = t;
+	if (A(r, a.ownerWallet)) return [];
+	let s = [...new Set(o.flatMap((e) => e.type === "wallet" ? x(e.walletCalls) : []))], c = await Promise.all(s.map((t) => i(e, {
+		chainId: n,
+		account: a.canonicalAccount,
+		delegate: r,
+		selector: t
+	})));
+	return s.filter((e, t) => !c[t]);
+}
+//#endregion
+export { M as relayGaslessBatch };
+
+//# sourceMappingURL=relay-gasless-batch.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"relay-gasless-batch.js","names":[],"sources":["../../../src/gasless/relay-gasless-batch/relay-gasless-batch.ts"],"sourcesContent":["import { isAddressEqual, type Address, type Hex } from \"viem\";\nimport type { Config } from \"../../core/config\";\nimport { SymmError } from \"../../shared/errors/symm-error\";\nimport type { ChainIdParameter, Compute, FromParameter } from \"../../shared/types/properties\";\nimport { generateSalt } from \"../../solvers/instant-open/shared/operations\";\nimport { getInstantLayerNonce } from \"../../symmio-contracts/instant-layer/actions/get-instant-layer-nonce\";\nimport { getIsDelegationActive } from \"../../symmio-contracts/instant-layer/actions/get-is-delegation-active\";\nimport { assertGaslessGatewayCoherence } from \"../assert-gateway-coherence\";\nimport type { GaslessBatchCall } from \"../batch/calls\";\nimport {\n  buildGaslessBatchOperations,\n  defaultGaslessBatchOperationType,\n  distinctGaslessBatchWalletIds,\n  readGaslessBatchWalletTargets,\n  resolveGaslessBatchEntries,\n  type ResolvedGaslessBatchEntry,\n} from \"../batch/resolve-gasless-batch\";\nimport { findUndelegatedGaslessSelectors, getCachedGaslessAccountOwner } from \"../delegation-preflight\";\nimport { formatGaslessOperation } from \"../format-gasless-operation\";\nimport { getGaslessWalletExecuteSelectors } from \"../gasless-wallet-execute/selectors\";\nimport { getGaslessFeeQuote } from \"../get-gasless-fee-quote/get-gasless-fee-quote\";\nimport { getGaslessWalletNonce } from \"../get-gasless-wallet-nonce/get-gasless-wallet-nonce\";\nimport { generateGaslessIdempotencyKey, postGaslessSubmit, resolveGaslessHttp } from \"../http\";\nimport {\n  blocksGaslessNonceStream,\n  gaslessInstantNonceStreamKey,\n  gaslessWalletNonceStreamKey,\n  readGaslessStreamNonce,\n  submitOnGaslessNonceStreams,\n  withGaslessNonceLocks,\n} from \"../nonce-lock\";\nimport { resolveGaslessService } from \"../resolve-gasless\";\nimport { resolveGaslessWalletIdentities, type GaslessWalletIdentities } from \"../resolve-wallet-identities\";\nimport { toGaslessSubmitReceipt } from \"../to-gasless-submit-receipt\";\nimport type { GaslessSubmitReceipt } from \"../types\";\nimport { toGaslessWalletIdWire } from \"../wallet-id\";\nimport type { GaslessWireOperationAccepted, GaslessWireRelayInstantRequest } from \"../wire-types\";\nimport { signGaslessBatchOperations } from \"./sign-gasless-batch\";\n\n/** How long a batch's signatures stay valid — room for one wallet prompt per operation. */\nconst GASLESS_BATCH_DEADLINE_SECONDS = 20 * 60;\n\n/**\n * Parameters for {@link relayGaslessBatch}.\n */\nexport type RelayGaslessBatchParameters = Compute<\n  ChainIdParameter &\n    FromParameter & {\n      /**\n       * The sub-account every operation runs under: the `signerAccount` of each\n       * relayable write, whose InstantLayer nonces the batch consumes and whose\n       * delegations authorize a session key; the billing account (a virtual\n       * account bills its parent); and, for GaslessWallet entries, the account\n       * whose owner's wallets execute — `ownerOf(account)`, so a sub-account\n       * resolves to its owner's wallets.\n       *\n       * Margin writes run under the virtual account's **parent** sub-account,\n       * with the virtual account as a calldata argument.\n       */\n      account: Address;\n      /**\n       * The calls, in execution order. The batch is **atomic**: one revert rolls\n       * back every call and every fee. Each is signed separately — the protocol\n       * has no batch signature — so a browser wallet shows one prompt per call,\n       * while a session key signs them silently.\n       */\n      calls: readonly GaslessBatchCall[];\n      /**\n       * Free-form workflow label (1-128 characters) stored with the request for\n       * metrics and vendor support. Defaults to the calls' own labels joined with\n       * `+` (`\"approveOperationalFee+allocate\"`), or `\"gaslessBatch\"` when that is\n       * too long. Fees are **not** keyed from it.\n       */\n      operationType?: string;\n      /** Non-secret client correlation data stored with the request. */\n      metadata?: Record<string, unknown>;\n    }\n>;\n\n/** Return type of {@link relayGaslessBatch}. */\nexport type RelayGaslessBatchReturnType = GaslessSubmitReceipt;\n\n/**\n * Relay **several gasless actions as one request** — one atomic transaction the\n * GaslessQ relayer broadcasts and pays gas for.\n *\n * Give each relayable write as `{ functionName, args }` (with an optional\n * `abi`) or raw `{ data }` — the target contract is resolved from its selector —\n * and calls the owner's GaslessWallet makes as `{ walletCalls, walletId }`. The\n * forms mix freely:\n *\n * 1. every call is encoded and checked before any network call — a write the\n *    relayer cannot carry throws `GASLESS_NOT_RELAYABLE`;\n * 2. a session key's delegations are checked before any prompt\n *    (`execution.preflightDelegation`, default on);\n * 3. fresh nonces are read and sequenced per stream — the account's InstantLayer\n *    nonces for the writes, each wallet id's own nonces for its entries;\n * 4. the batch is priced on-chain before any prompt (`execution.preflightFee`,\n *    default on) — a quote the contract refuses throws, a quote that fails for\n *    transport reasons does not block;\n * 5. each operation is signed — one EIP-712 prompt per call, in order;\n * 6. one `relay-instant` request carries them all, with one wallet id per\n *    operation (`0` for every write).\n *\n * The fee is collected **after** the whole batch executes, so an operational-fee\n * approval earlier in the batch already covers the calls after it. Preview the\n * same calls with {@link getGaslessBatchFeeQuote}.\n *\n * Fire-and-forget, like {@link relayInstantOperations}: persist the receipt's\n * `requestId`, `owner`, `walletIds` and `idempotencyKey`, then follow the\n * request to a terminal status. A `202` is the point of no return. React\n * consumers should reach for `useRelayGaslessBatch`, which confirms the request\n * before it resolves.\n *\n * @param config - The SDK config (must have a `getWalletClient` resolver).\n * @param parameters - The account, the calls, and optional chain / signer / label overrides.\n * @returns The acceptance receipt; persist it immediately.\n * @throws {SymmError} `GASLESS_NOT_CONFIGURED` / `GASLESS_UNSUPPORTED_CONTRACTS_VERSION`.\n * @throws {SymmError} `GASLESS_EMPTY_BATCH`, `GASLESS_NOT_RELAYABLE` or `GASLESS_WALLET_ID_INVALID`\n *   before any network call.\n * @throws {SymmError} `GASLESS_CONFIG_INCOHERENT` when the GaslessLayer verifies another InstantLayer.\n * @throws {SymmError} `GASLESS_SIGNER_NOT_DELEGATED` when a session key is missing a selector —\n *   grant `getGaslessBatchSelectors(calls)` on `account`.\n * @throws {SymmError} `GASLESS_FREE_QUOTA_EXHAUSTED`, `GASLESS_FEE_QUOTE_REVERTED` or\n *   `GASLESS_LAYER_INTERFACE_UNSUPPORTED` from the fee pre-flight, before any prompt.\n * @throws {SymmError} `GASLESS_NONCE_STREAM_BUSY` when an earlier relay on one of the\n *   batch's nonce streams is still unaccounted for.\n * @throws {SymmApiError} `GASLESS_RELAY_SUBMIT_FAILED` on HTTP failure, and\n *   `GASLESS_SUBMIT_UNCONFIRMED` when the outcome could not be established — replay it with\n *   `resubmitGaslessRequest`, never by signing the batch again.\n * @throws The wallet's own error when the user rejects a prompt; nothing is submitted.\n *\n * @example\n * ```ts\n * import { relayGaslessBatch } from \"@symmio/trading-core\";\n *\n * // Approve the gateway's fee allowance and use it in the same request.\n * const receipt = await relayGaslessBatch(config, {\n *   account: subAccount,\n *   calls: [\n *     { functionName: \"approveOperationalFeeWithMultiplier\", args: [[gaslessLayer], [budget18], [10_000n]] },\n *     { functionName: \"allocate\", args: [amount] },\n *   ],\n * });\n * ```\n */\nexport async function relayGaslessBatch(\n  config: Config,\n  parameters: RelayGaslessBatchParameters,\n): Promise<RelayGaslessBatchReturnType> {\n  const { account, calls, from, metadata } = parameters;\n  const gasless = resolveGaslessService(config, { chainId: parameters.chainId });\n  const chain = config.getChainConfig(parameters.chainId);\n  const chainId = chain.chainId;\n\n  const entries = resolveGaslessBatchEntries(chain.addresses, calls);\n  const operationType = parameters.operationType ?? defaultGaslessBatchOperationType(entries);\n  const context = resolveGaslessHttp(config, { chainId, service: \"operations\" });\n  const execution = gasless.execution ?? {};\n\n  const instantSelectors = entries.flatMap((entry) => (entry.type === \"instant\" ? [entry.selector] : []));\n  const walletIds = distinctGaslessBatchWalletIds(entries);\n\n  /** Relayable writes sign for the configured InstantLayer; make sure the gateway verifies that one. */\n  if (instantSelectors.length > 0) await assertGaslessGatewayCoherence(config, chainId, gasless);\n\n  const walletClient = await config.getWalletClient({ chainId, from });\n  const signer = walletClient.account.address;\n\n  const identities = walletIds.length > 0 ? await resolveGaslessWalletIdentities(config, { chainId, account }) : null;\n\n  /**\n   * Delegation pre-flight, before any signature prompt: a session key missing a\n   * selector would otherwise sign every operation, and the relayer's simulation\n   * would reject the batch after the user paid for the prompts.\n   */\n  if (execution.preflightDelegation ?? true) {\n    const missing = [\n      ...(instantSelectors.length > 0\n        ? await findUndelegatedGaslessSelectors(config, {\n            chainId,\n            signer,\n            signerAccount: account,\n            selectors: instantSelectors,\n          })\n        : []),\n      ...(identities ? await findUndelegatedWalletSelectors(config, { chainId, signer, identities, entries }) : []),\n    ];\n    if (missing.length > 0) {\n      throw new SymmError(\n        \"validation\",\n        \"GASLESS_SIGNER_NOT_DELEGATED\",\n        `Gasless: signer ${signer} holds no active InstantLayer delegation from ${account} for selector(s) ${[...new Set(missing)].join(\", \")}. Grant getGaslessBatchSelectors(calls) to the session key on ${account}, or sign the batch with the account's owner.`,\n      );\n    }\n  }\n\n  /**\n   * `userAddress` is the service's tracking identity: the owner of the account's\n   * wallets, else the sub-account's owner. The signer may be a session key that\n   * owns nothing, so an unreadable owner falls back to it rather than failing\n   * the batch over a tracking label.\n   */\n  const owner =\n    identities?.ownerWallet ??\n    (await getCachedGaslessAccountOwner(config, chainId, account).catch(() => null)) ??\n    signer;\n\n  const instantKey = instantSelectors.length > 0 ? gaslessInstantNonceStreamKey(chainId, account) : null;\n  const walletKeys = new Map(\n    walletIds.map((walletId) => [walletId, gaslessWalletNonceStreamKey(chainId, walletId, owner, account)] as const),\n  );\n  const streamKeys = [...(instantKey === null ? [] : [instantKey]), ...walletKeys.values()];\n\n  /**\n   * The locks span read-sign-submit on every stream the batch signs on. They are\n   * released at the `202`; the signed nonces are recorded on each stream so the\n   * next caller waits for them lazily instead of signing them again.\n   */\n  return withGaslessNonceLocks(config, streamKeys, async () => {\n    const [instantNonce, walletTargets, walletNonces] = await Promise.all([\n      instantKey === null\n        ? 0n\n        : readGaslessStreamNonce(config, instantKey, () => getInstantLayerNonce(config, { chainId, account })),\n      readGaslessBatchWalletTargets(config, { chainId, owner, walletIds }),\n      readWalletNonces(config, { chainId, owner, account, walletKeys }),\n    ]);\n\n    const deadline = BigInt(Math.floor(Date.now() / 1000) + GASLESS_BATCH_DEADLINE_SECONDS);\n    const built = buildGaslessBatchOperations(entries, {\n      signer,\n      account,\n      deadline,\n      instantNonce,\n      walletTargets,\n      walletNonces,\n      salt: generateSalt,\n    });\n\n    /** Fee pre-flight before any signature prompt. */\n    if (execution.preflightFee ?? true) {\n      try {\n        await getGaslessFeeQuote(config, {\n          chainId,\n          operations: built.operations.map((operation, index) => ({ operation, walletId: built.walletIds[index] })),\n        });\n      } catch (err) {\n        /**\n         * A refused quote — an exhausted free quota, a batch the contract\n         * rejects, a GaslessLayer without the quote interface — means the relay\n         * would fail the same way, and nothing is signed yet.\n         */\n        if (err instanceof SymmError) throw err;\n        /**\n         * Anything else is inconclusive: a transport or RPC failure of the quote\n         * read itself. The relayer simulates the full transaction before\n         * accepting it, so signing proceeds.\n         */\n      }\n    }\n\n    const signatures = await signGaslessBatchOperations(config, {\n      chainId,\n      walletClient,\n      entries,\n      operations: built.operations,\n    });\n\n    /**\n     * One key per signature: the operations were just signed, so the key is\n     * minted here. Replaying a lost response is `resubmitGaslessRequest`'s job,\n     * which reuses this key with the exact bytes that went with it.\n     */\n    const idempotencyKey = generateGaslessIdempotencyKey();\n    const body: GaslessWireRelayInstantRequest = {\n      idempotencyKey,\n      userAddress: owner,\n      accountId: account,\n      operationType,\n      signedOps: built.operations.map(formatGaslessOperation),\n      signatures,\n      walletIds: built.walletIds.map(toGaslessWalletIdWire),\n      fills: built.operations.map(() => []),\n      flexFillerSignatures: built.operations.map(() => []),\n      ...(metadata !== undefined ? { metadata } : {}),\n    };\n\n    const streams = [\n      ...(instantKey === null || built.lastInstantNonce === null\n        ? []\n        : [{ key: instantKey, signedNonce: built.lastInstantNonce }]),\n      ...[...walletKeys].map(([walletId, key]) => ({\n        key,\n        signedNonce: built.lastWalletNonces.get(walletId) ?? 0n,\n      })),\n    ];\n\n    return submitOnGaslessNonceStreams(\n      config,\n      streams,\n      { service: \"operations\", chainId, deadline },\n      async () => {\n        const raw = await postGaslessSubmit<GaslessWireOperationAccepted>(\n          context,\n          \"/gateway/relay-instant\",\n          body,\n          idempotencyKey,\n        );\n        return toGaslessSubmitReceipt(raw, {\n          owner,\n          walletIds: built.walletIds,\n          idempotencyKey,\n          protocolInstance: context.protocolInstance,\n        });\n      },\n      blocksGaslessNonceStream,\n    );\n  });\n}\n\n/**\n * The consumed wallet-operation nonce of each wallet a batch executes from,\n * waiting first for anything this SDK already signed on that stream.\n */\nasync function readWalletNonces(\n  config: Config,\n  parameters: { chainId: number; owner: Address; account: Address; walletKeys: ReadonlyMap<bigint, string> },\n): Promise<Map<bigint, bigint>> {\n  const { chainId, owner, account, walletKeys } = parameters;\n  const entries = await Promise.all(\n    [...walletKeys].map(\n      async ([walletId, key]) =>\n        [\n          walletId,\n          await readGaslessStreamNonce(config, key, () =>\n            getGaslessWalletNonce(config, { chainId, owner, walletId, account }),\n          ),\n        ] as const,\n    ),\n  );\n  return new Map(entries);\n}\n\n/**\n * The wallet-entry selectors a delegate may not relay: the GaslessLayer demands\n * a delegation for the wallet-execution sentinel **and every inner selector**,\n * on the account's canonical delegator. The wallet's owner needs none.\n */\nasync function findUndelegatedWalletSelectors(\n  config: Config,\n  parameters: {\n    chainId: number;\n    signer: Address;\n    identities: GaslessWalletIdentities;\n    entries: readonly ResolvedGaslessBatchEntry[];\n  },\n): Promise<Hex[]> {\n  const { chainId, signer, identities, entries } = parameters;\n  if (isAddressEqual(signer, identities.ownerWallet)) return [];\n\n  const required = [\n    ...new Set(\n      entries.flatMap((entry) => (entry.type === \"wallet\" ? getGaslessWalletExecuteSelectors(entry.walletCalls) : [])),\n    ),\n  ];\n  const active = await Promise.all(\n    required.map((selector) =>\n      getIsDelegationActive(config, { chainId, account: identities.canonicalAccount, delegate: signer, selector }),\n    ),\n  );\n  return required.filter((_, index) => !active[index]);\n}\n"],"mappings":"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"}