@symmio/trading-core 3.0.0 → 3.1.0

package/dist/gasless/classify-gasless-failure.js

@@ -0,0 +1,60 @@
+import { gaslessRevertText as e, parseGaslessErrorDetail as t } from "./errors.js";
+import { getGaslessUnconfirmedSubmit as n, isGaslessIdempotencyConflictError as r } from "./unconfirmed-submit.js";
+import { classifyGaslessHttpStatus as i } from "./http.js";
+import { isGaslessFreeQuotaExhaustedError as a } from "./get-gasless-fee-quote/fee-quote-errors.js";
+import { decodeErrorResult as o } from "viem";
+//#region src/gasless/classify-gasless-failure.ts
+function s(e) {
+	return e.includes("DailyFreeOpsLimitExceeded") ? "free-quota" : e.includes("OperationalFee: Insufficient balance") ? "payer-balance" : e.includes("OperationalFee: Allowance") || e.includes("OperationalFee: Insufficient allowance") ? "fee-allowance" : e.includes("FeeLimitExceeded") || e.includes("OperationalFee:") ? "fee-limit" : e.includes("DepositAmountBelowMinimum") ? "deposit-below-minimum" : e.includes("DepositAmountNotAboveFees") || e.includes("MinimumDepositNotAboveFee") ? "deposit-not-above-fees" : e.includes("InvalidNonce") || e.includes("DeadlineExpired") || e.includes("WalletOperationExpired") || e.includes("WalletOperationInvalidNonce") || e.includes("NativeGasTopUpNonceMismatch") ? "nonce-or-deadline" : null;
+}
+function c(e) {
+	switch (e) {
+		case "IDEMPOTENCY_KEY_CONFLICT": return "idempotency-conflict";
+		case "INSUFFICIENT_ALLOWANCE": return "fee-allowance";
+		case "FEE_POLICY_WOULD_REVERT": return "fee-limit";
+		case "DEPOSIT_BELOW_MINIMUM": return "deposit-below-minimum";
+		default: return null;
+	}
+}
+function l(e) {
+	switch (i(e)) {
+		case "rate-limited": return "rate-limited";
+		case "unauthorized": return "unauthorized";
+		case "forbidden": return "forbidden";
+		case "unknown-instance":
+		case "selector-conflict": return "unknown-instance";
+		case "client-schema": return "client-schema";
+		case "gateway-not-ready":
+		case "ambiguous": return "gateway-unavailable";
+		default: return null;
+	}
+}
+function u(i) {
+	if (n(i) !== null) return "submit-unconfirmed";
+	if (r(i)) return "idempotency-conflict";
+	if (a(i)) return "free-quota";
+	let o = t(i);
+	return s(e(o)) || (o?.failedOperation ? "failed-operation" : c(o?.code ?? null) || l(i) || (o?.code === "SIMULATION_REVERTED" ? "simulation-reverted" : "unknown"));
+}
+function d(e, n) {
+	let r = t(e)?.failedOperation;
+	if (!r) return null;
+	let i = null;
+	try {
+		i = o({
+			abi: n,
+			data: r.revertData
+		});
+	} catch {
+		i = null;
+	}
+	return {
+		index: r.index,
+		revertData: r.revertData,
+		decoded: i
+	};
+}
+//#endregion
+export { u as classifyGaslessFailure, d as decodeGaslessOperationFailure };
+
+//# sourceMappingURL=classify-gasless-failure.js.map

