@symmio/trading-core 3.0.0 → 3.1.0

package/dist/gasless/types.d.ts

@@ -0,0 +1,493 @@
+import { Address, Hash } from 'viem';
+/**
+ * Lifecycle status of a GaslessQ relayer request.
+ *
+ * A request moves `QUEUED → SUBMITTED → SUCCEEDED | REVERTED | FAILED`, or
+ * `QUEUED → REJECTED` when the worker's pre-broadcast re-check refuses it.
+ *
+ * `SUBMITTED` is **not** success — it only means a transaction hash exists.
+ * Only `SUCCEEDED` is success.
+ */
+export declare enum GaslessRequestStatus {
+    /** Accepted by the service; no transaction broadcast yet. */
+    QUEUED = "queued",
+    /** A transaction was broadcast and `txHash` is stored; the receipt is pending. */
+    SUBMITTED = "submitted",
+    /** The relayed transaction mined with `status = 1`. */
+    SUCCEEDED = "succeeded",
+    /** The relayed transaction mined with `status = 0`; all charges rolled back. */
+    REVERTED = "reverted",
+    /** A service or RPC failure occurred before a successful receipt. */
+    FAILED = "failed",
+    /** The worker's re-check rejected the request before any broadcast. */
+    REJECTED = "rejected"
+}
+/**
+ * The terminal {@link GaslessRequestStatus} values — polling stops here.
+ *
+ * @example
+ * ```ts
+ * refetchInterval: (query) => {
+ *   const status = query.state.data?.status;
+ *   return status && isGaslessRequestTerminal(status) ? false : 1_500;
+ * }
+ * ```
+ */
+export declare const GASLESS_TERMINAL_STATUSES: ReadonlySet<GaslessRequestStatus>;
+/**
+ * Whether a {@link GaslessRequestStatus} is terminal (no further polling needed).
+ *
+ * @param status - The status to check.
+ * @returns `true` for `succeeded`, `reverted`, `failed`, and `rejected`.
+ */
+export declare function isGaslessRequestTerminal(status: GaslessRequestStatus): boolean;
+/** Default poll cadence while a request is `queued` (service-recommended 1–2 s). */
+export declare const GASLESS_QUEUED_POLL_MS = 1500;
+/** Default poll cadence after a request is `submitted` (service-recommended 3–5 s). */
+export declare const GASLESS_SUBMITTED_POLL_MS = 3000;
+/**
+ * Default window a status wait gives the stream to deliver before its first
+ * HTTP read.
+ *
+ * Deliberately below {@link GASLESS_QUEUED_POLL_MS}: a stream that never
+ * answers costs one *delayed* read, never an extra one, so the fallback is
+ * strictly cheaper than the poll it defers.
+ */
+export declare const GASLESS_STREAM_SETTLE_MS = 1000;
+/**
+ * Default backstop for a *delivering* stream that reports nothing about the
+ * workflow.
+ *
+ * Heartbeats prove the socket is alive, not that this workflow is being
+ * reported, so a live-but-silent stream would otherwise blind a wait until the
+ * socket's own liveness timer fires. Only records for this request reset it.
+ */
+export declare const GASLESS_STREAM_STALE_MS = 15000;
+/**
+ * The poll cadence a request's current status calls for, or `false` once it is
+ * terminal.
+ *
+ * Shared by the imperative wait loop and the query factory's `refetchInterval`
+ * default so both follow one cadence. Terminal records are immutable, so
+ * stopping is not an optimisation — a poll that never stops bills the service
+ * forever for an answer that cannot change.
+ *
+ * The delay is drawn from the service's recommended band rather than fixed —
+ * 1–2 s while `queued`, 3–5 s after `submitted`. The jitter is load-bearing on
+ * the anonymous gateway: every workflow a page opened at the same moment would
+ * otherwise poll in lockstep and spend the shared per-IP budget in bursts.
+ *
+ * Meant for a loop that sleeps between reads. As a TanStack `refetchInterval`
+ * callback it needs a `random` that is stable between renders — TanStack
+ * recomputes the callback on every render and restarts the countdown whenever
+ * the value changed, so a fresh draw per call never fires. Use
+ * `getGaslessRequestQueryOptions`, which seeds the draw from the query's own
+ * fetch timestamps, rather than wiring this in by hand.
+ *
+ * @param status - The last known status, or `undefined` before the first fetch.
+ * @param random - Source of randomness in `[0, 1)`. Injectable for deterministic tests.
+ * @returns Milliseconds until the next poll, or `false` when terminal.
+ *
+ * @example
+ * ```ts
+ * for (let status: GaslessRequestStatus | undefined; ; ) {
+ *   const delay = gaslessPollDelay(status);
+ *   if (delay === false) break;
+ *   await new Promise((resolve) => setTimeout(resolve, delay));
+ *   status = (await getGaslessRequest(config, { requestId })).status;
+ * }
+ * ```
+ */
+export declare function gaslessPollDelay(status: GaslessRequestStatus | undefined, random?: () => number): number | false;
+/**
+ * Which GaslessQ sub-service a request id belongs to. Operations and deposit
+ * settlements are stored by different services with different poll URLs, so a
+ * request id alone does not identify a workflow — keep the service with it.
+ */
+export type GaslessService = "operations" | "deposits";
+/**
+ * What every stored relayer request carries, whichever service stores it.
+ *
+ * Raw decimal-string amounts are parsed to `bigint`; addresses come back
+ * lowercased by the service, so compare case-insensitively.
+ */
+export interface GaslessRequestBase {
+    /** Stable service tracking id — persist it to resume polling after a reload. */
+    requestId: string;
+    /** Current lifecycle status. */
+    status: GaslessRequestStatus;
+    /** Broadcast transaction hash, once the worker has submitted one. */
+    txHash: Hash | null;
+    /** Vendor error code on `rejected` / `reverted` / `failed`, when stored. */
+    errorCode: string | null;
+    /** Human-readable error message, when stored. */
+    errorMessage: string | null;
+    /** Idempotency key the request was submitted with, when stored. */
+    idempotencyKey: string | null;
+    /**
+     * The owner address the request is tracked under — `user_address` for an
+     * operation relay, `wallet_address` (which means the owner, not a
+     * GaslessWallet address) for a deposit settlement. `null` when the record
+     * stores none.
+     */
+    owner: Address | null;
+    /**
+     * The GaslessWallet ids the request selected, in `signedOps` order for an
+     * operation relay and as a single entry for a deposit settlement. Historical
+     * records that predate multiple wallets store no ids and normalize to zeros —
+     * one per stored operation — because an omitted id means wallet `0`.
+     */
+    walletIds: readonly bigint[];
+    /** When the service stored the request (ISO-8601), when recorded. */
+    createdAt: string | null;
+    /** When the service last updated the request (ISO-8601), when recorded. */
+    updatedAt: string | null;
+}
+/** A stored request of the `"operations"` service — a relayed InstantLayer batch. */
+export interface GaslessOperationRequest extends GaslessRequestBase {
+    /** Discriminant: this record lives in the operations service. */
+    service: "operations";
+    /** The workflow label the submitter attached (`operationType`). */
+    operationType: string | null;
+    /** The client accounting id the submitter attached, when stored. */
+    accountId: string | null;
+    /**
+     * The fee the service recorded for the request, in the unit the service
+     * reports it in (a vendor quote, not an authoritative on-chain charge).
+     */
+    feeAmountRaw: bigint | null;
+}
+/** A stored request of the `"deposits"` service — a deposit-address settlement. */
+export interface GaslessDepositRequest extends GaslessRequestBase {
+    /** Discriminant: this record lives in the deposits service. */
+    service: "deposits";
+    /** The deterministic deposit address being swept, when stored. */
+    depositAddress: Address | null;
+    /** The settled wallet's id. A record without one means wallet `0`. */
+    walletId: bigint;
+    /** Name of the sub-account the settlement credits, for a new-account settlement. */
+    accountName: string | null;
+    /** Collateral the service observed at the deposit address (token base units). */
+    amountRaw: bigint | null;
+    /** The deposit fee the service recorded (token base units). */
+    feeRaw: bigint | null;
+    /** The net credit the service recorded (token base units) — an estimate, not the final credit. */
+    creditedRaw: bigint | null;
+}
+/**
+ * One stored relayer request, normalized from the service's snake_case record.
+ *
+ * A flat per-service union: the two services store different columns, so the
+ * shared fields stay on {@link GaslessRequestBase} and each service's own
+ * fields live on its variant. Narrow with `request.service`.
+ *
+ * @example
+ * ```ts
+ * const request = await getGaslessRequest(config, { requestId, service: "deposits" });
+ * if (request.service === "deposits") console.log(request.depositAddress, request.walletId);
+ * ```
+ */
+export type GaslessRequest = GaslessOperationRequest | GaslessDepositRequest;
+/**
+ * The HTTP 202 acknowledgement returned by an operation relay submit.
+ *
+ * `paidFee` and `remainingFeeAllowance` are the service's **acceptance-time**
+ * figures, passed through as reported by the service with no unit conversion.
+ * They describe the request before it executes, so neither is an execution
+ * result. The GaslessLayer collects the operational fee only when the
+ * relayed batch executes, from the payer resolved at that moment, and a
+ * reverted relay charges nothing. For authoritative numbers, read the payer's
+ * Core allowance and balance (`getOperationalFeeAllowance`,
+ * `getAccountBalanceOf` — both 18-decimal) and reconcile the charge from the
+ * transaction receipt's `OperationalFeeRouted` events.
+ */
+export interface GaslessSubmitReceipt {
+    /** Stable service tracking id. Persist it immediately. */
+    requestId: string;
+    /** Status at acceptance — normally {@link GaslessRequestStatus.QUEUED}. */
+    status: GaslessRequestStatus;
+    /**
+     * The fee the service quoted for the request when it accepted it, as
+     * reported by the service. A quote, **not proof that a fee was collected**:
+     * the charge happens at execution and can differ, or not happen at all.
+     * `null` when the acceptance omitted it or reported an unparseable value —
+     * an acceptance is never discarded over a missing amount.
+     */
+    paidFee: bigint | null;
+    /**
+     * The service's acceptance-time view of the payer's remaining
+     * operational-fee allowance, as reported by the service. It is **not** a
+     * post-execution balance and not an authorization guarantee, and it can read
+     * `2^256 - 1` even while the payer's Core approval is bounded. Never display
+     * it as spendable or unlimited funds; read `getOperationalFeeAllowance`
+     * instead. `null` when the acceptance omitted it.
+     */
+    remainingFeeAllowance: bigint | null;
+    /**
+     * The idempotency key the request was submitted with — generated by the SDK
+     * when the caller passed none. Persist it: resending the byte-identical
+     * request under this key is what makes a lost response recoverable.
+     */
+    idempotencyKey: string;
+    /** Protocol instance the request was accepted on, or `null` for a proxy base that names none. */
+    protocolInstance: string | null;
+    /** The owner address the request is tracked under (the submitted `userAddress`). */
+    owner: Address;
+    /** The GaslessWallet ids the batch selected, in `signedOps` order — `0n` for ordinary InstantLayer operations. */
+    walletIds: readonly bigint[];
+}
+/**
+ * Outcome of one EVM broadcast attempt — the attempt's own lifecycle, which is
+ * **not** the request's {@link GaslessRequestStatus}. A request whose first
+ * attempt is `reverted` can still end `succeeded` on a later attempt, so read
+ * the outcome from the request and use the attempts for diagnosis.
+ */
+export declare enum GaslessTransactionAttemptStatus {
+    /** Broadcast to the network; no receipt observed yet. */
+    SUBMITTED = "submitted",
+    /** Mined with `status = 1`. */
+    CONFIRMED = "confirmed",
+    /** Mined with `status = 0`. */
+    REVERTED = "reverted",
+    /** Never mined — dropped, replaced, or rejected by the node. */
+    FAILED = "failed"
+}
+/**
+ * One EVM broadcast attempt stored for a relayer request, with its receipt
+ * outcome when observed.
+ *
+ * A request can broadcast more than once (a replacement transaction after a
+ * stuck nonce or a gas bump), so a hash is not a stable handle on a workflow —
+ * {@link GaslessRequestTransaction.requestId} is.
+ */
+export interface GaslessRequestTransaction {
+    /** Attempt row id. */
+    id: string;
+    /** Transaction hash of this attempt. */
+    txHash: Hash | null;
+    /** 1-based attempt number. */
+    attemptNumber: number;
+    /** Attempt outcome. */
+    status: GaslessTransactionAttemptStatus;
+    /**
+     * The request this attempt belongs to (the service's `entity_id`) — the same
+     * id `getGaslessRequest` is polled with.
+     */
+    requestId: string;
+    /** The service-side workflow that produced the attempt, e.g. `relay_instant`. */
+    workflow: string;
+    /**
+     * The raw receipt the service stored, as reported, or `null` while none was
+     * observed. Untyped on purpose: it is the relayer's node's JSON, not a viem
+     * `TransactionReceipt`, and its shape is the service's to change. Read the
+     * authoritative receipt from your own client with the attempt's `txHash`.
+     */
+    receipt: Record<string, unknown> | null;
+    /** Stored error code for a failed attempt, when present. */
+    errorCode: string | null;
+    /** Stored error message for a failed attempt, when present. */
+    errorMessage: string | null;
+    /** When the service stored the attempt (ISO-8601). */
+    createdAt: string | null;
+    /** When the service last updated the attempt (ISO-8601). */
+    updatedAt: string | null;
+}
+/**
+ * Everything a consumer needs to resume an accepted gasless workflow after a
+ * reload: the service, the instance and the identity that owns it.
+ *
+ * There is no list-by-wallet endpoint, so a request id lost to a reload is
+ * unrecoverable — persist this whole shape under
+ * `(environment, protocolInstance, service, requestId)`, with the owner and the
+ * selected wallet ids, as soon as it arrives.
+ */
+export interface GaslessAcceptedRequest {
+    /** Stable service tracking id. */
+    requestId: string;
+    /** Which sub-service stores the request (its poll URL and its stream). */
+    service: GaslessService;
+    /** The chain the request was accepted on. */
+    chainId: number;
+    /** Protocol-instance key the request was accepted on, or `null` for a proxy base that names none. */
+    protocolInstance: string | null;
+    /** The idempotency key the request was submitted with. */
+    idempotencyKey: string;
+    /** The workflow label stored with the request, when the submit carried one. */
+    operationType: string | null;
+    /** The owner address the request is tracked under. */
+    owner: Address;
+    /** The GaslessWallet ids the request selected, in `signedOps` order. */
+    walletIds: readonly bigint[];
+}
+/**
+ * Lifecycle event emitted by the transparent gasless execution mode (the
+ * `execution.onEvent` observer on {@link SymmioGaslessConfig}).
+ *
+ * `accepted` fires as soon as the service returns a request id — persist
+ * `{ requestId, service, protocolInstance, chainId }` there so an in-flight
+ * workflow survives a reload (there is no list-by-wallet endpoint).
+ * `broadcast` fires when a transaction hash appears, and `terminal` when the
+ * request reaches a terminal status.
+ */
+export type GaslessRelayEvent = ({
+    type: "accepted";
+} & GaslessAcceptedRequest) | {
+    type: "broadcast";
+    requestId: string;
+    txHash: Hash;
+    chainId: number;
+} | {
+    type: "terminal";
+    requestId: string;
+    status: GaslessRequestStatus;
+    txHash: Hash | null;
+    chainId: number;
+};
+/**
+ * The HTTP 202 acknowledgement returned by a deposit settlement submit —
+ * richer than the operations receipt: it echoes the swept deposit address and
+ * the observed, fee and credited amounts, in the collateral token's base units.
+ *
+ * The amounts are **acceptance-time estimates**, not the settlement result. The
+ * settlement sweeps the wallet's **full** collateral balance when the
+ * transaction executes, including anything that arrived after acceptance. The
+ * service's estimate deducts only the deposit fee, while the contract also
+ * charges the wallet creation fee (`getWalletCreationFee(owner, walletId)` on
+ * the GaslessLayer) when the settlement first deploys the wallet. Take the final
+ * net credit from the settlement transaction's `WalletDepositSettled` event or
+ * the sub-account's balance, never from `creditedAmount`.
+ */
+export interface GaslessDepositSubmitReceipt {
+    /** Stable service tracking id (poll it with `service: "deposits"`). */
+    requestId: string;
+    /** Status at acceptance — normally {@link GaslessRequestStatus.QUEUED}. */
+    status: GaslessRequestStatus;
+    /** The deterministic deposit address being swept, as the service echoed it. */
+    depositAddress: Address;
+    /**
+     * The wallet id the service settled, echoed back. An acceptance that omits it
+     * means wallet `0`. The settle actions verify it against the requested wallet
+     * before returning.
+     */
+    walletId: bigint;
+    /** The owner whose wallet was settled (the submitted `owner`). */
+    owner: Address;
+    /**
+     * Collateral balance the service observed at the deposit address when it
+     * accepted the request (token base units). The settlement sweeps whatever
+     * balance is there at execution, which can differ. `null` when the
+     * acceptance omitted it.
+     */
+    observedAmount: bigint | null;
+    /**
+     * The deposit fee in the service's acceptance-time estimate (token base
+     * units). It excludes a wallet creation fee. `null` when the acceptance
+     * omitted it.
+     */
+    paidFee: bigint | null;
+    /**
+     * The net credit the service estimated at acceptance (token base units),
+     * with only the deposit fee deducted. Not the final credit: show it as an
+     * estimate. `null` when the acceptance omitted it.
+     */
+    creditedAmount: bigint | null;
+    /** The idempotency key the settlement was submitted with — persist it for a byte-identical resend. */
+    idempotencyKey: string;
+    /** Protocol instance the settlement was accepted on, or `null` for a proxy base that names none. */
+    protocolInstance: string | null;
+}
+/**
+ * Where a quoted fee is paid from — mirrors the GaslessLayer's
+ * `IGaslessLayer.FeeSource` enum.
+ */
+export declare enum GaslessFeeSource {
+    /** The payer's SYMMIO (Core) balance, drawn through its operational-fee allowance. Every relayed-operation fee. */
+    SYMMIO_ACCOUNT = 0,
+    /** Collateral held at a GaslessWallet — deposit-settlement and wallet-withdrawal fees. */
+    WALLET_COLLATERAL = 1
+}
+/**
+ * One operation's charge in a {@link GaslessFeeQuote}. Every amount is **18-decimal**,
+ * including fees paid from wallet collateral — rescale to the collateral token's
+ * decimals with `core18ToCollateral(amount, quote.collateralDecimals)`, which
+ * rounds up, before comparing against a raw token balance.
+ */
+export interface GaslessFeePayment {
+    /**
+     * The billed identity: the operation's `signerAccount.addr` for a relayed
+     * operation (a virtual account stays here even when its parent pays), or the
+     * GaslessWallet for a wallet-collateral payment.
+     */
+    account: Address;
+    /**
+     * Who the contract would charge, resolved from current allowances and
+     * balances. Show funding and allowance needs per `payer`, not per `account`.
+     *
+     * A relayed operation bills its billing parent — the parent sub-account of a
+     * virtual account, otherwise `account` itself — while the parent's
+     * operational-fee allowance and Core balance (free plus allocated) cover its
+     * running total in the batch. When they do not, and `account` is a live
+     * virtual account that covers the fee at its own fee multiplier, the preview
+     * already names that virtual account here. When neither can pay, and for an
+     * operation that costs nothing, it stays the parent. A single approval-only
+     * operation always names the parent.
+     *
+     * State changes inside the batch (an approval, a transfer, returned funds) can
+     * still move the charge at execution; only the service's simulation resolves
+     * that. A wallet-collateral payment names the GaslessWallet.
+     */
+    payer: Address;
+    /** Balance the fee is drawn from. */
+    source: GaslessFeeSource;
+    /** Operational fee for the operation's selectors after multipliers and the free quota (18-decimal). */
+    operationalFee18: bigint;
+    /** Deposit-settlement fee (18-decimal). */
+    depositFee18: bigint;
+    /**
+     * One-time fee for deploying a GaslessWallet — any wallet id, wallet `0`
+     * included (18-decimal). In a relayed batch it is charged once per undeployed
+     * wallet, on the first operation that executes from it, to `payer`'s SYMMIO
+     * balance; the free quota and fee multipliers do not reduce it. A
+     * wallet-collateral payment deducts it from the wallet's own collateral.
+     */
+    walletCreationFee18: bigint;
+    /** Native gas top-up fee (18-decimal). */
+    nativeTopUpFee18: bigint;
+    /** Collateral debited to fund a native gas top-up — a debit, not a fee (18-decimal). */
+    nativeGasCollateral18: bigint;
+}
+/**
+ * A fee quote from the GaslessLayer's `previewFeeQuote` view — a **preview**
+ * of what the relay transaction would charge at `blockNumber`, not a guarantee.
+ */
+export interface GaslessFeeQuote {
+    /** The collateral token fees are denominated in. */
+    collateralToken: Address;
+    /** The collateral token's decimals, for rescaling the 18-decimal amounts. */
+    collateralDecimals: number;
+    /**
+     * The contract's `block.number` when the quote was computed. On Arbitrum that
+     * is the L1 block estimate, not the L2 block number a receipt reports.
+     */
+    blockNumber: bigint;
+    /** Timestamp of that block (seconds). */
+    timestamp: bigint;
+    /**
+     * Whether the quote came from executing the real fee-collection path. Always
+     * `false` from `previewFeeQuote` — only the relayer's own simulation is exact,
+     * and it can differ (an approval or transfer inside the same batch that changes
+     * the fee or its payer, state changing before execution).
+     */
+    exact: boolean;
+    /** One entry per quoted operation (or one wallet-collateral payment), in order. */
+    payments: readonly GaslessFeePayment[];
+    /** Sum of every payment's fees (18-decimal). */
+    totalFee18: bigint;
+    /** `totalFee18` plus native gas collateral — the full debit (18-decimal). */
+    totalDebit18: bigint;
+    /** How many operations the billing accounts' daily free quota covers. */
+    freeOpsApplied: bigint;
+    /** Whether a native gas top-up would be sponsored. `false` for relayed operations. */
+    nativeSponsored: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/gasless/types.ts"],"names":[],"mappings":"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"}

package/dist/gasless/types.js

@@ -0,0 +1,33 @@
+//#region src/gasless/types.ts
+var e = /* @__PURE__ */ function(e) {
+	return e.QUEUED = "queued", e.SUBMITTED = "submitted", e.SUCCEEDED = "succeeded", e.REVERTED = "reverted", e.FAILED = "failed", e.REJECTED = "rejected", e;
+}({}), t = new Set([
+	"succeeded",
+	"reverted",
+	"failed",
+	"rejected"
+]);
+function n(e) {
+	return t.has(e);
+}
+var r = 1500, i = 3e3, a = 1e3, o = 15e3, s = {
+	minMs: 1e3,
+	maxMs: 2e3
+}, c = {
+	minMs: 3e3,
+	maxMs: 5e3
+};
+function l(e, t = Math.random) {
+	if (e && n(e)) return !1;
+	let r = e === "submitted" ? c : s;
+	return r.minMs + Math.floor(t() * (r.maxMs - r.minMs));
+}
+var u = /* @__PURE__ */ function(e) {
+	return e.SUBMITTED = "submitted", e.CONFIRMED = "confirmed", e.REVERTED = "reverted", e.FAILED = "failed", e;
+}({}), d = /* @__PURE__ */ function(e) {
+	return e[e.SYMMIO_ACCOUNT = 0] = "SYMMIO_ACCOUNT", e[e.WALLET_COLLATERAL = 1] = "WALLET_COLLATERAL", e;
+}({});
+//#endregion
+export { r as GASLESS_QUEUED_POLL_MS, a as GASLESS_STREAM_SETTLE_MS, o as GASLESS_STREAM_STALE_MS, i as GASLESS_SUBMITTED_POLL_MS, t as GASLESS_TERMINAL_STATUSES, d as GaslessFeeSource, e as GaslessRequestStatus, u as GaslessTransactionAttemptStatus, l as gaslessPollDelay, n as isGaslessRequestTerminal };
+
+//# sourceMappingURL=types.js.map

package/dist/gasless/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../src/gasless/types.ts"],"sourcesContent":["import type { Address, Hash } from \"viem\";\n\n/**\n * Lifecycle status of a GaslessQ relayer request.\n *\n * A request moves `QUEUED → SUBMITTED → SUCCEEDED | REVERTED | FAILED`, or\n * `QUEUED → REJECTED` when the worker's pre-broadcast re-check refuses it.\n *\n * `SUBMITTED` is **not** success — it only means a transaction hash exists.\n * Only `SUCCEEDED` is success.\n */\nexport enum GaslessRequestStatus {\n  /** Accepted by the service; no transaction broadcast yet. */\n  QUEUED = \"queued\",\n  /** A transaction was broadcast and `txHash` is stored; the receipt is pending. */\n  SUBMITTED = \"submitted\",\n  /** The relayed transaction mined with `status = 1`. */\n  SUCCEEDED = \"succeeded\",\n  /** The relayed transaction mined with `status = 0`; all charges rolled back. */\n  REVERTED = \"reverted\",\n  /** A service or RPC failure occurred before a successful receipt. */\n  FAILED = \"failed\",\n  /** The worker's re-check rejected the request before any broadcast. */\n  REJECTED = \"rejected\",\n}\n\n/**\n * The terminal {@link GaslessRequestStatus} values — polling stops here.\n *\n * @example\n * ```ts\n * refetchInterval: (query) => {\n *   const status = query.state.data?.status;\n *   return status && isGaslessRequestTerminal(status) ? false : 1_500;\n * }\n * ```\n */\nexport const GASLESS_TERMINAL_STATUSES: ReadonlySet<GaslessRequestStatus> = new Set([\n  GaslessRequestStatus.SUCCEEDED,\n  GaslessRequestStatus.REVERTED,\n  GaslessRequestStatus.FAILED,\n  GaslessRequestStatus.REJECTED,\n]);\n\n/**\n * Whether a {@link GaslessRequestStatus} is terminal (no further polling needed).\n *\n * @param status - The status to check.\n * @returns `true` for `succeeded`, `reverted`, `failed`, and `rejected`.\n */\nexport function isGaslessRequestTerminal(status: GaslessRequestStatus): boolean {\n  return GASLESS_TERMINAL_STATUSES.has(status);\n}\n\n/** Default poll cadence while a request is `queued` (service-recommended 1–2 s). */\nexport const GASLESS_QUEUED_POLL_MS = 1_500;\n/** Default poll cadence after a request is `submitted` (service-recommended 3–5 s). */\nexport const GASLESS_SUBMITTED_POLL_MS = 3_000;\n\n/**\n * Default window a status wait gives the stream to deliver before its first\n * HTTP read.\n *\n * Deliberately below {@link GASLESS_QUEUED_POLL_MS}: a stream that never\n * answers costs one *delayed* read, never an extra one, so the fallback is\n * strictly cheaper than the poll it defers.\n */\nexport const GASLESS_STREAM_SETTLE_MS = 1_000;\n\n/**\n * Default backstop for a *delivering* stream that reports nothing about the\n * workflow.\n *\n * Heartbeats prove the socket is alive, not that this workflow is being\n * reported, so a live-but-silent stream would otherwise blind a wait until the\n * socket's own liveness timer fires. Only records for this request reset it.\n */\nexport const GASLESS_STREAM_STALE_MS = 15_000;\n\n/** The service-recommended poll band for a `queued` request, in ms. */\nconst QUEUED_POLL_BAND = { minMs: 1_000, maxMs: 2_000 } as const;\n/** The service-recommended poll band for a `submitted` request, in ms. */\nconst SUBMITTED_POLL_BAND = { minMs: 3_000, maxMs: 5_000 } as const;\n\n/**\n * The poll cadence a request's current status calls for, or `false` once it is\n * terminal.\n *\n * Shared by the imperative wait loop and the query factory's `refetchInterval`\n * default so both follow one cadence. Terminal records are immutable, so\n * stopping is not an optimisation — a poll that never stops bills the service\n * forever for an answer that cannot change.\n *\n * The delay is drawn from the service's recommended band rather than fixed —\n * 1–2 s while `queued`, 3–5 s after `submitted`. The jitter is load-bearing on\n * the anonymous gateway: every workflow a page opened at the same moment would\n * otherwise poll in lockstep and spend the shared per-IP budget in bursts.\n *\n * Meant for a loop that sleeps between reads. As a TanStack `refetchInterval`\n * callback it needs a `random` that is stable between renders — TanStack\n * recomputes the callback on every render and restarts the countdown whenever\n * the value changed, so a fresh draw per call never fires. Use\n * `getGaslessRequestQueryOptions`, which seeds the draw from the query's own\n * fetch timestamps, rather than wiring this in by hand.\n *\n * @param status - The last known status, or `undefined` before the first fetch.\n * @param random - Source of randomness in `[0, 1)`. Injectable for deterministic tests.\n * @returns Milliseconds until the next poll, or `false` when terminal.\n *\n * @example\n * ```ts\n * for (let status: GaslessRequestStatus | undefined; ; ) {\n *   const delay = gaslessPollDelay(status);\n *   if (delay === false) break;\n *   await new Promise((resolve) => setTimeout(resolve, delay));\n *   status = (await getGaslessRequest(config, { requestId })).status;\n * }\n * ```\n */\nexport function gaslessPollDelay(\n  status: GaslessRequestStatus | undefined,\n  random: () => number = Math.random,\n): number | false {\n  if (status && isGaslessRequestTerminal(status)) return false;\n  const band = status === GaslessRequestStatus.SUBMITTED ? SUBMITTED_POLL_BAND : QUEUED_POLL_BAND;\n  return band.minMs + Math.floor(random() * (band.maxMs - band.minMs));\n}\n\n/**\n * Which GaslessQ sub-service a request id belongs to. Operations and deposit\n * settlements are stored by different services with different poll URLs, so a\n * request id alone does not identify a workflow — keep the service with it.\n */\nexport type GaslessService = \"operations\" | \"deposits\";\n\n/**\n * What every stored relayer request carries, whichever service stores it.\n *\n * Raw decimal-string amounts are parsed to `bigint`; addresses come back\n * lowercased by the service, so compare case-insensitively.\n */\nexport interface GaslessRequestBase {\n  /** Stable service tracking id — persist it to resume polling after a reload. */\n  requestId: string;\n  /** Current lifecycle status. */\n  status: GaslessRequestStatus;\n  /** Broadcast transaction hash, once the worker has submitted one. */\n  txHash: Hash | null;\n  /** Vendor error code on `rejected` / `reverted` / `failed`, when stored. */\n  errorCode: string | null;\n  /** Human-readable error message, when stored. */\n  errorMessage: string | null;\n  /** Idempotency key the request was submitted with, when stored. */\n  idempotencyKey: string | null;\n  /**\n   * The owner address the request is tracked under — `user_address` for an\n   * operation relay, `wallet_address` (which means the owner, not a\n   * GaslessWallet address) for a deposit settlement. `null` when the record\n   * stores none.\n   */\n  owner: Address | null;\n  /**\n   * The GaslessWallet ids the request selected, in `signedOps` order for an\n   * operation relay and as a single entry for a deposit settlement. Historical\n   * records that predate multiple wallets store no ids and normalize to zeros —\n   * one per stored operation — because an omitted id means wallet `0`.\n   */\n  walletIds: readonly bigint[];\n  /** When the service stored the request (ISO-8601), when recorded. */\n  createdAt: string | null;\n  /** When the service last updated the request (ISO-8601), when recorded. */\n  updatedAt: string | null;\n}\n\n/** A stored request of the `\"operations\"` service — a relayed InstantLayer batch. */\nexport interface GaslessOperationRequest extends GaslessRequestBase {\n  /** Discriminant: this record lives in the operations service. */\n  service: \"operations\";\n  /** The workflow label the submitter attached (`operationType`). */\n  operationType: string | null;\n  /** The client accounting id the submitter attached, when stored. */\n  accountId: string | null;\n  /**\n   * The fee the service recorded for the request, in the unit the service\n   * reports it in (a vendor quote, not an authoritative on-chain charge).\n   */\n  feeAmountRaw: bigint | null;\n}\n\n/** A stored request of the `\"deposits\"` service — a deposit-address settlement. */\nexport interface GaslessDepositRequest extends GaslessRequestBase {\n  /** Discriminant: this record lives in the deposits service. */\n  service: \"deposits\";\n  /** The deterministic deposit address being swept, when stored. */\n  depositAddress: Address | null;\n  /** The settled wallet's id. A record without one means wallet `0`. */\n  walletId: bigint;\n  /** Name of the sub-account the settlement credits, for a new-account settlement. */\n  accountName: string | null;\n  /** Collateral the service observed at the deposit address (token base units). */\n  amountRaw: bigint | null;\n  /** The deposit fee the service recorded (token base units). */\n  feeRaw: bigint | null;\n  /** The net credit the service recorded (token base units) — an estimate, not the final credit. */\n  creditedRaw: bigint | null;\n}\n\n/**\n * One stored relayer request, normalized from the service's snake_case record.\n *\n * A flat per-service union: the two services store different columns, so the\n * shared fields stay on {@link GaslessRequestBase} and each service's own\n * fields live on its variant. Narrow with `request.service`.\n *\n * @example\n * ```ts\n * const request = await getGaslessRequest(config, { requestId, service: \"deposits\" });\n * if (request.service === \"deposits\") console.log(request.depositAddress, request.walletId);\n * ```\n */\nexport type GaslessRequest = GaslessOperationRequest | GaslessDepositRequest;\n\n/**\n * The HTTP 202 acknowledgement returned by an operation relay submit.\n *\n * `paidFee` and `remainingFeeAllowance` are the service's **acceptance-time**\n * figures, passed through as reported by the service with no unit conversion.\n * They describe the request before it executes, so neither is an execution\n * result. The GaslessLayer collects the operational fee only when the\n * relayed batch executes, from the payer resolved at that moment, and a\n * reverted relay charges nothing. For authoritative numbers, read the payer's\n * Core allowance and balance (`getOperationalFeeAllowance`,\n * `getAccountBalanceOf` — both 18-decimal) and reconcile the charge from the\n * transaction receipt's `OperationalFeeRouted` events.\n */\nexport interface GaslessSubmitReceipt {\n  /** Stable service tracking id. Persist it immediately. */\n  requestId: string;\n  /** Status at acceptance — normally {@link GaslessRequestStatus.QUEUED}. */\n  status: GaslessRequestStatus;\n  /**\n   * The fee the service quoted for the request when it accepted it, as\n   * reported by the service. A quote, **not proof that a fee was collected**:\n   * the charge happens at execution and can differ, or not happen at all.\n   * `null` when the acceptance omitted it or reported an unparseable value —\n   * an acceptance is never discarded over a missing amount.\n   */\n  paidFee: bigint | null;\n  /**\n   * The service's acceptance-time view of the payer's remaining\n   * operational-fee allowance, as reported by the service. It is **not** a\n   * post-execution balance and not an authorization guarantee, and it can read\n   * `2^256 - 1` even while the payer's Core approval is bounded. Never display\n   * it as spendable or unlimited funds; read `getOperationalFeeAllowance`\n   * instead. `null` when the acceptance omitted it.\n   */\n  remainingFeeAllowance: bigint | null;\n  /**\n   * The idempotency key the request was submitted with — generated by the SDK\n   * when the caller passed none. Persist it: resending the byte-identical\n   * request under this key is what makes a lost response recoverable.\n   */\n  idempotencyKey: string;\n  /** Protocol instance the request was accepted on, or `null` for a proxy base that names none. */\n  protocolInstance: string | null;\n  /** The owner address the request is tracked under (the submitted `userAddress`). */\n  owner: Address;\n  /** The GaslessWallet ids the batch selected, in `signedOps` order — `0n` for ordinary InstantLayer operations. */\n  walletIds: readonly bigint[];\n}\n\n/**\n * Outcome of one EVM broadcast attempt — the attempt's own lifecycle, which is\n * **not** the request's {@link GaslessRequestStatus}. A request whose first\n * attempt is `reverted` can still end `succeeded` on a later attempt, so read\n * the outcome from the request and use the attempts for diagnosis.\n */\nexport enum GaslessTransactionAttemptStatus {\n  /** Broadcast to the network; no receipt observed yet. */\n  SUBMITTED = \"submitted\",\n  /** Mined with `status = 1`. */\n  CONFIRMED = \"confirmed\",\n  /** Mined with `status = 0`. */\n  REVERTED = \"reverted\",\n  /** Never mined — dropped, replaced, or rejected by the node. */\n  FAILED = \"failed\",\n}\n\n/**\n * One EVM broadcast attempt stored for a relayer request, with its receipt\n * outcome when observed.\n *\n * A request can broadcast more than once (a replacement transaction after a\n * stuck nonce or a gas bump), so a hash is not a stable handle on a workflow —\n * {@link GaslessRequestTransaction.requestId} is.\n */\nexport interface GaslessRequestTransaction {\n  /** Attempt row id. */\n  id: string;\n  /** Transaction hash of this attempt. */\n  txHash: Hash | null;\n  /** 1-based attempt number. */\n  attemptNumber: number;\n  /** Attempt outcome. */\n  status: GaslessTransactionAttemptStatus;\n  /**\n   * The request this attempt belongs to (the service's `entity_id`) — the same\n   * id `getGaslessRequest` is polled with.\n   */\n  requestId: string;\n  /** The service-side workflow that produced the attempt, e.g. `relay_instant`. */\n  workflow: string;\n  /**\n   * The raw receipt the service stored, as reported, or `null` while none was\n   * observed. Untyped on purpose: it is the relayer's node's JSON, not a viem\n   * `TransactionReceipt`, and its shape is the service's to change. Read the\n   * authoritative receipt from your own client with the attempt's `txHash`.\n   */\n  receipt: Record<string, unknown> | null;\n  /** Stored error code for a failed attempt, when present. */\n  errorCode: string | null;\n  /** Stored error message for a failed attempt, when present. */\n  errorMessage: string | null;\n  /** When the service stored the attempt (ISO-8601). */\n  createdAt: string | null;\n  /** When the service last updated the attempt (ISO-8601). */\n  updatedAt: string | null;\n}\n\n/**\n * Everything a consumer needs to resume an accepted gasless workflow after a\n * reload: the service, the instance and the identity that owns it.\n *\n * There is no list-by-wallet endpoint, so a request id lost to a reload is\n * unrecoverable — persist this whole shape under\n * `(environment, protocolInstance, service, requestId)`, with the owner and the\n * selected wallet ids, as soon as it arrives.\n */\nexport interface GaslessAcceptedRequest {\n  /** Stable service tracking id. */\n  requestId: string;\n  /** Which sub-service stores the request (its poll URL and its stream). */\n  service: GaslessService;\n  /** The chain the request was accepted on. */\n  chainId: number;\n  /** Protocol-instance key the request was accepted on, or `null` for a proxy base that names none. */\n  protocolInstance: string | null;\n  /** The idempotency key the request was submitted with. */\n  idempotencyKey: string;\n  /** The workflow label stored with the request, when the submit carried one. */\n  operationType: string | null;\n  /** The owner address the request is tracked under. */\n  owner: Address;\n  /** The GaslessWallet ids the request selected, in `signedOps` order. */\n  walletIds: readonly bigint[];\n}\n\n/**\n * Lifecycle event emitted by the transparent gasless execution mode (the\n * `execution.onEvent` observer on {@link SymmioGaslessConfig}).\n *\n * `accepted` fires as soon as the service returns a request id — persist\n * `{ requestId, service, protocolInstance, chainId }` there so an in-flight\n * workflow survives a reload (there is no list-by-wallet endpoint).\n * `broadcast` fires when a transaction hash appears, and `terminal` when the\n * request reaches a terminal status.\n */\nexport type GaslessRelayEvent =\n  | ({ type: \"accepted\" } & GaslessAcceptedRequest)\n  | { type: \"broadcast\"; requestId: string; txHash: Hash; chainId: number }\n  | {\n      type: \"terminal\";\n      requestId: string;\n      status: GaslessRequestStatus;\n      txHash: Hash | null;\n      chainId: number;\n    };\n\n/**\n * The HTTP 202 acknowledgement returned by a deposit settlement submit —\n * richer than the operations receipt: it echoes the swept deposit address and\n * the observed, fee and credited amounts, in the collateral token's base units.\n *\n * The amounts are **acceptance-time estimates**, not the settlement result. The\n * settlement sweeps the wallet's **full** collateral balance when the\n * transaction executes, including anything that arrived after acceptance. The\n * service's estimate deducts only the deposit fee, while the contract also\n * charges the wallet creation fee (`getWalletCreationFee(owner, walletId)` on\n * the GaslessLayer) when the settlement first deploys the wallet. Take the final\n * net credit from the settlement transaction's `WalletDepositSettled` event or\n * the sub-account's balance, never from `creditedAmount`.\n */\nexport interface GaslessDepositSubmitReceipt {\n  /** Stable service tracking id (poll it with `service: \"deposits\"`). */\n  requestId: string;\n  /** Status at acceptance — normally {@link GaslessRequestStatus.QUEUED}. */\n  status: GaslessRequestStatus;\n  /** The deterministic deposit address being swept, as the service echoed it. */\n  depositAddress: Address;\n  /**\n   * The wallet id the service settled, echoed back. An acceptance that omits it\n   * means wallet `0`. The settle actions verify it against the requested wallet\n   * before returning.\n   */\n  walletId: bigint;\n  /** The owner whose wallet was settled (the submitted `owner`). */\n  owner: Address;\n  /**\n   * Collateral balance the service observed at the deposit address when it\n   * accepted the request (token base units). The settlement sweeps whatever\n   * balance is there at execution, which can differ. `null` when the\n   * acceptance omitted it.\n   */\n  observedAmount: bigint | null;\n  /**\n   * The deposit fee in the service's acceptance-time estimate (token base\n   * units). It excludes a wallet creation fee. `null` when the acceptance\n   * omitted it.\n   */\n  paidFee: bigint | null;\n  /**\n   * The net credit the service estimated at acceptance (token base units),\n   * with only the deposit fee deducted. Not the final credit: show it as an\n   * estimate. `null` when the acceptance omitted it.\n   */\n  creditedAmount: bigint | null;\n  /** The idempotency key the settlement was submitted with — persist it for a byte-identical resend. */\n  idempotencyKey: string;\n  /** Protocol instance the settlement was accepted on, or `null` for a proxy base that names none. */\n  protocolInstance: string | null;\n}\n\n/**\n * Where a quoted fee is paid from — mirrors the GaslessLayer's\n * `IGaslessLayer.FeeSource` enum.\n */\nexport enum GaslessFeeSource {\n  /** The payer's SYMMIO (Core) balance, drawn through its operational-fee allowance. Every relayed-operation fee. */\n  SYMMIO_ACCOUNT = 0,\n  /** Collateral held at a GaslessWallet — deposit-settlement and wallet-withdrawal fees. */\n  WALLET_COLLATERAL = 1,\n}\n\n/**\n * One operation's charge in a {@link GaslessFeeQuote}. Every amount is **18-decimal**,\n * including fees paid from wallet collateral — rescale to the collateral token's\n * decimals with `core18ToCollateral(amount, quote.collateralDecimals)`, which\n * rounds up, before comparing against a raw token balance.\n */\nexport interface GaslessFeePayment {\n  /**\n   * The billed identity: the operation's `signerAccount.addr` for a relayed\n   * operation (a virtual account stays here even when its parent pays), or the\n   * GaslessWallet for a wallet-collateral payment.\n   */\n  account: Address;\n  /**\n   * Who the contract would charge, resolved from current allowances and\n   * balances. Show funding and allowance needs per `payer`, not per `account`.\n   *\n   * A relayed operation bills its billing parent — the parent sub-account of a\n   * virtual account, otherwise `account` itself — while the parent's\n   * operational-fee allowance and Core balance (free plus allocated) cover its\n   * running total in the batch. When they do not, and `account` is a live\n   * virtual account that covers the fee at its own fee multiplier, the preview\n   * already names that virtual account here. When neither can pay, and for an\n   * operation that costs nothing, it stays the parent. A single approval-only\n   * operation always names the parent.\n   *\n   * State changes inside the batch (an approval, a transfer, returned funds) can\n   * still move the charge at execution; only the service's simulation resolves\n   * that. A wallet-collateral payment names the GaslessWallet.\n   */\n  payer: Address;\n  /** Balance the fee is drawn from. */\n  source: GaslessFeeSource;\n  /** Operational fee for the operation's selectors after multipliers and the free quota (18-decimal). */\n  operationalFee18: bigint;\n  /** Deposit-settlement fee (18-decimal). */\n  depositFee18: bigint;\n  /**\n   * One-time fee for deploying a GaslessWallet — any wallet id, wallet `0`\n   * included (18-decimal). In a relayed batch it is charged once per undeployed\n   * wallet, on the first operation that executes from it, to `payer`'s SYMMIO\n   * balance; the free quota and fee multipliers do not reduce it. A\n   * wallet-collateral payment deducts it from the wallet's own collateral.\n   */\n  walletCreationFee18: bigint;\n  /** Native gas top-up fee (18-decimal). */\n  nativeTopUpFee18: bigint;\n  /** Collateral debited to fund a native gas top-up — a debit, not a fee (18-decimal). */\n  nativeGasCollateral18: bigint;\n}\n\n/**\n * A fee quote from the GaslessLayer's `previewFeeQuote` view — a **preview**\n * of what the relay transaction would charge at `blockNumber`, not a guarantee.\n */\nexport interface GaslessFeeQuote {\n  /** The collateral token fees are denominated in. */\n  collateralToken: Address;\n  /** The collateral token's decimals, for rescaling the 18-decimal amounts. */\n  collateralDecimals: number;\n  /**\n   * The contract's `block.number` when the quote was computed. On Arbitrum that\n   * is the L1 block estimate, not the L2 block number a receipt reports.\n   */\n  blockNumber: bigint;\n  /** Timestamp of that block (seconds). */\n  timestamp: bigint;\n  /**\n   * Whether the quote came from executing the real fee-collection path. Always\n   * `false` from `previewFeeQuote` — only the relayer's own simulation is exact,\n   * and it can differ (an approval or transfer inside the same batch that changes\n   * the fee or its payer, state changing before execution).\n   */\n  exact: boolean;\n  /** One entry per quoted operation (or one wallet-collateral payment), in order. */\n  payments: readonly GaslessFeePayment[];\n  /** Sum of every payment's fees (18-decimal). */\n  totalFee18: bigint;\n  /** `totalFee18` plus native gas collateral — the full debit (18-decimal). */\n  totalDebit18: bigint;\n  /** How many operations the billing accounts' daily free quota covers. */\n  freeOpsApplied: bigint;\n  /** Whether a native gas top-up would be sponsored. `false` for relayed operations. */\n  nativeSponsored: boolean;\n}\n"],"mappings":";AAWA,IAAY,IAAL,yBAAA,GAAA;QAEL,EAAA,SAAA,UAEA,EAAA,YAAA,aAEA,EAAA,YAAA,aAEA,EAAA,WAAA,YAEA,EAAA,SAAA,UAEA,EAAA,WAAA;AACF,EAAA,CAAA,CAAA,GAaa,IAA+D,IAAI,IAAI;;;;;AAKpF,CAAC;AAQD,SAAgB,EAAyB,GAAuC;CAC9E,OAAO,EAA0B,IAAI,CAAM;AAC7C;AAGA,IAAa,IAAyB,MAEzB,IAA4B,KAU5B,IAA2B,KAU3B,IAA0B,MAGjC,IAAmB;CAAE,OAAO;CAAO,OAAO;AAAM,GAEhD,IAAsB;CAAE,OAAO;CAAO,OAAO;AAAM;AAqCzD,SAAgB,EACd,GACA,IAAuB,KAAK,QACZ;CAChB,IAAI,KAAU,EAAyB,CAAM,GAAG,OAAO;CACvD,IAAM,IAAO,MAAA,cAA4C,IAAsB;CAC/E,OAAO,EAAK,QAAQ,KAAK,MAAM,EAAO,KAAK,EAAK,QAAQ,EAAK,MAAM;AACrE;AAuJA,IAAY,IAAL,yBAAA,GAAA;QAEL,EAAA,YAAA,aAEA,EAAA,YAAA,aAEA,EAAA,WAAA,YAEA,EAAA,SAAA;AACF,EAAA,CAAA,CAAA,GAsJY,IAAL,yBAAA,GAAA;QAEL,EAAA,EAAA,iBAAA,KAAA,kBAEA,EAAA,EAAA,oBAAA,KAAA;AACF,EAAA,CAAA,CAAA"}