package/dist/gasless/classify-gasless-failure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify-gasless-failure.js","names":[],"sources":["../../src/gasless/classify-gasless-failure.ts"],"sourcesContent":["import { decodeErrorResult, type Abi, type DecodeErrorResultReturnType, type Hex } from \"viem\";\nimport { gaslessRevertText, parseGaslessErrorDetail } from \"./errors\";\nimport { isGaslessFreeQuotaExhaustedError } from \"./get-gasless-fee-quote/fee-quote-errors\";\nimport { classifyGaslessHttpStatus } from \"./http\";\nimport { getGaslessUnconfirmedSubmit, isGaslessIdempotencyConflictError } from \"./unconfirmed-submit\";\n\n/**\n * Why a gasless action failed, in terms of what a UI can do about it.\n *\n * Deliberately coarser than the vendor's codes and finer than the HTTP status:\n * `INSUFFICIENT_ALLOWANCE` and an `OperationalFee: Allowance exceeded` revert\n * are the same problem with two wire shapes, while a `404` for an unknown\n * instance and a `404` for an unknown request id are not the same problem at\n * all.\n *\n * - `\"payer-balance\"` — the billing account cannot cover the fee. Top up its\n *   SYMMIO collateral; raising the allowance alone does nothing.\n * - `\"fee-allowance\"` — the payer's operational-fee allowance is too low.\n *   Approve more with `approveOperationalFee`, then re-read.\n * - `\"free-quota\"` — the daily free-operations quota is spent and the\n *   deployment refuses paid ones. Wait for the UTC reset or use the wallet.\n * - `\"fee-limit\"` — the fee policy refused the request for any other reason.\n * - `\"failed-operation\"` — one entry of the batch reverted; decode it with\n *   {@link decodeGaslessOperationFailure} to name the real cause.\n * - `\"nonce-or-deadline\"` — the signature is stale. Refresh the nonce and\n *   deadline and ask for a new one; never resend the old payload.\n * - `\"deposit-below-minimum\"` — the deposit address holds less than the\n *   settlement minimum, or the funds are not visible yet.\n * - `\"deposit-not-above-fees\"` — the balance clears the minimum but not the\n *   deposit and wallet-creation fees.\n * - `\"idempotency-conflict\"` — the key belongs to another workflow; mint a new one.\n * - `\"client-schema\"` — a `422`: the payload's shape is wrong. A client bug.\n * - `\"rate-limited\"` / `\"unauthorized\"` / `\"forbidden\"` / `\"unknown-instance\"` /\n *   `\"gateway-unavailable\"` — the gateway answered, before any service saw it.\n * - `\"submit-unconfirmed\"` — the outcome is unknown and the request may be\n *   executing. Replay it with `resubmitGaslessRequest`; never re-run the intent.\n * - `\"simulation-reverted\"` — the service simulated the batch and it reverted\n *   for a reason none of the above explains. Rebuild and re-sign.\n * - `\"unknown\"` — nothing classified it.\n */\nexport type GaslessFailureReason =\n  | \"payer-balance\"\n  | \"fee-allowance\"\n  | \"free-quota\"\n  | \"fee-limit\"\n  | \"failed-operation\"\n  | \"nonce-or-deadline\"\n  | \"deposit-below-minimum\"\n  | \"deposit-not-above-fees\"\n  | \"idempotency-conflict\"\n  | \"client-schema\"\n  | \"rate-limited\"\n  | \"unauthorized\"\n  | \"forbidden\"\n  | \"unknown-instance\"\n  | \"gateway-unavailable\"\n  | \"submit-unconfirmed\"\n  | \"simulation-reverted\"\n  | \"unknown\";\n\n/**\n * Map a revert the service decoded onto a reason, when one of the contract's\n * own error names or require-strings is unambiguous about the cause.\n *\n * The error names come from the perps-core 0.8.6 GaslessLayer and InstantLayer\n * ABIs. The `\"OperationalFee: …\"` strings are not theirs — they are SymmioCore's\n * own `LibOperationalFee` require messages, raised when the GaslessLayer charges\n * the payer (the same ones `approveOperationalFee` documents), and they reach the\n * SDK through the service's simulation of the batch.\n */\nfunction reasonFromRevert(text: string): GaslessFailureReason | null {\n  if (text.includes(\"DailyFreeOpsLimitExceeded\")) return \"free-quota\";\n  if (text.includes(\"OperationalFee: Insufficient balance\")) return \"payer-balance\";\n  if (text.includes(\"OperationalFee: Allowance\") || text.includes(\"OperationalFee: Insufficient allowance\")) {\n    return \"fee-allowance\";\n  }\n  if (text.includes(\"FeeLimitExceeded\") || text.includes(\"OperationalFee:\")) return \"fee-limit\";\n  if (text.includes(\"DepositAmountBelowMinimum\")) return \"deposit-below-minimum\";\n  if (text.includes(\"DepositAmountNotAboveFees\") || text.includes(\"MinimumDepositNotAboveFee\")) {\n    return \"deposit-not-above-fees\";\n  }\n  if (\n    text.includes(\"InvalidNonce\") ||\n    text.includes(\"DeadlineExpired\") ||\n    text.includes(\"WalletOperationExpired\") ||\n    text.includes(\"WalletOperationInvalidNonce\") ||\n    text.includes(\"NativeGasTopUpNonceMismatch\")\n  ) {\n    return \"nonce-or-deadline\";\n  }\n  return null;\n}\n\n/** Map a vendor `detail.code` onto a reason, where the code alone decides. */\nfunction reasonFromVendorCode(code: string | null): GaslessFailureReason | null {\n  switch (code) {\n    case \"IDEMPOTENCY_KEY_CONFLICT\":\n      return \"idempotency-conflict\";\n    case \"INSUFFICIENT_ALLOWANCE\":\n      return \"fee-allowance\";\n    case \"FEE_POLICY_WOULD_REVERT\":\n      return \"fee-limit\";\n    case \"DEPOSIT_BELOW_MINIMUM\":\n      return \"deposit-below-minimum\";\n    default:\n      return null;\n  }\n}\n\n/** Map the gateway's own answer onto a reason. */\nfunction reasonFromHttpStatus(err: unknown): GaslessFailureReason | null {\n  switch (classifyGaslessHttpStatus(err)) {\n    case \"rate-limited\":\n      return \"rate-limited\";\n    case \"unauthorized\":\n      return \"unauthorized\";\n    case \"forbidden\":\n      return \"forbidden\";\n    case \"unknown-instance\":\n    case \"selector-conflict\":\n      return \"unknown-instance\";\n    case \"client-schema\":\n      return \"client-schema\";\n    case \"gateway-not-ready\":\n    case \"ambiguous\":\n      return \"gateway-unavailable\";\n    default:\n      return null;\n  }\n}\n\n/**\n * Classify any gasless failure into the one reason a UI should act on.\n *\n * The order is deliberate: what the request *did* (unconfirmed, conflicting)\n * outranks what the service *said*, which outranks what the gateway answered —\n * a `400 SIMULATION_REVERTED` whose revert names an allowance shortfall is an\n * allowance problem, not a \"bad request\".\n *\n * Works on the error a framework layer re-wrapped too, so a React hook's\n * `SymmioRequestError` classifies exactly like the `SymmApiError` under it.\n *\n * @param err - Anything caught from a gasless action, or a polled record error.\n * @returns The reason, or `\"unknown\"` when nothing identifies it.\n *\n * @example\n * ```ts\n * switch (classifyGaslessFailure(err)) {\n *   case \"fee-allowance\":\n *     return showApproveOperationalFee();\n *   case \"submit-unconfirmed\":\n *     return showReconcilePending(getGaslessUnconfirmedSubmit(err));\n *   default:\n *     return showDiagnostics(parseGaslessErrorDetail(err));\n * }\n * ```\n */\nexport function classifyGaslessFailure(err: unknown): GaslessFailureReason {\n  if (getGaslessUnconfirmedSubmit(err) !== null) return \"submit-unconfirmed\";\n  if (isGaslessIdempotencyConflictError(err)) return \"idempotency-conflict\";\n  /** Thrown by the fee pre-flight, before any HTTP call and with no vendor detail. */\n  if (isGaslessFreeQuotaExhaustedError(err)) return \"free-quota\";\n\n  const detail = parseGaslessErrorDetail(err);\n  const fromRevert = reasonFromRevert(gaslessRevertText(detail));\n  if (fromRevert) return fromRevert;\n  if (detail?.failedOperation) return \"failed-operation\";\n\n  const fromCode = reasonFromVendorCode(detail?.code ?? null);\n  if (fromCode) return fromCode;\n\n  const fromStatus = reasonFromHttpStatus(err);\n  if (fromStatus) return fromStatus;\n\n  return detail?.code === \"SIMULATION_REVERTED\" ? \"simulation-reverted\" : \"unknown\";\n}\n\n/**\n * The failing batch entry of an `OperationFailed` revert, with its inner revert\n * decoded against the ABI you supplied.\n */\nexport interface GaslessDecodedOperationFailure {\n  /** Zero-based position of the failing operation in the submitted batch. */\n  index: number;\n  /** The inner revert data, exactly as the service reported it. */\n  revertData: Hex;\n  /** The decoded error, or `null` when the ABI does not describe it. */\n  decoded: DecodeErrorResultReturnType | null;\n}\n\n/**\n * Identify the batch entry that reverted, and decode its inner revert.\n *\n * A relayed batch is atomic, so the InstantLayer reports an inner failure as\n * `OperationFailed(operationIndex, revertData)` — which names a position, not a\n * cause. Decoding `revertData` against the ABI of the contract that operation\n * targeted turns it back into the error the user can act on\n * (`InvalidNameLength`, `InsufficientBalance`, …).\n *\n * @param err - Anything caught from a gasless submit.\n * @param abi - ABI of the contract the failing operation targeted.\n * @returns The index, the raw revert data and the decoded error, or `null` when\n *   the failure was not an `OperationFailed`.\n *\n * @example\n * ```ts\n * const failure = decodeGaslessOperationFailure(err, accountLayerAbi);\n * if (failure) {\n *   console.error(`operation ${failure.index} reverted:`, failure.decoded?.errorName ?? failure.revertData);\n * }\n * ```\n */\nexport function decodeGaslessOperationFailure(err: unknown, abi: Abi): GaslessDecodedOperationFailure | null {\n  const failed = parseGaslessErrorDetail(err)?.failedOperation;\n  if (!failed) return null;\n\n  let decoded: DecodeErrorResultReturnType | null = null;\n  try {\n    decoded = decodeErrorResult({ abi, data: failed.revertData });\n  } catch {\n    /** An ABI that does not describe this error is a caller mistake, not a reason to lose the index. */\n    decoded = null;\n  }\n  return { index: failed.index, revertData: failed.revertData, decoded };\n}\n"],"mappings":";;;;;;AAsEA,SAAS,EAAiB,GAA2C;CAoBnE,OAnBI,EAAK,SAAS,2BAA2B,IAAU,eACnD,EAAK,SAAS,sCAAsC,IAAU,kBAC9D,EAAK,SAAS,2BAA2B,KAAK,EAAK,SAAS,wCAAwC,IAC/F,kBAEL,EAAK,SAAS,kBAAkB,KAAK,EAAK,SAAS,iBAAiB,IAAU,cAC9E,EAAK,SAAS,2BAA2B,IAAU,0BACnD,EAAK,SAAS,2BAA2B,KAAK,EAAK,SAAS,2BAA2B,IAClF,2BAGP,EAAK,SAAS,cAAc,KAC5B,EAAK,SAAS,iBAAiB,KAC/B,EAAK,SAAS,wBAAwB,KACtC,EAAK,SAAS,6BAA6B,KAC3C,EAAK,SAAS,6BAA6B,IAEpC,sBAEF;AACT;AAGA,SAAS,EAAqB,GAAkD;CAC9E,QAAQ,GAAR;EACE,KAAK,4BACH,OAAO;EACT,KAAK,0BACH,OAAO;EACT,KAAK,2BACH,OAAO;EACT,KAAK,yBACH,OAAO;EACT,SACE,OAAO;CACX;AACF;AAGA,SAAS,EAAqB,GAA2C;CACvE,QAAQ,EAA0B,CAAG,GAArC;EACE,KAAK,gBACH,OAAO;EACT,KAAK,gBACH,OAAO;EACT,KAAK,aACH,OAAO;EACT,KAAK;EACL,KAAK,qBACH,OAAO;EACT,KAAK,iBACH,OAAO;EACT,KAAK;EACL,KAAK,aACH,OAAO;EACT,SACE,OAAO;CACX;AACF;AA4BA,SAAgB,EAAuB,GAAoC;CACzE,IAAI,EAA4B,CAAG,MAAM,MAAM,OAAO;CACtD,IAAI,EAAkC,CAAG,GAAG,OAAO;CAEnD,IAAI,EAAiC,CAAG,GAAG,OAAO;CAElD,IAAM,IAAS,EAAwB,CAAG;CAW1C,OAVmB,EAAiB,EAAkB,CAAM,CACxD,MACA,GAAQ,kBAAwB,qBAEnB,EAAqB,GAAQ,QAAQ,IAClD,KAEe,EAAqB,CACpC,MAEG,GAAQ,SAAS,wBAAwB,wBAAwB;AAC1E;AAqCA,SAAgB,EAA8B,GAAc,GAAiD;CAC3G,IAAM,IAAS,EAAwB,CAAG,GAAG;CAC7C,IAAI,CAAC,GAAQ,OAAO;CAEpB,IAAI,IAA8C;CAClD,IAAI;EACF,IAAU,EAAkB;GAAE;GAAK,MAAM,EAAO;EAAW,CAAC;CAC9D,QAAQ;EAEN,IAAU;CACZ;CACA,OAAO;EAAE,OAAO,EAAO;EAAO,YAAY,EAAO;EAAY;CAAQ;AACvE"}

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

@@ -0,0 +1,121 @@
+import { Hash, TransactionReceipt } from 'viem';
+import { Config } from '../../core/config/index.js';
+import { SymmError } from '../../shared/errors/symm-error.js';
+import { ChainIdParameter, Compute } from '../../shared/types/properties.js';
+import { GaslessStatusTransport } from '../observe-gasless-request.js';
+import { GaslessRequest, GaslessService } from '../types.js';
+/** Default budget for the receipt wait, once the relayer reports `succeeded`. */
+export declare const GASLESS_RECEIPT_TIMEOUT_MS = 60000;
+/**
+ * How far a relayed request is followed before it counts as done.
+ *
+ * - `"none"` — the 202 acceptance is the answer. You own the lifecycle and the
+ *   cache invalidation.
+ * - `"terminal"` — the relayer reports `succeeded`. Its node saw the receipt;
+ *   yours may not have.
+ * - `"receipt"` — additionally waits for the receipt on your own client, so the
+ *   state is readable by the reads you are about to invalidate.
+ */
+export type GaslessConfirmation = "none" | "terminal" | "receipt";
+/** A relayed request followed through to on-chain reality. */
+export interface GaslessConfirmedRequest {
+    /** The terminal record. Always `succeeded` — anything else threw. */
+    request: GaslessRequest;
+    /** The broadcast transaction hash. */
+    txHash: Hash;
+    /**
+     * Receipt from this config's client. Absent when `until: "terminal"`, and
+     * absent when the receipt wait ran out of budget — see the timeout note on
+     * {@link confirmGaslessRequest}.
+     */
+    receipt?: TransactionReceipt;
+}
+/**
+ * Parameters for {@link confirmGaslessRequest}.
+ */
+export type ConfirmGaslessRequestParameters = Compute<ChainIdParameter & {
+    /** Stable service tracking id returned by a gasless submit. */
+    requestId: string;
+    /** Which sub-service stores the request. Defaults to `"operations"`. */
+    service?: GaslessService;
+    /** How far to follow the request. Defaults to `"terminal"`. */
+    until?: Exclude<GaslessConfirmation, "none">;
+    /** Confirmations to wait for. Default `1`. Ignored unless `until: "receipt"`. */
+    receiptConfirmations?: number;
+    /** Budget for the terminal wait. */
+    timeoutMs?: number;
+    /** Budget for the receipt wait. Default {@link GASLESS_RECEIPT_TIMEOUT_MS}. */
+    receiptTimeoutMs?: number;
+    /** Poll cadence while `queued`. */
+    queuedPollMs?: number;
+    /** Poll cadence after `submitted`. */
+    submittedPollMs?: number;
+    /** How long to let the stream settle before the first HTTP read. */
+    streamSettleMs?: number;
+    /** How long a live stream may report nothing before one HTTP read is taken. */
+    streamStaleMs?: number;
+    /** Abort the wait (e.g. on unmount). The request keeps running server-side. */
+    signal?: AbortSignal;
+    /** Observer invoked with every fetched record, including the final one. */
+    onUpdate?: (request: GaslessRequest) => void;
+    /**
+     * Observer invoked for every transient read failure the status wait
+     * absorbed — see {@link waitForGaslessRequest}.
+     * It means the status is temporarily unreadable, never that the request
+     * failed.
+     */
+    onTransportIssue?: (error: SymmError) => void;
+    /**
+     * How to follow the workflow: `"auto"` (default) prefers the gateway's
+     * status stream where the deployment enables it and polls while it is not
+     * delivering; `"poll"` forces HTTP polling. The outcome is identical.
+     */
+    transport?: GaslessStatusTransport;
+}>;
+/** Return type of {@link confirmGaslessRequest}. */
+export type ConfirmGaslessRequestReturnType = GaslessConfirmedRequest;
+/**
+ * Follow one accepted relay request through to on-chain reality.
+ *
+ * This is the opinionated layer above {@link waitForGaslessRequest}: where the
+ * driver resolves with whatever terminal it reaches, this resolves **only** on
+ * `succeeded` and throws for `reverted` / `failed` / `rejected`, with the record
+ * attached to the error's `responseData`. That split is deliberate — the driver
+ * reports facts, this one asserts the outcome a caller is waiting for.
+ *
+ * With `until: "receipt"` it then waits for the receipt on *this config's*
+ * client. That matters more than it looks: the relayer's `succeeded` is the
+ * relayer's node's view, and invalidating cached reads against a node that has
+ * not seen the block re-reads pre-state, which is the stalled UI this whole
+ * mechanism exists to prevent.
+ *
+ * **A receipt-wait timeout is not a failure.** The relayer already reported the
+ * transaction mined with `status = 1`; the receipt wait is a freshness barrier
+ * on your RPC, not a source of truth. On timeout this resolves with `receipt`
+ * absent rather than throwing — turning a succeeded action into an error
+ * because a public RPC lagged would be a worse bug than the one being fixed.
+ *
+ * Transient read failures are absorbed by the status wait underneath, not
+ * reported as failures — subscribe to `onTransportIssue` to show "status
+ * unavailable" while they last. Never re-submits: a 202 is the point of no
+ * return.
+ *
+ * @param config - The SDK config.
+ * @param parameters - Request id, how far to follow it, and the budgets.
+ * @returns The terminal record, its transaction hash, and (for `"receipt"`) the receipt.
+ * @throws {SymmApiError} `GASLESS_RELAY_REJECTED` / `GASLESS_RELAY_REVERTED` /
+ *   `GASLESS_RELAY_FAILED` on a non-succeeded terminal, carrying the record.
+ * @throws {SymmError} `GASLESS_SUCCEEDED_WITHOUT_TX` when a `succeeded` record has no hash.
+ * @throws {SymmError} `GASLESS_WAIT_ABORTED` when `signal` aborts — this means
+ *   nobody is watching any more, **not** that the action failed.
+ *
+ * @example
+ * ```ts
+ * const { request, receipt } = await confirmGaslessRequest(config, {
+ *   requestId: accepted.requestId,
+ *   until: "receipt",
+ * });
+ * ```
+ */
+export declare function confirmGaslessRequest(config: Config, parameters: ConfirmGaslessRequestParameters): Promise<ConfirmGaslessRequestReturnType>;
+//# sourceMappingURL=confirm-gasless-request.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"confirm-gasless-request.d.ts","sourceRoot":"","sources":["../../../src/gasless/confirm-gasless-request/confirm-gasless-request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,kBAAkB,EAAE,MAAM,MAAM,CAAC;AACrD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAgB,SAAS,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AAE/E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AAEzE,OAAO,EAAwB,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,UAAU,CAAC;AAG1F,iFAAiF;AACjF,eAAO,MAAM,0BAA0B,QAAS,CAAC;AAEjD;;;;;;;;;GASG;AACH,MAAM,MAAM,mBAAmB,GAAG,MAAM,GAAG,UAAU,GAAG,SAAS,CAAC;AAElE,8DAA8D;AAC9D,MAAM,WAAW,uBAAuB;IACtC,qEAAqE;IACrE,OAAO,EAAE,cAAc,CAAC;IACxB,sCAAsC;IACtC,MAAM,EAAE,IAAI,CAAC;IACb;;;;OAIG;IACH,OAAO,CAAC,EAAE,kBAAkB,CAAC;CAC9B;AAED;;GAEG;AACH,MAAM,MAAM,+BAA+B,GAAG,OAAO,CACnD,gBAAgB,GAAG;IACjB,+DAA+D;IAC/D,SAAS,EAAE,MAAM,CAAC;IAClB,wEAAwE;IACxE,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,+DAA+D;IAC/D,KAAK,CAAC,EAAE,OAAO,CAAC,mBAAmB,EAAE,MAAM,CAAC,CAAC;IAC7C,iFAAiF;IACjF,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,oCAAoC;IACpC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,+EAA+E;IAC/E,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,mCAAmC;IACnC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,sCAAsC;IACtC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,oEAAoE;IACpE,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,+EAA+E;IAC/E,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,+EAA+E;IAC/E,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;IAC7C;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;IAC9C;;;;OAIG;IACH,SAAS,CAAC,EAAE,sBAAsB,CAAC;CACpC,CACF,CAAC;AAEF,oDAAoD;AACpD,MAAM,MAAM,+BAA+B,GAAG,uBAAuB,CAAC;AAEtE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,+BAA+B,GAC1C,OAAO,CAAC,+BAA+B,CAAC,CA+E1C"}

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

@@ -0,0 +1,73 @@
+import { SymmApiError as e, SymmError as t } from "../../shared/errors/symm-error.js";
+import { fireGaslessEvent as n, toGaslessRecordBody as r } from "../events.js";
+import { resolveGaslessService as i } from "../resolve-gasless.js";
+import { GaslessRequestStatus as a } from "../types.js";
+import { waitForGaslessRequest as o } from "../wait-for-gasless-request/wait-for-gasless-request.js";
+//#region src/gasless/confirm-gasless-request/confirm-gasless-request.ts
+var s = 6e4;
+async function c(c, u) {
+	let { chainId: d, requestId: f, service: p = "operations", until: m = "terminal", receiptConfirmations: h = 1, receiptTimeoutMs: g = s, signal: _, onUpdate: v, onTransportIssue: y, transport: b } = u, x = i(c, { chainId: d }), S = x.execution?.onEvent, C = await o(c, {
+		chainId: d,
+		requestId: f,
+		service: p,
+		until: "terminal",
+		timeoutMs: u.timeoutMs,
+		queuedPollMs: u.queuedPollMs,
+		submittedPollMs: u.submittedPollMs,
+		streamSettleMs: u.streamSettleMs,
+		streamStaleMs: u.streamStaleMs,
+		signal: _,
+		onUpdate: v,
+		onTransportIssue: y,
+		transport: b
+	});
+	if (n(S, {
+		type: "terminal",
+		requestId: C.requestId,
+		status: C.status,
+		txHash: C.txHash,
+		chainId: c.getChainConfig(d).chainId
+	}), C.status !== a.SUCCEEDED) throw new e({
+		code: l[C.status],
+		message: `Gasless: request ${C.requestId} ended ${C.status}${C.errorMessage ? ` — ${C.errorMessage}` : ""}.`,
+		status: 200,
+		statusText: "OK",
+		responseData: r(C),
+		url: x.url,
+		method: "GET"
+	});
+	if (C.txHash === null) throw new t("api", "GASLESS_SUCCEEDED_WITHOUT_TX", `Gasless: request ${C.requestId} reports succeeded but carries no transaction hash.`);
+	let w = C.txHash;
+	if (m === "terminal") return {
+		request: C,
+		txHash: w
+	};
+	let T = c.getClient({ chainId: d });
+	try {
+		return {
+			request: C,
+			txHash: w,
+			receipt: await T.waitForTransactionReceipt({
+				hash: w,
+				confirmations: h,
+				timeout: g
+			})
+		};
+	} catch {
+		return {
+			request: C,
+			txHash: w
+		};
+	}
+}
+var l = {
+	[a.REJECTED]: "GASLESS_RELAY_REJECTED",
+	[a.REVERTED]: "GASLESS_RELAY_REVERTED",
+	[a.FAILED]: "GASLESS_RELAY_FAILED",
+	[a.QUEUED]: "GASLESS_RELAY_FAILED",
+	[a.SUBMITTED]: "GASLESS_RELAY_FAILED"
+};
+//#endregion
+export { s as GASLESS_RECEIPT_TIMEOUT_MS, c as confirmGaslessRequest };
+
+//# sourceMappingURL=confirm-gasless-request.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"confirm-gasless-request.js","names":[],"sources":["../../../src/gasless/confirm-gasless-request/confirm-gasless-request.ts"],"sourcesContent":["import type { Hash, TransactionReceipt } from \"viem\";\nimport type { Config } from \"../../core/config\";\nimport { SymmApiError, SymmError } from \"../../shared/errors/symm-error\";\nimport type { ChainIdParameter, Compute } from \"../../shared/types/properties\";\nimport { fireGaslessEvent, toGaslessRecordBody } from \"../events\";\nimport type { GaslessStatusTransport } from \"../observe-gasless-request\";\nimport { resolveGaslessService } from \"../resolve-gasless\";\nimport { GaslessRequestStatus, type GaslessRequest, type GaslessService } from \"../types\";\nimport { waitForGaslessRequest } from \"../wait-for-gasless-request/wait-for-gasless-request\";\n\n/** Default budget for the receipt wait, once the relayer reports `succeeded`. */\nexport const GASLESS_RECEIPT_TIMEOUT_MS = 60_000;\n\n/**\n * How far a relayed request is followed before it counts as done.\n *\n * - `\"none\"` — the 202 acceptance is the answer. You own the lifecycle and the\n *   cache invalidation.\n * - `\"terminal\"` — the relayer reports `succeeded`. Its node saw the receipt;\n *   yours may not have.\n * - `\"receipt\"` — additionally waits for the receipt on your own client, so the\n *   state is readable by the reads you are about to invalidate.\n */\nexport type GaslessConfirmation = \"none\" | \"terminal\" | \"receipt\";\n\n/** A relayed request followed through to on-chain reality. */\nexport interface GaslessConfirmedRequest {\n  /** The terminal record. Always `succeeded` — anything else threw. */\n  request: GaslessRequest;\n  /** The broadcast transaction hash. */\n  txHash: Hash;\n  /**\n   * Receipt from this config's client. Absent when `until: \"terminal\"`, and\n   * absent when the receipt wait ran out of budget — see the timeout note on\n   * {@link confirmGaslessRequest}.\n   */\n  receipt?: TransactionReceipt;\n}\n\n/**\n * Parameters for {@link confirmGaslessRequest}.\n */\nexport type ConfirmGaslessRequestParameters = Compute<\n  ChainIdParameter & {\n    /** Stable service tracking id returned by a gasless submit. */\n    requestId: string;\n    /** Which sub-service stores the request. Defaults to `\"operations\"`. */\n    service?: GaslessService;\n    /** How far to follow the request. Defaults to `\"terminal\"`. */\n    until?: Exclude<GaslessConfirmation, \"none\">;\n    /** Confirmations to wait for. Default `1`. Ignored unless `until: \"receipt\"`. */\n    receiptConfirmations?: number;\n    /** Budget for the terminal wait. */\n    timeoutMs?: number;\n    /** Budget for the receipt wait. Default {@link GASLESS_RECEIPT_TIMEOUT_MS}. */\n    receiptTimeoutMs?: number;\n    /** Poll cadence while `queued`. */\n    queuedPollMs?: number;\n    /** Poll cadence after `submitted`. */\n    submittedPollMs?: number;\n    /** How long to let the stream settle before the first HTTP read. */\n    streamSettleMs?: number;\n    /** How long a live stream may report nothing before one HTTP read is taken. */\n    streamStaleMs?: number;\n    /** Abort the wait (e.g. on unmount). The request keeps running server-side. */\n    signal?: AbortSignal;\n    /** Observer invoked with every fetched record, including the final one. */\n    onUpdate?: (request: GaslessRequest) => void;\n    /**\n     * Observer invoked for every transient read failure the status wait\n     * absorbed — see {@link waitForGaslessRequest}.\n     * It means the status is temporarily unreadable, never that the request\n     * failed.\n     */\n    onTransportIssue?: (error: SymmError) => void;\n    /**\n     * How to follow the workflow: `\"auto\"` (default) prefers the gateway's\n     * status stream where the deployment enables it and polls while it is not\n     * delivering; `\"poll\"` forces HTTP polling. The outcome is identical.\n     */\n    transport?: GaslessStatusTransport;\n  }\n>;\n\n/** Return type of {@link confirmGaslessRequest}. */\nexport type ConfirmGaslessRequestReturnType = GaslessConfirmedRequest;\n\n/**\n * Follow one accepted relay request through to on-chain reality.\n *\n * This is the opinionated layer above {@link waitForGaslessRequest}: where the\n * driver resolves with whatever terminal it reaches, this resolves **only** on\n * `succeeded` and throws for `reverted` / `failed` / `rejected`, with the record\n * attached to the error's `responseData`. That split is deliberate — the driver\n * reports facts, this one asserts the outcome a caller is waiting for.\n *\n * With `until: \"receipt\"` it then waits for the receipt on *this config's*\n * client. That matters more than it looks: the relayer's `succeeded` is the\n * relayer's node's view, and invalidating cached reads against a node that has\n * not seen the block re-reads pre-state, which is the stalled UI this whole\n * mechanism exists to prevent.\n *\n * **A receipt-wait timeout is not a failure.** The relayer already reported the\n * transaction mined with `status = 1`; the receipt wait is a freshness barrier\n * on your RPC, not a source of truth. On timeout this resolves with `receipt`\n * absent rather than throwing — turning a succeeded action into an error\n * because a public RPC lagged would be a worse bug than the one being fixed.\n *\n * Transient read failures are absorbed by the status wait underneath, not\n * reported as failures — subscribe to `onTransportIssue` to show \"status\n * unavailable\" while they last. Never re-submits: a 202 is the point of no\n * return.\n *\n * @param config - The SDK config.\n * @param parameters - Request id, how far to follow it, and the budgets.\n * @returns The terminal record, its transaction hash, and (for `\"receipt\"`) the receipt.\n * @throws {SymmApiError} `GASLESS_RELAY_REJECTED` / `GASLESS_RELAY_REVERTED` /\n *   `GASLESS_RELAY_FAILED` on a non-succeeded terminal, carrying the record.\n * @throws {SymmError} `GASLESS_SUCCEEDED_WITHOUT_TX` when a `succeeded` record has no hash.\n * @throws {SymmError} `GASLESS_WAIT_ABORTED` when `signal` aborts — this means\n *   nobody is watching any more, **not** that the action failed.\n *\n * @example\n * ```ts\n * const { request, receipt } = await confirmGaslessRequest(config, {\n *   requestId: accepted.requestId,\n *   until: \"receipt\",\n * });\n * ```\n */\nexport async function confirmGaslessRequest(\n  config: Config,\n  parameters: ConfirmGaslessRequestParameters,\n): Promise<ConfirmGaslessRequestReturnType> {\n  const {\n    chainId,\n    requestId,\n    service = \"operations\",\n    until = \"terminal\",\n    receiptConfirmations = 1,\n    receiptTimeoutMs = GASLESS_RECEIPT_TIMEOUT_MS,\n    signal,\n    onUpdate,\n    onTransportIssue,\n    transport,\n  } = parameters;\n\n  const gasless = resolveGaslessService(config, { chainId });\n  const events = gasless.execution?.onEvent;\n\n  const record = await waitForGaslessRequest(config, {\n    chainId,\n    requestId,\n    service,\n    until: \"terminal\",\n    timeoutMs: parameters.timeoutMs,\n    queuedPollMs: parameters.queuedPollMs,\n    submittedPollMs: parameters.submittedPollMs,\n    streamSettleMs: parameters.streamSettleMs,\n    streamStaleMs: parameters.streamStaleMs,\n    signal,\n    onUpdate,\n    onTransportIssue,\n    transport,\n  });\n\n  fireGaslessEvent(events, {\n    type: \"terminal\",\n    requestId: record.requestId,\n    status: record.status,\n    txHash: record.txHash,\n    chainId: config.getChainConfig(chainId).chainId,\n  });\n\n  if (record.status !== GaslessRequestStatus.SUCCEEDED) {\n    throw new SymmApiError({\n      code: TERMINAL_ERROR_CODES[record.status],\n      message: `Gasless: request ${record.requestId} ended ${record.status}${record.errorMessage ? ` — ${record.errorMessage}` : \"\"}.`,\n      status: 200,\n      statusText: \"OK\",\n      responseData: toGaslessRecordBody(record),\n      url: gasless.url,\n      method: \"GET\",\n    });\n  }\n\n  if (record.txHash === null) {\n    throw new SymmError(\n      \"api\",\n      \"GASLESS_SUCCEEDED_WITHOUT_TX\",\n      `Gasless: request ${record.requestId} reports succeeded but carries no transaction hash.`,\n    );\n  }\n  const txHash = record.txHash;\n\n  if (until === \"terminal\") return { request: record, txHash };\n\n  const client = config.getClient({ chainId });\n  try {\n    const receipt = await client.waitForTransactionReceipt({\n      hash: txHash,\n      confirmations: receiptConfirmations,\n      timeout: receiptTimeoutMs,\n    });\n    return { request: record, txHash, receipt };\n  } catch {\n    /**\n     * The transaction is mined — the relayer watched it happen. Only our view\n     * of it is late, so report the success we already have.\n     */\n    return { request: record, txHash };\n  }\n}\n\n/** Which typed error a non-succeeded terminal raises. */\nconst TERMINAL_ERROR_CODES: Record<Exclude<GaslessRequestStatus, GaslessRequestStatus.SUCCEEDED>, string> = {\n  [GaslessRequestStatus.REJECTED]: \"GASLESS_RELAY_REJECTED\",\n  [GaslessRequestStatus.REVERTED]: \"GASLESS_RELAY_REVERTED\",\n  [GaslessRequestStatus.FAILED]: \"GASLESS_RELAY_FAILED\",\n  [GaslessRequestStatus.QUEUED]: \"GASLESS_RELAY_FAILED\",\n  [GaslessRequestStatus.SUBMITTED]: \"GASLESS_RELAY_FAILED\",\n};\n"],"mappings":";;;;;;AAWA,IAAa,IAA6B;AAuH1C,eAAsB,EACpB,GACA,GAC0C;CAC1C,IAAM,EACJ,YACA,cACA,aAAU,cACV,WAAQ,YACR,0BAAuB,GACvB,sBAAmB,GACnB,WACA,aACA,qBACA,iBACE,GAEE,IAAU,EAAsB,GAAQ,EAAE,WAAQ,CAAC,GACnD,IAAS,EAAQ,WAAW,SAE5B,IAAS,MAAM,EAAsB,GAAQ;EACjD;EACA;EACA;EACA,OAAO;EACP,WAAW,EAAW;EACtB,cAAc,EAAW;EACzB,iBAAiB,EAAW;EAC5B,gBAAgB,EAAW;EAC3B,eAAe,EAAW;EAC1B;EACA;EACA;EACA;CACF,CAAC;CAUD,IARA,EAAiB,GAAQ;EACvB,MAAM;EACN,WAAW,EAAO;EAClB,QAAQ,EAAO;EACf,QAAQ,EAAO;EACf,SAAS,EAAO,eAAe,CAAO,EAAE;CAC1C,CAAC,GAEG,EAAO,WAAW,EAAqB,WACzC,MAAM,IAAI,EAAa;EACrB,MAAM,EAAqB,EAAO;EAClC,SAAS,oBAAoB,EAAO,UAAU,SAAS,EAAO,SAAS,EAAO,eAAe,MAAM,EAAO,iBAAiB,GAAG;EAC9H,QAAQ;EACR,YAAY;EACZ,cAAc,EAAoB,CAAM;EACxC,KAAK,EAAQ;EACb,QAAQ;CACV,CAAC;CAGH,IAAI,EAAO,WAAW,MACpB,MAAM,IAAI,EACR,OACA,gCACA,oBAAoB,EAAO,UAAU,oDACvC;CAEF,IAAM,IAAS,EAAO;CAEtB,IAAI,MAAU,YAAY,OAAO;EAAE,SAAS;EAAQ;CAAO;CAE3D,IAAM,IAAS,EAAO,UAAU,EAAE,WAAQ,CAAC;CAC3C,IAAI;EAMF,OAAO;GAAE,SAAS;GAAQ;GAAQ,SAAA,MALZ,EAAO,0BAA0B;IACrD,MAAM;IACN,eAAe;IACf,SAAS;GACX,CAAC;EACyC;CAC5C,QAAQ;EAKN,OAAO;GAAE,SAAS;GAAQ;EAAO;CACnC;AACF;AAGA,IAAM,IAAsG;EACzG,EAAqB,WAAW;EAChC,EAAqB,WAAW;EAChC,EAAqB,SAAS;EAC9B,EAAqB,SAAS;EAC9B,EAAqB,YAAY;AACpC"}

package/dist/gasless/confirm-gasless-request/index.d.ts

@@ -0,0 +1,2 @@
+export * from './confirm-gasless-request.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/gasless/confirm-gasless-request/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/gasless/confirm-gasless-request/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC"}

package/dist/gasless/constants.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 4-byte selector of `GaslessWallet.execute((address,uint256,bytes)[])` — the
+ * only selector a relayed wallet operation's `callData` may start with.
+ *
+ * @example
+ * ```ts
+ * const isWalletOperation = operation.callData.slice(0, 10).toLowerCase() === GASLESS_WALLET_EXECUTE_SELECTOR;
+ * ```
+ */
+export declare const GASLESS_WALLET_EXECUTE_SELECTOR: "0x3f707e6b";
+/**
+ * Sentinel selector (`bytes4(keccak256("GASLESSQ_WALLET_EXECUTION"))`) a
+ * session key must hold an InstantLayer delegation for before it may sign
+ * **delegated** GaslessWallet executions — alongside every inner call selector.
+ * Owner-signed wallet operations do not use it. The GaslessLayer exposes the
+ * same value as `WALLET_EXECUTION_SENTINEL_SELECTOR()`.
+ *
+ * @example
+ * ```ts
+ * const selectors = [GASLESS_WALLET_EXECUTION_SENTINEL_SELECTOR, ...innerSelectors];
+ * ```
+ */
+export declare const GASLESS_WALLET_EXECUTION_SENTINEL_SELECTOR: "0x1dccecab";
+//# sourceMappingURL=constants.d.ts.map

package/dist/gasless/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/gasless/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,+BAA+B,EAAG,YAAqB,CAAC;AAErE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,0CAA0C,EAAG,YAAqB,CAAC"}

package/dist/gasless/constants.js

@@ -0,0 +1,6 @@
+//#region src/gasless/constants.ts
+var e = "0x3f707e6b", t = "0x1dccecab";
+//#endregion
+export { e as GASLESS_WALLET_EXECUTE_SELECTOR, t as GASLESS_WALLET_EXECUTION_SENTINEL_SELECTOR };
+
+//# sourceMappingURL=constants.js.map

package/dist/gasless/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","names":[],"sources":["../../src/gasless/constants.ts"],"sourcesContent":["/**\n * 4-byte selector of `GaslessWallet.execute((address,uint256,bytes)[])` — the\n * only selector a relayed wallet operation's `callData` may start with.\n *\n * @example\n * ```ts\n * const isWalletOperation = operation.callData.slice(0, 10).toLowerCase() === GASLESS_WALLET_EXECUTE_SELECTOR;\n * ```\n */\nexport const GASLESS_WALLET_EXECUTE_SELECTOR = \"0x3f707e6b\" as const;\n\n/**\n * Sentinel selector (`bytes4(keccak256(\"GASLESSQ_WALLET_EXECUTION\"))`) a\n * session key must hold an InstantLayer delegation for before it may sign\n * **delegated** GaslessWallet executions — alongside every inner call selector.\n * Owner-signed wallet operations do not use it. The GaslessLayer exposes the\n * same value as `WALLET_EXECUTION_SENTINEL_SELECTOR()`.\n *\n * @example\n * ```ts\n * const selectors = [GASLESS_WALLET_EXECUTION_SENTINEL_SELECTOR, ...innerSelectors];\n * ```\n */\nexport const GASLESS_WALLET_EXECUTION_SENTINEL_SELECTOR = \"0x1dccecab\" as const;\n"],"mappings":";AASA,IAAa,IAAkC,cAclC,IAA6C"}

package/dist/gasless/delegation-preflight.d.ts

@@ -0,0 +1,39 @@
+import { Address, Hex } from 'viem';
+import { Config } from '../core/config/index.js';
+/**
+ * The owning EOA of a sub-account, read once per config lifetime.
+ *
+ * The real promise is cached (so concurrent writes share the single in-flight
+ * read instead of each issuing their own), and the entry is dropped on rejection
+ * so a transient RPC failure cannot poison the config.
+ *
+ * @param config - The SDK config.
+ * @param chainId - The chain the sub-account lives on.
+ * @param account - The sub-account.
+ * @returns The owner, or `null` when the AccountLayer knows no such sub-account.
+ *
+ * @internal
+ */
+export declare function getCachedGaslessAccountOwner(config: Config, chainId: number, account: Address): Promise<Address | null>;
+/**
+ * Selectors the signing key may not relay under `signerAccount`.
+ *
+ * The owner needs no delegation, so an owner signer short-circuits after the
+ * (cached) owner read with zero extra calls. Any other signer is a delegate — a
+ * session key — and every distinct selector is checked against
+ * `isDelegationActive` concurrently.
+ *
+ * @param config - The SDK config.
+ * @param parameters - The chain, the signing key, the account it signs under, and the selectors it relays.
+ * @returns The selectors with no active delegation; empty when the signer may
+ *   relay every call.
+ *
+ * @internal
+ */
+export declare function findUndelegatedGaslessSelectors(config: Config, parameters: {
+    chainId: number;
+    signer: Address;
+    signerAccount: Address;
+    selectors: readonly Hex[];
+}): Promise<Hex[]>;
+//# sourceMappingURL=delegation-preflight.d.ts.map

package/dist/gasless/delegation-preflight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegation-preflight.d.ts","sourceRoot":"","sources":["../../src/gasless/delegation-preflight.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,MAAM,CAAC;AAC9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAgB7C;;;;;;;;;;;;;GAaG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CA4BzB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,+BAA+B,CACnD,MAAM,EAAE,MAAM,EACd,UAAU,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,aAAa,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,SAAS,GAAG,EAAE,CAAA;CAAE,GAClG,OAAO,CAAC,GAAG,EAAE,CAAC,CAgBhB"}

package/dist/gasless/delegation-preflight.js

@@ -0,0 +1,33 @@
+import { getSubAccount as e } from "../symmio-contracts/account-layer/actions/get-sub-account.js";
+import { getIsDelegationActive as t } from "../symmio-contracts/instant-layer/actions/get-is-delegation-active.js";
+import { isAddressEqual as n } from "viem";
+//#region src/gasless/delegation-preflight.ts
+var r = /* @__PURE__ */ new WeakMap();
+function i(t, n, i) {
+	let a = r.get(t);
+	a || (a = /* @__PURE__ */ new Map(), r.set(t, a));
+	let o = a, s = `${n}:${i.toLowerCase()}`, c = o.get(s);
+	if (c) return c;
+	let l = e(t, {
+		chainId: n,
+		account: i
+	}).then((e) => e.isExists ? e.owner : null);
+	return o.set(s, l), l.catch(() => {
+		o.get(s) === l && o.delete(s);
+	}), l;
+}
+async function a(e, r) {
+	let a = await i(e, r.chainId, r.signerAccount);
+	if (a === null || n(r.signer, a)) return [];
+	let o = [...new Set(r.selectors)], s = await Promise.all(o.map((n) => t(e, {
+		chainId: r.chainId,
+		account: r.signerAccount,
+		delegate: r.signer,
+		selector: n
+	})));
+	return o.filter((e, t) => !s[t]);
+}
+//#endregion
+export { a as findUndelegatedGaslessSelectors, i as getCachedGaslessAccountOwner };
+
+//# sourceMappingURL=delegation-preflight.js.map

package/dist/gasless/delegation-preflight.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegation-preflight.js","names":[],"sources":["../../src/gasless/delegation-preflight.ts"],"sourcesContent":["import { isAddressEqual, type Address, type Hex } from \"viem\";\nimport type { Config } from \"../core/config\";\nimport { getSubAccount } from \"../symmio-contracts/account-layer/actions/get-sub-account\";\nimport { getIsDelegationActive } from \"../symmio-contracts/instant-layer/actions/get-is-delegation-active\";\n\n/**\n * One owner read per (config, chainId, sub-account).\n *\n * Cached for the config's lifetime, which is a deliberate trade: the AccountLayer\n * does expose `transferSubAccountOwnership`, so an owner is not strictly\n * immutable, but a transfer mid-session is rare and the alternative is an extra\n * RPC read on every relayed write. A stale entry costs a spurious delegation\n * probe, never a wrong authorization — the contract re-checks both the owner and\n * the delegation on execution.\n */\nconst accountOwners = new WeakMap<Config, Map<string, Promise<Address | null>>>();\n\n/**\n * The owning EOA of a sub-account, read once per config lifetime.\n *\n * The real promise is cached (so concurrent writes share the single in-flight\n * read instead of each issuing their own), and the entry is dropped on rejection\n * so a transient RPC failure cannot poison the config.\n *\n * @param config - The SDK config.\n * @param chainId - The chain the sub-account lives on.\n * @param account - The sub-account.\n * @returns The owner, or `null` when the AccountLayer knows no such sub-account.\n *\n * @internal\n */\nexport function getCachedGaslessAccountOwner(\n  config: Config,\n  chainId: number,\n  account: Address,\n): Promise<Address | null> {\n  let byAccount = accountOwners.get(config);\n  if (!byAccount) {\n    byAccount = new Map();\n    accountOwners.set(config, byAccount);\n  }\n  const cache = byAccount;\n  const key = `${chainId}:${account.toLowerCase()}`;\n  const cached = cache.get(key);\n  if (cached) return cached;\n\n  const read = getSubAccount(config, { chainId, account }).then((detail) =>\n    /**\n     * An unknown or deleted sub-account reports `isExists: false` with a zero\n     * `owner`. Returning that zero address would make every signer compare\n     * unequal to the owner, so the dispatcher would classify even the real owner\n     * as a delegate and reject the write with a misleading\n     * `GASLESS_SIGNER_NOT_DELEGATED`. `null` instead means \"cannot establish an\n     * owner\" and skips the pre-flight, leaving the contract to give the accurate\n     * error.\n     */\n    detail.isExists ? detail.owner : null,\n  );\n  cache.set(key, read);\n  read.catch(() => {\n    if (cache.get(key) === read) cache.delete(key);\n  });\n  return read;\n}\n\n/**\n * Selectors the signing key may not relay under `signerAccount`.\n *\n * The owner needs no delegation, so an owner signer short-circuits after the\n * (cached) owner read with zero extra calls. Any other signer is a delegate — a\n * session key — and every distinct selector is checked against\n * `isDelegationActive` concurrently.\n *\n * @param config - The SDK config.\n * @param parameters - The chain, the signing key, the account it signs under, and the selectors it relays.\n * @returns The selectors with no active delegation; empty when the signer may\n *   relay every call.\n *\n * @internal\n */\nexport async function findUndelegatedGaslessSelectors(\n  config: Config,\n  parameters: { chainId: number; signer: Address; signerAccount: Address; selectors: readonly Hex[] },\n): Promise<Hex[]> {\n  const owner = await getCachedGaslessAccountOwner(config, parameters.chainId, parameters.signerAccount);\n  if (owner === null || isAddressEqual(parameters.signer, owner)) return [];\n\n  const selectors = [...new Set(parameters.selectors)];\n  const active = await Promise.all(\n    selectors.map((selector) =>\n      getIsDelegationActive(config, {\n        chainId: parameters.chainId,\n        account: parameters.signerAccount,\n        delegate: parameters.signer,\n        selector,\n      }),\n    ),\n  );\n  return selectors.filter((_, index) => !active[index]);\n}\n"],"mappings":";;;;AAeA,IAAM,oBAAgB,IAAI,QAAsD;AAgBhF,SAAgB,EACd,GACA,GACA,GACyB;CACzB,IAAI,IAAY,EAAc,IAAI,CAAM;CACxC,AAAK,MACH,oBAAY,IAAI,IAAI,GACpB,EAAc,IAAI,GAAQ,CAAS;CAErC,IAAM,IAAQ,GACR,IAAM,GAAG,EAAQ,GAAG,EAAQ,YAAY,KACxC,IAAS,EAAM,IAAI,CAAG;CAC5B,IAAI,GAAQ,OAAO;CAEnB,IAAM,IAAO,EAAc,GAAQ;EAAE;EAAS;CAAQ,CAAC,EAAE,MAAM,MAU7D,EAAO,WAAW,EAAO,QAAQ,IACnC;CAKA,OAJA,EAAM,IAAI,GAAK,CAAI,GACnB,EAAK,YAAY;EACf,AAAI,EAAM,IAAI,CAAG,MAAM,KAAM,EAAM,OAAO,CAAG;CAC/C,CAAC,GACM;AACT;AAiBA,eAAsB,EACpB,GACA,GACgB;CAChB,IAAM,IAAQ,MAAM,EAA6B,GAAQ,EAAW,SAAS,EAAW,aAAa;CACrG,IAAI,MAAU,QAAQ,EAAe,EAAW,QAAQ,CAAK,GAAG,OAAO,CAAC;CAExE,IAAM,IAAY,CAAC,GAAG,IAAI,IAAI,EAAW,SAAS,CAAC,GAC7C,IAAS,MAAM,QAAQ,IAC3B,EAAU,KAAK,MACb,EAAsB,GAAQ;EAC5B,SAAS,EAAW;EACpB,SAAS,EAAW;EACpB,UAAU,EAAW;EACrB;CACF,CAAC,CACH,CACF;CACA,OAAO,EAAU,QAAQ,GAAG,MAAU,CAAC,EAAO,EAAM;AACtD"}

package/dist/gasless/dispatch/maybe-relay-as-gasless.d.ts

@@ -0,0 +1,73 @@
+import { Address, Hash, Hex } from 'viem';
+import { Config } from '../../core/config/index.js';
+import { GaslessWriteOptions } from '../../shared/types/properties.js';
+/** One inner call of a write the dispatcher may relay. @internal */
+export interface GaslessDispatchCall {
+    /** Contract the calldata targets (core diamond or AccountLayer). */
+    target: Address;
+    /** Raw function calldata. */
+    callData: Hex;
+}
+/** Input the write seams hand to {@link maybeRelayAsGasless}. @internal */
+export interface MaybeRelayAsGaslessParameters {
+    chainId?: number;
+    from?: Address;
+    /** The write's `gasless` parameter, verbatim. */
+    gasless: boolean | GaslessWriteOptions | undefined;
+    /** The calls, in execution order (a multi-call `_call` batch stays atomic as a relay batch). */
+    calls: readonly GaslessDispatchCall[];
+    /**
+     * The sub-account the operations run under. The `_call` seam knows it; the
+     * margin seam passes `virtualAccount` instead and the parent is resolved
+     * on-chain (or taken from `gasless.account`).
+     */
+    signerAccount?: Address;
+    /** The virtual account of a margin write, for parent-sub-account resolution. */
+    virtualAccount?: Address;
+    /**
+     * An account a write targets that may be either a sub-account or a virtual
+     * account — the deposit seams cannot tell the two apart from their parameters.
+     * A VA resolves to its parent sub-account (a VA has no balance of its own to
+     * bill); anything else is used as the billing account unchanged. Unlike
+     * {@link MaybeRelayAsGaslessParameters.virtualAccount} this never throws for a
+     * non-VA address.
+     */
+    accountMaybeVirtual?: Address;
+}
+/**
+ * The transparent gasless dispatcher. Called by relayable write actions before
+ * their wallet path: returns the relayer's broadcast transaction hash when the
+ * write was relayed, or `null` when the caller must proceed on the normal
+ * gas-paid wallet path (gasless off, unsupported selector, or a definitive
+ * pre-broadcast rejection under `fallback: "wallet"`).
+ *
+ * The full policy lives in the docs; the load-bearing rules are:
+ * - **202 is the point of no return** — after acceptance there is no wallet
+ *   fallback ever, except a `rejected` terminal whose cause is a confirmed
+ *   fee/quota limit (nothing was broadcast, so a wallet retry cannot
+ *   double-execute).
+ * - A user's signature rejection always propagates — the user said no.
+ * - The returned hash behaves exactly like a wallet-submitted hash: the
+ *   caller's receipt-wait and invalidation pipelines run unchanged.
+ * - A signer that is not the sub-account's owner is checked against its
+ *   InstantLayer delegations **before** the signature prompt
+ *   (`execution.preflightDelegation`, default on): a session key missing a
+ *   selector throws `GASLESS_SIGNER_NOT_DELEGATED` — the selector set to grant
+ *   is the one `getSessionKeySelectors` builds. Under `fallback: "wallet"` that
+ *   rejection returns `null` instead, exactly like an exhausted free quota; note
+ *   the wallet path will then fail too for a session key, which holds no gas
+ *   and is not the owner — guarding that is the caller's concern, not this
+ *   dispatcher's.
+ * - The fee quote runs **before** the signature prompt too
+ *   (`execution.preflightFee`, default on). An exhausted daily free quota throws
+ *   `GASLESS_FREE_QUOTA_EXHAUSTED` (or returns `null` under `fallback: "wallet"`);
+ *   a quote the contract rejects throws `GASLESS_FEE_QUOTE_REVERTED` and a
+ *   GaslessLayer without the multi-wallet interface throws
+ *   `GASLESS_LAYER_INTERFACE_UNSUPPORTED`, neither with a fallback. A quote that
+ *   fails for transport reasons does not block: the relayer's own simulation is
+ *   authoritative.
+ *
+ * @internal
+ */
+export declare function maybeRelayAsGasless(config: Config, parameters: MaybeRelayAsGaslessParameters): Promise<Hash | null>;
+//# sourceMappingURL=maybe-relay-as-gasless.d.ts.map

package/dist/gasless/dispatch/maybe-relay-as-gasless.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maybe-relay-as-gasless.d.ts","sourceRoot":"","sources":["../../../src/gasless/dispatch/maybe-relay-as-gasless.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAE/C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AA8BzE,oEAAoE;AACpE,MAAM,WAAW,mBAAmB;IAClC,oEAAoE;IACpE,MAAM,EAAE,OAAO,CAAC;IAChB,6BAA6B;IAC7B,QAAQ,EAAE,GAAG,CAAC;CACf;AAED,2EAA2E;AAC3E,MAAM,WAAW,6BAA6B;IAC5C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,iDAAiD;IACjD,OAAO,EAAE,OAAO,GAAG,mBAAmB,GAAG,SAAS,CAAC;IACnD,gGAAgG;IAChG,KAAK,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACtC;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,gFAAgF;IAChF,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;;;OAOG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAyCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,6BAA6B,GACxC,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,CA6QtB"}