@symmio/trading-core 3.0.0 → 3.1.0

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

@@ -0,0 +1,148 @@
+import { Address } from 'viem';
+import { Config } from '../../core/config/index.js';
+import { ChainIdParameter, Compute, FromParameter } from '../../shared/types/properties.js';
+import { GaslessSubmitReceipt } from '../types.js';
+import { GaslessWalletCall } from './calls.js';
+/**
+ * Default workflow label stored with a wallet-execute request.
+ *
+ * @internal
+ */
+export declare const GASLESS_WALLET_EXECUTE_OPERATION_TYPE = "gaslessqWalletExecute";
+/**
+ * Parameters for {@link gaslessWalletExecute}.
+ */
+export type GaslessWalletExecuteParameters = Compute<ChainIdParameter & FromParameter & {
+    /**
+     * Owner of the deterministic gasless wallet. Defaults to `signerAccount`,
+     * or to the signing wallet's address when that is omitted too. When
+     * `signerAccount` names a sub-account the owner is read from the
+     * AccountLayer, so a session key never has to supply it.
+     */
+    owner?: Address;
+    /**
+     * Account whose InstantLayer delegations authorize the operation, whose
+     * wallet-operation nonce is consumed, and which the gateway bills.
+     * Defaults to `owner`.
+     *
+     * **Pass a sub-account whenever a session key signs.** `grantDelegation`
+     * is `onlyAccountOwner` and the AccountLayer knows no owner for a bare
+     * EOA, so a delegation with an EOA delegator can never be granted — the
+     * default therefore only ever works owner-signed. The wallet is unchanged
+     * either way: the gateway derives it from `ownerOf(signerAccount)`, which
+     * is the same owner and so the same address.
+     *
+     * It is also the billing account. An EOA holds no SYMMIO collateral, so
+     * the default is payable only while the daily free quota covers it; a
+     * funded sub-account is what makes the fee chargeable.
+     */
+    signerAccount?: Address;
+    /**
+     * Which of the owner's GaslessWallets the calls execute from. Defaults to
+     * `0n`, the original wallet.
+     *
+     * The id selects everything at once: the operation's signed `target`
+     * (`getGaslessWalletAddress(owner, walletId)`), the nonce stream
+     * (`walletOperationNonces(owner, walletId, signerAccount)`) and the
+     * `walletIds` entry sent with the relay. Each id is an independent wallet
+     * with its own address, balance and nonces — an id is an application
+     * convention, not something the contract registers, so persist your
+     * assignment under `(environment, protocolInstance, owner, walletId)`.
+     *
+     * A wallet deploys lazily on first use and its one-time creation fee is
+     * charged to the signer account then.
+     */
+    walletId?: bigint;
+    /**
+     * The calls to execute from the wallet, in order. The batch is atomic:
+     * if any call reverts, the whole operation reverts and nothing is charged.
+     */
+    calls: readonly GaslessWalletCall[];
+    /**
+     * Free-form workflow label (1-128 characters) stored with the request for
+     * metrics and vendor support. Defaults to `"gaslessqWalletExecute"`. Fees
+     * are **not** keyed from it — they come from the inner call selectors.
+     */
+    operationType?: string;
+    /** Non-secret client correlation data stored with the request. */
+    metadata?: Record<string, unknown>;
+}>;
+/** Return type of {@link gaslessWalletExecute}. */
+export type GaslessWalletExecuteReturnType = GaslessSubmitReceipt;
+/**
+ * Run **any contract call from the deterministic gasless wallet**, with no
+ * native gas — an atomic batch of arbitrary `{ target, value, data }` calls
+ * relayed by GaslessQ. Nothing in the SDK or the relayer restricts the inner
+ * targets or selectors; authority comes from the owner's EIP-712 signature and
+ * the wallet can only ever be moved by its owner.
+ *
+ * Give each call either raw `data` or an `{ abi, functionName, args }` triple
+ * the SDK encodes; the two forms mix freely in one batch. Typical uses are a
+ * collateral exit (a finalized withdrawal routed to the wallet), or an ERC-20
+ * `approve` followed by a bridge or router call.
+ *
+ * **The wallet's own balance never pays the fee.** The GaslessLayer prices the
+ * operation from the **inner** call selectors and charges it to the SYMMIO
+ * account's collateral, bounded by its diamond-side operational-fee allowance;
+ * a per-account daily free quota can waive it. Collateral parked at the wallet
+ * is not a funding source for gas.
+ *
+ * The signature scheme is deliberately different from ordinary operations:
+ * - `callData` is `GaslessWallet.execute((address,uint256,bytes)[])` (selector
+ *   `0x3f707e6b`) and the operation's `target` is the **wallet** address;
+ * - the EIP-712 domain is the **gateway** domain (`"GaslessGateway"`, with the
+ *   GaslessLayer as `verifyingContract`);
+ * - the signed struct has five fields (no `flexFields`, no `maxUses`) — the
+ *   relay body still carries `flexFields: []` / `maxUses: 1`, appended after
+ *   signing;
+ * - the nonce comes from `walletOperationNonces(owner, walletId, signerAccount) + 1`,
+ *   a separate counter from InstantLayer nonces, and a separate stream per wallet id;
+ * - `signerAccount.addr` defaults to the **owner wallet itself**; pass a
+ *   sub-account through `signerAccount` to sign with a session key.
+ *
+ * **Session keys.** A signer that is not the wallet's owner must hold
+ * InstantLayer delegations for the wallet-execution sentinel **and every inner
+ * call selector** — build them with `getGaslessWalletExecuteSelectors`. Because
+ * a delegation can only be granted on an account the AccountLayer knows an
+ * owner for, the delegation lives on a **sub-account**, which you then pass as
+ * `signerAccount`; the wallet it resolves to is unchanged. A missing grant
+ * throws `GASLESS_SIGNER_NOT_DELEGATED` before the signature prompt (disable
+ * with `execution.preflightDelegation: false`).
+ *
+ * Fire-and-forget: persist the returned `requestId` and poll to a terminal
+ * status. React consumers should reach for `useGaslessWalletExecute`, which
+ * confirms the request before it resolves.
+ *
+ * @param config - The SDK config (must have a `getWalletClient` resolver).
+ * @param parameters - The calls, optional wallet id and owner/chain/signer/label overrides.
+ * @returns The acceptance receipt; persist `requestId`, `owner` and `walletIds` immediately.
+ * @throws {SymmError} `GASLESS_NOT_CONFIGURED` / `GASLESS_UNSUPPORTED_CONTRACTS_VERSION` /
+ *   `GASLESS_WALLET_UNAVAILABLE`.
+ * @throws {SymmError} `GASLESS_WALLET_ID_INVALID` for a wallet id outside the `uint256` range.
+ * @throws {SymmError} `GASLESS_WALLET_OWNER_MISMATCH` when an explicit `owner` does not own
+ *   `signerAccount` — thrown before the signature prompt.
+ * @throws {SymmError} `GASLESS_SIGNER_NOT_DELEGATED` when a non-owner signer is
+ *   missing a delegation for the sentinel or an inner selector.
+ * @throws {SymmError} `GASLESS_NONCE_STREAM_BUSY` when an earlier relay on this
+ *   `(walletId, signerAccount)` stream is still unaccounted for.
+ * @throws {SymmApiError} `GASLESS_RELAY_SUBMIT_FAILED` on HTTP failure —
+ *   `InvalidWalletOperationTarget` in the decoded revert means the operation's
+ *   target was not the owner's wallet.
+ * @throws {SymmApiError} `GASLESS_SUBMIT_UNCONFIRMED` when the outcome could not be
+ *   established. The signature is spent either way: replay the submit with
+ *   `resubmitGaslessRequest`, never by signing a new operation.
+ *
+ * @example
+ * ```ts
+ * // Approve a router, then call it — one atomic, gas-free batch.
+ * const receipt = await gaslessWalletExecute(config, {
+ *   calls: [
+ *     { target: usdc, abi: erc20Abi, functionName: "approve", args: [router, amount] },
+ *     { target: router, data: routeCalldata },
+ *   ],
+ *   operationType: "bridgeWithdraw",
+ * });
+ * ```
+ */
+export declare function gaslessWalletExecute(config: Config, parameters: GaslessWalletExecuteParameters): Promise<GaslessWalletExecuteReturnType>;
+//# sourceMappingURL=gasless-wallet-execute.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gasless-wallet-execute.d.ts","sourceRoot":"","sources":["../../../src/gasless/gasless-wallet-execute/gasless-wallet-execute.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsC,KAAK,OAAO,EAAE,MAAM,MAAM,CAAC;AACxE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,+BAA+B,CAAC;AAkB9F,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAGrD,OAAO,EAAqB,KAAK,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAMpE;;;;GAIG;AACH,eAAO,MAAM,qCAAqC,0BAA0B,CAAC;AAE7E;;GAEG;AACH,MAAM,MAAM,8BAA8B,GAAG,OAAO,CAClD,gBAAgB,GACd,aAAa,GAAG;IACd;;;;;OAKG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;;;;;;;;;;;;;OAeG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,KAAK,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACpC;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,kEAAkE;IAClE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC,CACJ,CAAC;AAEF,mDAAmD;AACnD,MAAM,MAAM,8BAA8B,GAAG,oBAAoB,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,8BAA8B,GACzC,OAAO,CAAC,8BAA8B,CAAC,CAwKzC"}

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

@@ -0,0 +1,120 @@
+import { gaslessWalletAbi as e } from "../../symmio-contracts/abi/v0.8.6/gasless-wallet.js";
+import { SymmError as t } from "../../shared/errors/symm-error.js";
+import { generateSalt as n } from "../../solvers/instant-open/shared/operations.js";
+import { getIsDelegationActive as r } from "../../symmio-contracts/instant-layer/actions/get-is-delegation-active.js";
+import { generateGaslessIdempotencyKey as i, postGaslessSubmit as a, resolveGaslessHttp as o } from "../http.js";
+import { assertGaslessWalletId as s, toGaslessWalletIdWire as c } from "../wallet-id.js";
+import { toGaslessSubmitReceipt as l } from "../to-gasless-submit-receipt.js";
+import { blocksGaslessNonceStream as u, gaslessWalletNonceStreamKey as d, readGaslessStreamNonce as f, submitOnGaslessNonceStream as p, withGaslessNonceLock as m } from "../nonce-lock.js";
+import { toGaslessSafeNumber as h } from "../format-gasless-operation.js";
+import { toWalletCallTuple as g } from "./calls.js";
+import { getGaslessWalletExecuteSelectors as _ } from "./selectors.js";
+import { GASLESS_WALLET_OPERATION_TYPES as v, getGaslessGatewayEip712Domain as y } from "../eip712.js";
+import { getGaslessWalletAddress as b } from "../get-gasless-wallet-address/get-gasless-wallet-address.js";
+import { getGaslessWalletNonce as x } from "../get-gasless-wallet-nonce/get-gasless-wallet-nonce.js";
+import { resolveGaslessWalletIdentities as S } from "../resolve-wallet-identities.js";
+import { encodeFunctionData as C, isAddressEqual as w } from "viem";
+//#region src/gasless/gasless-wallet-execute/gasless-wallet-execute.ts
+var T = 600, E = "gaslessqWalletExecute";
+async function D(E, D) {
+	let { chainId: O, calls: k, from: A, metadata: j } = D, M = s(D.walletId ?? 0n), N = E.getChainConfig(O), P = o(E, {
+		chainId: O,
+		service: "operations"
+	}), F = await E.getWalletClient({
+		chainId: O,
+		from: A
+	}), I = F.account.address, L = D.signerAccount ?? D.owner ?? I, { canonicalAccount: R, ownerWallet: z } = D.signerAccount === void 0 ? {
+		canonicalAccount: L,
+		ownerWallet: D.owner ?? L
+	} : await S(E, {
+		chainId: O,
+		account: L
+	});
+	if (D.owner !== void 0 && !w(D.owner, z)) throw new t("validation", "GASLESS_WALLET_OWNER_MISMATCH", `Gasless: owner ${D.owner} does not own signerAccount ${L}, whose wallet belongs to ${z}. The GaslessLayer derives the wallet from the signer account's owner, so drop \`owner\` or pass the signer account that ${D.owner} owns.`);
+	let B = D.owner ?? z, V = C({
+		abi: e,
+		functionName: "execute",
+		args: [k.map(g)]
+	});
+	if ((N.gasless?.execution?.preflightDelegation ?? !0) && !w(I, B)) {
+		let e = _(k), n = await Promise.all(e.map((e) => r(E, {
+			chainId: O,
+			account: R,
+			delegate: I,
+			selector: e
+		}))), i = e.filter((e, t) => !n[t]);
+		if (i.length > 0) throw new t("validation", "GASLESS_SIGNER_NOT_DELEGATED", `Gasless: ${I} holds no delegation from ${R} for ${i.join(", ")}. Grant getGaslessWalletExecuteSelectors(calls) to the key, on a sub-account — an owner EOA cannot be a delegator.`);
+	}
+	let H = d(N.chainId, M, B, L);
+	return m(E, H, async () => {
+		let [e, t] = await Promise.all([b(E, {
+			chainId: O,
+			owner: B,
+			walletId: M
+		}), f(E, H, () => x(E, {
+			chainId: O,
+			owner: B,
+			walletId: M,
+			account: L
+		}))]), r = {
+			nonce: t + 1n,
+			deadline: BigInt(Math.floor(Date.now() / 1e3) + T),
+			salt: n()
+		}, o = {
+			signer: I,
+			target: e,
+			callData: V,
+			signerAccount: {
+				addr: L,
+				isPartyB: !1
+			},
+			replayAttackHeader: r
+		}, s = await F.signTypedData({
+			account: F.account,
+			domain: y(E, { chainId: O }),
+			types: v,
+			primaryType: "SignedOperation",
+			message: o
+		}), d = {
+			signer: o.signer,
+			target: o.target,
+			callData: o.callData,
+			signerAccount: o.signerAccount,
+			replayAttackHeader: {
+				nonce: h(r.nonce, "replayAttackHeader.nonce"),
+				deadline: h(r.deadline, "replayAttackHeader.deadline"),
+				salt: r.salt
+			}
+		}, m = i(), g = {
+			idempotencyKey: m,
+			userAddress: B,
+			accountId: L,
+			operationType: D.operationType ?? "gaslessqWalletExecute",
+			signedOps: [{
+				...d,
+				flexFields: [],
+				maxUses: 1
+			}],
+			signatures: [s],
+			walletIds: [c(M)],
+			fills: [[]],
+			flexFillerSignatures: [[]],
+			...j === void 0 ? {} : { metadata: j }
+		};
+		return p(E, H, {
+			signedNonce: r.nonce,
+			service: "operations",
+			chainId: N.chainId,
+			deadline: r.deadline
+		}, async () => l(await a(P, "/gateway/relay-instant", g, m), {
+			owner: B,
+			walletIds: [M],
+			idempotencyKey: m,
+			protocolInstance: P.protocolInstance
+		}), u);
+	});
+}
+//#endregion
+export { E as GASLESS_WALLET_EXECUTE_OPERATION_TYPE, D as gaslessWalletExecute };
+
+//# sourceMappingURL=gasless-wallet-execute.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gasless-wallet-execute.js","names":[],"sources":["../../../src/gasless/gasless-wallet-execute/gasless-wallet-execute.ts"],"sourcesContent":["import { encodeFunctionData, isAddressEqual, type Address } from \"viem\";\nimport type { Config } from \"../../core/config\";\nimport { SymmError } from \"../../shared/errors/symm-error\";\nimport type { ChainIdParameter, Compute, FromParameter } from \"../../shared/types/properties\";\nimport { generateSalt } from \"../../solvers/instant-open/shared/operations\";\nimport { gaslessWalletAbi } from \"../../symmio-contracts/abi/v0.8.6/gasless-wallet\";\nimport { getIsDelegationActive } from \"../../symmio-contracts/instant-layer/actions/get-is-delegation-active\";\nimport { GASLESS_WALLET_OPERATION_TYPES, getGaslessGatewayEip712Domain } from \"../eip712\";\nimport { toGaslessSafeNumber } from \"../format-gasless-operation\";\nimport { getGaslessWalletAddress } from \"../get-gasless-wallet-address/get-gasless-wallet-address\";\nimport { getGaslessWalletNonce } from \"../get-gasless-wallet-nonce/get-gasless-wallet-nonce\";\nimport { generateGaslessIdempotencyKey, postGaslessSubmit, resolveGaslessHttp } from \"../http\";\nimport {\n  blocksGaslessNonceStream,\n  gaslessWalletNonceStreamKey,\n  readGaslessStreamNonce,\n  submitOnGaslessNonceStream,\n  withGaslessNonceLock,\n} from \"../nonce-lock\";\nimport { resolveGaslessWalletIdentities } from \"../resolve-wallet-identities\";\nimport { toGaslessSubmitReceipt } from \"../to-gasless-submit-receipt\";\nimport type { GaslessSubmitReceipt } from \"../types\";\nimport { assertGaslessWalletId, toGaslessWalletIdWire } from \"../wallet-id\";\nimport type { GaslessWireOperationAccepted, GaslessWireRelayInstantRequest } from \"../wire-types\";\nimport { toWalletCallTuple, type GaslessWalletCall } from \"./calls\";\nimport { getGaslessWalletExecuteSelectors } from \"./selectors\";\n\n/** How long a wallet-operation signature stays valid. */\nconst GASLESS_WALLET_OPERATION_DEADLINE_SECONDS = 10 * 60;\n\n/**\n * Default workflow label stored with a wallet-execute request.\n *\n * @internal\n */\nexport const GASLESS_WALLET_EXECUTE_OPERATION_TYPE = \"gaslessqWalletExecute\";\n\n/**\n * Parameters for {@link gaslessWalletExecute}.\n */\nexport type GaslessWalletExecuteParameters = Compute<\n  ChainIdParameter &\n    FromParameter & {\n      /**\n       * Owner of the deterministic gasless wallet. Defaults to `signerAccount`,\n       * or to the signing wallet's address when that is omitted too. When\n       * `signerAccount` names a sub-account the owner is read from the\n       * AccountLayer, so a session key never has to supply it.\n       */\n      owner?: Address;\n      /**\n       * Account whose InstantLayer delegations authorize the operation, whose\n       * wallet-operation nonce is consumed, and which the gateway bills.\n       * Defaults to `owner`.\n       *\n       * **Pass a sub-account whenever a session key signs.** `grantDelegation`\n       * is `onlyAccountOwner` and the AccountLayer knows no owner for a bare\n       * EOA, so a delegation with an EOA delegator can never be granted — the\n       * default therefore only ever works owner-signed. The wallet is unchanged\n       * either way: the gateway derives it from `ownerOf(signerAccount)`, which\n       * is the same owner and so the same address.\n       *\n       * It is also the billing account. An EOA holds no SYMMIO collateral, so\n       * the default is payable only while the daily free quota covers it; a\n       * funded sub-account is what makes the fee chargeable.\n       */\n      signerAccount?: Address;\n      /**\n       * Which of the owner's GaslessWallets the calls execute from. Defaults to\n       * `0n`, the original wallet.\n       *\n       * The id selects everything at once: the operation's signed `target`\n       * (`getGaslessWalletAddress(owner, walletId)`), the nonce stream\n       * (`walletOperationNonces(owner, walletId, signerAccount)`) and the\n       * `walletIds` entry sent with the relay. Each id is an independent wallet\n       * with its own address, balance and nonces — an id is an application\n       * convention, not something the contract registers, so persist your\n       * assignment under `(environment, protocolInstance, owner, walletId)`.\n       *\n       * A wallet deploys lazily on first use and its one-time creation fee is\n       * charged to the signer account then.\n       */\n      walletId?: bigint;\n      /**\n       * The calls to execute from the wallet, in order. The batch is atomic:\n       * if any call reverts, the whole operation reverts and nothing is charged.\n       */\n      calls: readonly GaslessWalletCall[];\n      /**\n       * Free-form workflow label (1-128 characters) stored with the request for\n       * metrics and vendor support. Defaults to `\"gaslessqWalletExecute\"`. Fees\n       * are **not** keyed from it — they come from the inner call selectors.\n       */\n      operationType?: string;\n      /** Non-secret client correlation data stored with the request. */\n      metadata?: Record<string, unknown>;\n    }\n>;\n\n/** Return type of {@link gaslessWalletExecute}. */\nexport type GaslessWalletExecuteReturnType = GaslessSubmitReceipt;\n\n/**\n * Run **any contract call from the deterministic gasless wallet**, with no\n * native gas — an atomic batch of arbitrary `{ target, value, data }` calls\n * relayed by GaslessQ. Nothing in the SDK or the relayer restricts the inner\n * targets or selectors; authority comes from the owner's EIP-712 signature and\n * the wallet can only ever be moved by its owner.\n *\n * Give each call either raw `data` or an `{ abi, functionName, args }` triple\n * the SDK encodes; the two forms mix freely in one batch. Typical uses are a\n * collateral exit (a finalized withdrawal routed to the wallet), or an ERC-20\n * `approve` followed by a bridge or router call.\n *\n * **The wallet's own balance never pays the fee.** The GaslessLayer prices the\n * operation from the **inner** call selectors and charges it to the SYMMIO\n * account's collateral, bounded by its diamond-side operational-fee allowance;\n * a per-account daily free quota can waive it. Collateral parked at the wallet\n * is not a funding source for gas.\n *\n * The signature scheme is deliberately different from ordinary operations:\n * - `callData` is `GaslessWallet.execute((address,uint256,bytes)[])` (selector\n *   `0x3f707e6b`) and the operation's `target` is the **wallet** address;\n * - the EIP-712 domain is the **gateway** domain (`\"GaslessGateway\"`, with the\n *   GaslessLayer as `verifyingContract`);\n * - the signed struct has five fields (no `flexFields`, no `maxUses`) — the\n *   relay body still carries `flexFields: []` / `maxUses: 1`, appended after\n *   signing;\n * - the nonce comes from `walletOperationNonces(owner, walletId, signerAccount) + 1`,\n *   a separate counter from InstantLayer nonces, and a separate stream per wallet id;\n * - `signerAccount.addr` defaults to the **owner wallet itself**; pass a\n *   sub-account through `signerAccount` to sign with a session key.\n *\n * **Session keys.** A signer that is not the wallet's owner must hold\n * InstantLayer delegations for the wallet-execution sentinel **and every inner\n * call selector** — build them with `getGaslessWalletExecuteSelectors`. Because\n * a delegation can only be granted on an account the AccountLayer knows an\n * owner for, the delegation lives on a **sub-account**, which you then pass as\n * `signerAccount`; the wallet it resolves to is unchanged. A missing grant\n * throws `GASLESS_SIGNER_NOT_DELEGATED` before the signature prompt (disable\n * with `execution.preflightDelegation: false`).\n *\n * Fire-and-forget: persist the returned `requestId` and poll to a terminal\n * status. React consumers should reach for `useGaslessWalletExecute`, which\n * confirms the request before it resolves.\n *\n * @param config - The SDK config (must have a `getWalletClient` resolver).\n * @param parameters - The calls, optional wallet id and owner/chain/signer/label overrides.\n * @returns The acceptance receipt; persist `requestId`, `owner` and `walletIds` immediately.\n * @throws {SymmError} `GASLESS_NOT_CONFIGURED` / `GASLESS_UNSUPPORTED_CONTRACTS_VERSION` /\n *   `GASLESS_WALLET_UNAVAILABLE`.\n * @throws {SymmError} `GASLESS_WALLET_ID_INVALID` for a wallet id outside the `uint256` range.\n * @throws {SymmError} `GASLESS_WALLET_OWNER_MISMATCH` when an explicit `owner` does not own\n *   `signerAccount` — thrown before the signature prompt.\n * @throws {SymmError} `GASLESS_SIGNER_NOT_DELEGATED` when a non-owner signer is\n *   missing a delegation for the sentinel or an inner selector.\n * @throws {SymmError} `GASLESS_NONCE_STREAM_BUSY` when an earlier relay on this\n *   `(walletId, signerAccount)` stream is still unaccounted for.\n * @throws {SymmApiError} `GASLESS_RELAY_SUBMIT_FAILED` on HTTP failure —\n *   `InvalidWalletOperationTarget` in the decoded revert means the operation's\n *   target was not the owner's wallet.\n * @throws {SymmApiError} `GASLESS_SUBMIT_UNCONFIRMED` when the outcome could not be\n *   established. The signature is spent either way: replay the submit with\n *   `resubmitGaslessRequest`, never by signing a new operation.\n *\n * @example\n * ```ts\n * // Approve a router, then call it — one atomic, gas-free batch.\n * const receipt = await gaslessWalletExecute(config, {\n *   calls: [\n *     { target: usdc, abi: erc20Abi, functionName: \"approve\", args: [router, amount] },\n *     { target: router, data: routeCalldata },\n *   ],\n *   operationType: \"bridgeWithdraw\",\n * });\n * ```\n */\nexport async function gaslessWalletExecute(\n  config: Config,\n  parameters: GaslessWalletExecuteParameters,\n): Promise<GaslessWalletExecuteReturnType> {\n  const { chainId, calls, from, metadata } = parameters;\n  const walletId = assertGaslessWalletId(parameters.walletId ?? 0n);\n\n  const chain = config.getChainConfig(chainId);\n  const context = resolveGaslessHttp(config, { chainId, service: \"operations\" });\n  const walletClient = await config.getWalletClient({ chainId, from });\n  const signer = walletClient.account.address;\n\n  /**\n   * `signedOp.signerAccount.addr`: the nonce key, the delegation scope, and the\n   * billing identity. Defaults to `owner` so the owner-signed call is unchanged.\n   */\n  const account = parameters.signerAccount ?? parameters.owner ?? signer;\n\n  /**\n   * Without an explicit `signerAccount` the account is an owner EOA by\n   * definition of this API, and the gateway's own resolution is the identity on\n   * both counts — so skip two reads on the hot path rather than confirming what\n   * cannot differ.\n   */\n  const { canonicalAccount, ownerWallet } =\n    parameters.signerAccount === undefined\n      ? { canonicalAccount: account, ownerWallet: parameters.owner ?? account }\n      : await resolveGaslessWalletIdentities(config, { chainId, account });\n\n  /**\n   * An explicit `owner` that is not the one the GaslessLayer resolves for\n   * `signerAccount` would sign a `target` the contract never checks against:\n   * the wallet comes from `ownerOf(signerAccount)` on execution, so the\n   * operation would revert with `InvalidWalletOperationTarget` after the user\n   * paid for a prompt. Fail before the signature instead.\n   */\n  if (parameters.owner !== undefined && !isAddressEqual(parameters.owner, ownerWallet)) {\n    throw new SymmError(\n      \"validation\",\n      \"GASLESS_WALLET_OWNER_MISMATCH\",\n      `Gasless: owner ${parameters.owner} does not own signerAccount ${account}, whose wallet belongs to ${ownerWallet}. The GaslessLayer derives the wallet from the signer account's owner, so drop \\`owner\\` or pass the signer account that ${parameters.owner} owns.`,\n    );\n  }\n  const owner = parameters.owner ?? ownerWallet;\n\n  /** Encoded before any network work, so a malformed ABI call throws up front. */\n  const callData = encodeFunctionData({\n    abi: gaslessWalletAbi,\n    functionName: \"execute\",\n    args: [calls.map(toWalletCallTuple)],\n  });\n\n  /**\n   * A signer that is not the wallet's owner is a delegate, and the GaslessLayer\n   * demands an active delegation for the wallet-execution sentinel **and every\n   * inner selector**. Probing here turns a relayer-side\n   * `WalletDelegationMissing` into a local error that names the missing\n   * selectors, before the user is asked to sign anything.\n   */\n  if ((chain.gasless?.execution?.preflightDelegation ?? true) && !isAddressEqual(signer, owner)) {\n    const required = getGaslessWalletExecuteSelectors(calls);\n    const active = await Promise.all(\n      required.map((selector) =>\n        getIsDelegationActive(config, { chainId, account: canonicalAccount, delegate: signer, selector }),\n      ),\n    );\n    const missing = required.filter((_, index) => !active[index]);\n    if (missing.length > 0) {\n      throw new SymmError(\n        \"validation\",\n        \"GASLESS_SIGNER_NOT_DELEGATED\",\n        `Gasless: ${signer} holds no delegation from ${canonicalAccount} for ${missing.join(\", \")}. Grant getGaslessWalletExecuteSelectors(calls) to the key, on a sub-account — an owner EOA cannot be a delegator.`,\n      );\n    }\n  }\n\n  const streamKey = gaslessWalletNonceStreamKey(chain.chainId, walletId, owner, account);\n\n  return withGaslessNonceLock(config, streamKey, async () => {\n    const [wallet, currentNonce] = await Promise.all([\n      getGaslessWalletAddress(config, { chainId, owner, walletId }),\n      readGaslessStreamNonce(config, streamKey, () =>\n        getGaslessWalletNonce(config, { chainId, owner, walletId, account }),\n      ),\n    ]);\n\n    const replayAttackHeader = {\n      nonce: currentNonce + 1n,\n      deadline: BigInt(Math.floor(Date.now() / 1000) + GASLESS_WALLET_OPERATION_DEADLINE_SECONDS),\n      salt: generateSalt(),\n    };\n\n    /** The 5-field gateway-domain struct — exactly what gets signed. */\n    const message = {\n      signer,\n      target: wallet,\n      callData,\n      signerAccount: { addr: account, isPartyB: false },\n      replayAttackHeader,\n    };\n\n    const signature = await walletClient.signTypedData({\n      account: walletClient.account,\n      domain: getGaslessGatewayEip712Domain(config, { chainId }),\n      types: GASLESS_WALLET_OPERATION_TYPES,\n      primaryType: \"SignedOperation\",\n      message,\n    });\n\n    /** The wire twin of the signed struct: uint256 fields become JSON numbers. */\n    const wireOperation = {\n      signer: message.signer,\n      target: message.target,\n      callData: message.callData,\n      signerAccount: message.signerAccount,\n      replayAttackHeader: {\n        nonce: toGaslessSafeNumber(replayAttackHeader.nonce, \"replayAttackHeader.nonce\"),\n        deadline: toGaslessSafeNumber(replayAttackHeader.deadline, \"replayAttackHeader.deadline\"),\n        salt: replayAttackHeader.salt,\n      },\n    };\n\n    /**\n     * Minted here, never taken from the caller: this action signs a fresh\n     * operation on every call, so a key the caller could reuse would describe a\n     * different payload than the one it first keyed and the service would\n     * answer `409 IDEMPOTENCY_KEY_CONFLICT`. Replaying a lost response is\n     * `resubmitGaslessRequest`'s job, which reuses this key with the bytes that\n     * went with it.\n     */\n    const idempotencyKey = generateGaslessIdempotencyKey();\n    const body: GaslessWireRelayInstantRequest = {\n      idempotencyKey,\n      userAddress: owner,\n      accountId: account,\n      operationType: parameters.operationType ?? GASLESS_WALLET_EXECUTE_OPERATION_TYPE,\n      /** Transport-only fields (`flexFields`, `maxUses`) the signature deliberately excludes. */\n      signedOps: [{ ...wireOperation, flexFields: [], maxUses: 1 }],\n      signatures: [signature],\n      walletIds: [toGaslessWalletIdWire(walletId)],\n      fills: [[]],\n      flexFillerSignatures: [[]],\n      ...(metadata !== undefined ? { metadata } : {}),\n    };\n\n    return submitOnGaslessNonceStream(\n      config,\n      streamKey,\n      {\n        signedNonce: replayAttackHeader.nonce,\n        service: \"operations\",\n        chainId: chain.chainId,\n        deadline: replayAttackHeader.deadline,\n      },\n      async () => {\n        const raw = await postGaslessSubmit<GaslessWireOperationAccepted>(\n          context,\n          \"/gateway/relay-instant\",\n          body,\n          idempotencyKey,\n        );\n        return toGaslessSubmitReceipt(raw, {\n          owner,\n          walletIds: [walletId],\n          idempotencyKey,\n          protocolInstance: context.protocolInstance,\n        });\n      },\n      blocksGaslessNonceStream,\n    );\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA4BA,IAAM,IAA4C,KAOrC,IAAwC;AA8IrD,eAAsB,EACpB,GACA,GACyC;CACzC,IAAM,EAAE,YAAS,UAAO,SAAM,gBAAa,GACrC,IAAW,EAAsB,EAAW,YAAY,EAAE,GAE1D,IAAQ,EAAO,eAAe,CAAO,GACrC,IAAU,EAAmB,GAAQ;EAAE;EAAS,SAAS;CAAa,CAAC,GACvE,IAAe,MAAM,EAAO,gBAAgB;EAAE;EAAS;CAAK,CAAC,GAC7D,IAAS,EAAa,QAAQ,SAM9B,IAAU,EAAW,iBAAiB,EAAW,SAAS,GAQ1D,EAAE,qBAAkB,mBACxB,EAAW,kBAAkB,KAAA,IACzB;EAAE,kBAAkB;EAAS,aAAa,EAAW,SAAS;CAAQ,IACtE,MAAM,EAA+B,GAAQ;EAAE;EAAS;CAAQ,CAAC;CASvE,IAAI,EAAW,UAAU,KAAA,KAAa,CAAC,EAAe,EAAW,OAAO,CAAW,GACjF,MAAM,IAAI,EACR,cACA,iCACA,kBAAkB,EAAW,MAAM,8BAA8B,EAAQ,4BAA4B,EAAY,2HAA2H,EAAW,MAAM,OAC/P;CAEF,IAAM,IAAQ,EAAW,SAAS,GAG5B,IAAW,EAAmB;EAClC,KAAK;EACL,cAAc;EACd,MAAM,CAAC,EAAM,IAAI,CAAiB,CAAC;CACrC,CAAC;CASD,KAAK,EAAM,SAAS,WAAW,uBAAuB,OAAS,CAAC,EAAe,GAAQ,CAAK,GAAG;EAC7F,IAAM,IAAW,EAAiC,CAAK,GACjD,IAAS,MAAM,QAAQ,IAC3B,EAAS,KAAK,MACZ,EAAsB,GAAQ;GAAE;GAAS,SAAS;GAAkB,UAAU;GAAQ;EAAS,CAAC,CAClG,CACF,GACM,IAAU,EAAS,QAAQ,GAAG,MAAU,CAAC,EAAO,EAAM;EAC5D,IAAI,EAAQ,SAAS,GACnB,MAAM,IAAI,EACR,cACA,gCACA,YAAY,EAAO,4BAA4B,EAAiB,OAAO,EAAQ,KAAK,IAAI,EAAE,mHAC5F;CAEJ;CAEA,IAAM,IAAY,EAA4B,EAAM,SAAS,GAAU,GAAO,CAAO;CAErF,OAAO,EAAqB,GAAQ,GAAW,YAAY;EACzD,IAAM,CAAC,GAAQ,KAAgB,MAAM,QAAQ,IAAI,CAC/C,EAAwB,GAAQ;GAAE;GAAS;GAAO;EAAS,CAAC,GAC5D,EAAuB,GAAQ,SAC7B,EAAsB,GAAQ;GAAE;GAAS;GAAO;GAAU;EAAQ,CAAC,CACrE,CACF,CAAC,GAEK,IAAqB;GACzB,OAAO,IAAe;GACtB,UAAU,OAAO,KAAK,MAAM,KAAK,IAAI,IAAI,GAAI,IAAI,CAAyC;GAC1F,MAAM,EAAa;EACrB,GAGM,IAAU;GACd;GACA,QAAQ;GACR;GACA,eAAe;IAAE,MAAM;IAAS,UAAU;GAAM;GAChD;EACF,GAEM,IAAY,MAAM,EAAa,cAAc;GACjD,SAAS,EAAa;GACtB,QAAQ,EAA8B,GAAQ,EAAE,WAAQ,CAAC;GACzD,OAAO;GACP,aAAa;GACb;EACF,CAAC,GAGK,IAAgB;GACpB,QAAQ,EAAQ;GAChB,QAAQ,EAAQ;GAChB,UAAU,EAAQ;GAClB,eAAe,EAAQ;GACvB,oBAAoB;IAClB,OAAO,EAAoB,EAAmB,OAAO,0BAA0B;IAC/E,UAAU,EAAoB,EAAmB,UAAU,6BAA6B;IACxF,MAAM,EAAmB;GAC3B;EACF,GAUM,IAAiB,EAA8B,GAC/C,IAAuC;GAC3C;GACA,aAAa;GACb,WAAW;GACX,eAAe,EAAW,iBAAA;GAE1B,WAAW,CAAC;IAAE,GAAG;IAAe,YAAY,CAAC;IAAG,SAAS;GAAE,CAAC;GAC5D,YAAY,CAAC,CAAS;GACtB,WAAW,CAAC,EAAsB,CAAQ,CAAC;GAC3C,OAAO,CAAC,CAAC,CAAC;GACV,sBAAsB,CAAC,CAAC,CAAC;GACzB,GAAI,MAAa,KAAA,IAA2B,CAAC,IAAhB,EAAE,YAAS;EAC1C;EAEA,OAAO,EACL,GACA,GACA;GACE,aAAa,EAAmB;GAChC,SAAS;GACT,SAAS,EAAM;GACf,UAAU,EAAmB;EAC/B,GACA,YAOS,EAAuB,MANZ,EAChB,GACA,0BACA,GACA,CACF,GACmC;GACjC;GACA,WAAW,CAAC,CAAQ;GACpB;GACA,kBAAkB,EAAQ;EAC5B,CAAC,GAEH,CACF;CACF,CAAC;AACH"}

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

@@ -0,0 +1,5 @@
+export * from './calls.js';
+export * from './gasless-wallet-execute.js';
+export * from './query.js';
+export * from './selectors.js';
+//# sourceMappingURL=index.d.ts.map

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,38 @@
+import { Hex } from 'viem';
+import { GaslessWalletCall } from './calls.js';
+/**
+ * The exact selector set a session key must hold to run `calls` from the
+ * gasless wallet: the wallet-execution sentinel plus every inner call's
+ * selector, lowercased and de-duplicated.
+ *
+ * The GaslessLayer checks **each inner selector individually** on top of the
+ * sentinel — granting only the sentinel, or only the `execute` wrapper, is not
+ * enough. Build the batch first, then grant exactly what it needs.
+ *
+ * The delegation must be granted on a **sub-account**, not on the owner EOA:
+ * `grantDelegation` is `onlyAccountOwner`, and the AccountLayer knows no owner
+ * for a bare EOA, so an EOA delegator can never be authorized. Pass that same
+ * sub-account as `gaslessWalletExecute`'s `signerAccount`.
+ *
+ * Values are `bytes4` hex. `grantDelegation` rejects a duplicate-bearing array,
+ * which is why this de-duplicates.
+ *
+ * @param calls - The batch the session key must be able to run.
+ * @returns The selector set to grant, sentinel first.
+ *
+ * @example
+ * ```ts
+ * const calls = [{ target: usdc, abi: erc20Abi, functionName: "transfer", args: [to, amount] }];
+ *
+ * await grantDelegation(config, {
+ *   account: { addr: subAccount, isPartyB: false },
+ *   delegatedSigner: sessionKey,
+ *   selectors: getGaslessWalletExecuteSelectors(calls),
+ *   expiryTimestamp,
+ * });
+ *
+ * await gaslessWalletExecute(config, { calls, signerAccount: subAccount, from: sessionKey });
+ * ```
+ */
+export declare function getGaslessWalletExecuteSelectors(calls: readonly GaslessWalletCall[]): readonly Hex[];
+//# sourceMappingURL=selectors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.d.ts","sourceRoot":"","sources":["../../../src/gasless/gasless-wallet-execute/selectors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAEhC,OAAO,EAA6B,KAAK,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAE5E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,SAAS,iBAAiB,EAAE,GAAG,SAAS,GAAG,EAAE,CAepG"}

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

@@ -0,0 +1,15 @@
+import { GASLESS_WALLET_EXECUTION_SENTINEL_SELECTOR as e } from "../constants.js";
+import { gaslessWalletCallSelector as t } from "./calls.js";
+//#region src/gasless/gasless-wallet-execute/selectors.ts
+function n(n) {
+	let r = /* @__PURE__ */ new Set(), i = [];
+	for (let a of [e, ...n.map((e) => t(e))]) {
+		let e = a.toLowerCase();
+		r.has(e) || (r.add(e), i.push(e));
+	}
+	return i;
+}
+//#endregion
+export { n as getGaslessWalletExecuteSelectors };
+
+//# sourceMappingURL=selectors.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.js","names":[],"sources":["../../../src/gasless/gasless-wallet-execute/selectors.ts"],"sourcesContent":["import type { Hex } from \"viem\";\nimport { GASLESS_WALLET_EXECUTION_SENTINEL_SELECTOR } from \"../constants\";\nimport { gaslessWalletCallSelector, type GaslessWalletCall } from \"./calls\";\n\n/**\n * The exact selector set a session key must hold to run `calls` from the\n * gasless wallet: the wallet-execution sentinel plus every inner call's\n * selector, lowercased and de-duplicated.\n *\n * The GaslessLayer checks **each inner selector individually** on top of the\n * sentinel — granting only the sentinel, or only the `execute` wrapper, is not\n * enough. Build the batch first, then grant exactly what it needs.\n *\n * The delegation must be granted on a **sub-account**, not on the owner EOA:\n * `grantDelegation` is `onlyAccountOwner`, and the AccountLayer knows no owner\n * for a bare EOA, so an EOA delegator can never be authorized. Pass that same\n * sub-account as `gaslessWalletExecute`'s `signerAccount`.\n *\n * Values are `bytes4` hex. `grantDelegation` rejects a duplicate-bearing array,\n * which is why this de-duplicates.\n *\n * @param calls - The batch the session key must be able to run.\n * @returns The selector set to grant, sentinel first.\n *\n * @example\n * ```ts\n * const calls = [{ target: usdc, abi: erc20Abi, functionName: \"transfer\", args: [to, amount] }];\n *\n * await grantDelegation(config, {\n *   account: { addr: subAccount, isPartyB: false },\n *   delegatedSigner: sessionKey,\n *   selectors: getGaslessWalletExecuteSelectors(calls),\n *   expiryTimestamp,\n * });\n *\n * await gaslessWalletExecute(config, { calls, signerAccount: subAccount, from: sessionKey });\n * ```\n */\nexport function getGaslessWalletExecuteSelectors(calls: readonly GaslessWalletCall[]): readonly Hex[] {\n  const seen = new Set<Hex>();\n  const unique: Hex[] = [];\n\n  for (const selector of [\n    GASLESS_WALLET_EXECUTION_SENTINEL_SELECTOR as Hex,\n    ...calls.map((call) => gaslessWalletCallSelector(call)),\n  ]) {\n    const normalized = selector.toLowerCase() as Hex;\n    if (seen.has(normalized)) continue;\n    seen.add(normalized);\n    unique.push(normalized);\n  }\n\n  return unique;\n}\n"],"mappings":";;;AAsCA,SAAgB,EAAiC,GAAqD;CACpG,IAAM,oBAAO,IAAI,IAAS,GACpB,IAAgB,CAAC;CAEvB,KAAK,IAAM,KAAY,CACrB,GACA,GAAG,EAAM,KAAK,MAAS,EAA0B,CAAI,CAAC,CACxD,GAAG;EACD,IAAM,IAAa,EAAS,YAAY;EACpC,EAAK,IAAI,CAAU,MACvB,EAAK,IAAI,CAAU,GACnB,EAAO,KAAK,CAAU;CACxB;CAEA,OAAO;AACT"}

package/dist/gasless/get-gasless-batch-fee-quote/get-gasless-batch-fee-quote.d.ts

@@ -0,0 +1,72 @@
+import { Address } from 'viem';
+import { Config } from '../../core/config/index.js';
+import { ChainIdParameter, Compute } from '../../shared/types/properties.js';
+import { GaslessBatchCall } from '../batch/calls.js';
+import { GaslessFeeQuote } from '../types.js';
+/**
+ * Parameters for {@link getGaslessBatchFeeQuote}.
+ */
+export type GetGaslessBatchFeeQuoteParameters = Compute<ChainIdParameter & {
+    /**
+     * The sub-account every operation runs under — the account `relayGaslessBatch`
+     * would relay with. It decides the billing account (a virtual account bills
+     * its parent) and, for GaslessWallet entries, which owner's wallets execute.
+     */
+    account: Address;
+    /**
+     * The batch, in relay order. Quote the whole batch rather than one call at a
+     * time: free-quota slots and first-use wallet creation fees are allocated
+     * across it.
+     */
+    calls: readonly GaslessBatchCall[];
+}>;
+/** Return type of {@link getGaslessBatchFeeQuote}. */
+export type GetGaslessBatchFeeQuoteReturnType = GaslessFeeQuote;
+/**
+ * Preview what {@link relayGaslessBatch} would charge for the same calls —
+ * before any signature prompt, and without building a single operation by hand.
+ *
+ * The calls are resolved exactly as the relay resolves them, encoded as the
+ * `relayInstantBatch` call the relayer submits, and priced by the GaslessLayer's
+ * `previewFeeQuote`. The preview never checks nonces, deadlines, salts or
+ * signatures, so they are fixed placeholders here: the result depends only on
+ * the account and the calls, and caches cleanly.
+ *
+ * The quote is one row per call in `payments` (a GaslessWallet entry is one
+ * row, priced by its inner call selectors), with `totalFee18` the batch total.
+ * Every amount is 18-decimal. Group rows by `payer` and `source` to tell the
+ * user which balance pays: a relayed batch is charged to the SYMMIO account's
+ * Core balance, bounded by its operational-fee allowance, never to the wallet.
+ *
+ * It is a preview, not a guarantee: `exact` is always `false`, and an approval
+ * or a transfer inside the batch can change the final fee or its payer. It does
+ * not check that the payer can afford it — the relayer's own simulation is
+ * authoritative.
+ *
+ * @param config - The SDK config.
+ * @param parameters - The account, the batch, and an optional chain id.
+ * @returns The fee quote.
+ * @throws {SymmError} `GASLESS_NOT_CONFIGURED` / `GASLESS_UNSUPPORTED_CONTRACTS_VERSION`.
+ * @throws {SymmError} `GASLESS_EMPTY_BATCH`, `GASLESS_NOT_RELAYABLE` or `GASLESS_WALLET_ID_INVALID`
+ *   for a batch the relay could not carry — before any RPC call.
+ * @throws {SymmError} `GASLESS_FREE_QUOTA_EXHAUSTED`, `GASLESS_FEE_QUOTE_REVERTED` or
+ *   `GASLESS_LAYER_INTERFACE_UNSUPPORTED`, exactly as {@link getGaslessFeeQuote} does.
+ * @throws Viem's encoding error when an ABI-level call does not encode, and viem transport errors.
+ *
+ * @example
+ * ```ts
+ * import { getGaslessBatchFeeQuote } from "@symmio/trading-core";
+ * import { formatUnits } from "viem";
+ *
+ * const quote = await getGaslessBatchFeeQuote(config, {
+ *   account: subAccount,
+ *   calls: [
+ *     { functionName: "allocate", args: [amount] },
+ *     { functionName: "editAccountName", args: [subAccount, "Main"] },
+ *   ],
+ * });
+ * formatUnits(quote.totalFee18, 18); // "0.1"
+ * ```
+ */
+export declare function getGaslessBatchFeeQuote(config: Config, parameters: GetGaslessBatchFeeQuoteParameters): Promise<GetGaslessBatchFeeQuoteReturnType>;
+//# sourceMappingURL=get-gasless-batch-fee-quote.d.ts.map

package/dist/gasless/get-gasless-batch-fee-quote/get-gasless-batch-fee-quote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-gasless-batch-fee-quote.d.ts","sourceRoot":"","sources":["../../../src/gasless/get-gasless-batch-fee-quote/get-gasless-batch-fee-quote.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,KAAK,OAAO,EAAE,MAAM,MAAM,CAAC;AAC3D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AAC/E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAUvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAEhD;;GAEG;AACH,MAAM,MAAM,iCAAiC,GAAG,OAAO,CACrD,gBAAgB,GAAG;IACjB;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;;OAIG;IACH,KAAK,EAAE,SAAS,gBAAgB,EAAE,CAAC;CACpC,CACF,CAAC;AAEF,sDAAsD;AACtD,MAAM,MAAM,iCAAiC,GAAG,eAAe,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,iCAAiC,GAC5C,OAAO,CAAC,iCAAiC,CAAC,CAkC5C"}

package/dist/gasless/get-gasless-batch-fee-quote/get-gasless-batch-fee-quote.js

@@ -0,0 +1,42 @@
+import { resolveGaslessService as e } from "../resolve-gasless.js";
+import { getGaslessFeeQuote as t } from "../get-gasless-fee-quote/get-gasless-fee-quote.js";
+import { resolveGaslessWalletIdentities as n } from "../resolve-wallet-identities.js";
+import { buildGaslessBatchOperations as r, distinctGaslessBatchWalletIds as i, readGaslessBatchWalletTargets as a, resolveGaslessBatchEntries as o } from "../batch/resolve-gasless-batch.js";
+import { zeroAddress as s, zeroHash as c } from "viem";
+//#region src/gasless/get-gasless-batch-fee-quote/get-gasless-batch-fee-quote.ts
+async function l(l, u) {
+	let { account: d, calls: f } = u;
+	e(l, { chainId: u.chainId });
+	let p = l.getChainConfig(u.chainId), m = p.chainId, h = o(p.addresses, f), g = i(h), _ = /* @__PURE__ */ new Map();
+	if (g.length > 0) {
+		let { ownerWallet: e } = await n(l, {
+			chainId: m,
+			account: d
+		});
+		_ = await a(l, {
+			chainId: m,
+			owner: e,
+			walletIds: g
+		});
+	}
+	let v = r(h, {
+		signer: s,
+		account: d,
+		deadline: 0n,
+		instantNonce: 0n,
+		walletTargets: _,
+		walletNonces: /* @__PURE__ */ new Map(),
+		salt: () => c
+	});
+	return t(l, {
+		chainId: m,
+		operations: v.operations.map((e, t) => ({
+			operation: e,
+			walletId: v.walletIds[t]
+		}))
+	});
+}
+//#endregion
+export { l as getGaslessBatchFeeQuote };
+
+//# sourceMappingURL=get-gasless-batch-fee-quote.js.map

package/dist/gasless/get-gasless-batch-fee-quote/get-gasless-batch-fee-quote.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-gasless-batch-fee-quote.js","names":[],"sources":["../../../src/gasless/get-gasless-batch-fee-quote/get-gasless-batch-fee-quote.ts"],"sourcesContent":["import { zeroAddress, zeroHash, type Address } from \"viem\";\nimport type { Config } from \"../../core/config\";\nimport type { ChainIdParameter, Compute } from \"../../shared/types/properties\";\nimport type { GaslessBatchCall } from \"../batch/calls\";\nimport {\n  buildGaslessBatchOperations,\n  distinctGaslessBatchWalletIds,\n  readGaslessBatchWalletTargets,\n  resolveGaslessBatchEntries,\n} from \"../batch/resolve-gasless-batch\";\nimport { getGaslessFeeQuote } from \"../get-gasless-fee-quote/get-gasless-fee-quote\";\nimport { resolveGaslessService } from \"../resolve-gasless\";\nimport { resolveGaslessWalletIdentities } from \"../resolve-wallet-identities\";\nimport type { GaslessFeeQuote } from \"../types\";\n\n/**\n * Parameters for {@link getGaslessBatchFeeQuote}.\n */\nexport type GetGaslessBatchFeeQuoteParameters = Compute<\n  ChainIdParameter & {\n    /**\n     * The sub-account every operation runs under — the account `relayGaslessBatch`\n     * would relay with. It decides the billing account (a virtual account bills\n     * its parent) and, for GaslessWallet entries, which owner's wallets execute.\n     */\n    account: Address;\n    /**\n     * The batch, in relay order. Quote the whole batch rather than one call at a\n     * time: free-quota slots and first-use wallet creation fees are allocated\n     * across it.\n     */\n    calls: readonly GaslessBatchCall[];\n  }\n>;\n\n/** Return type of {@link getGaslessBatchFeeQuote}. */\nexport type GetGaslessBatchFeeQuoteReturnType = GaslessFeeQuote;\n\n/**\n * Preview what {@link relayGaslessBatch} would charge for the same calls —\n * before any signature prompt, and without building a single operation by hand.\n *\n * The calls are resolved exactly as the relay resolves them, encoded as the\n * `relayInstantBatch` call the relayer submits, and priced by the GaslessLayer's\n * `previewFeeQuote`. The preview never checks nonces, deadlines, salts or\n * signatures, so they are fixed placeholders here: the result depends only on\n * the account and the calls, and caches cleanly.\n *\n * The quote is one row per call in `payments` (a GaslessWallet entry is one\n * row, priced by its inner call selectors), with `totalFee18` the batch total.\n * Every amount is 18-decimal. Group rows by `payer` and `source` to tell the\n * user which balance pays: a relayed batch is charged to the SYMMIO account's\n * Core balance, bounded by its operational-fee allowance, never to the wallet.\n *\n * It is a preview, not a guarantee: `exact` is always `false`, and an approval\n * or a transfer inside the batch can change the final fee or its payer. It does\n * not check that the payer can afford it — the relayer's own simulation is\n * authoritative.\n *\n * @param config - The SDK config.\n * @param parameters - The account, the batch, and an optional chain id.\n * @returns The fee quote.\n * @throws {SymmError} `GASLESS_NOT_CONFIGURED` / `GASLESS_UNSUPPORTED_CONTRACTS_VERSION`.\n * @throws {SymmError} `GASLESS_EMPTY_BATCH`, `GASLESS_NOT_RELAYABLE` or `GASLESS_WALLET_ID_INVALID`\n *   for a batch the relay could not carry — before any RPC call.\n * @throws {SymmError} `GASLESS_FREE_QUOTA_EXHAUSTED`, `GASLESS_FEE_QUOTE_REVERTED` or\n *   `GASLESS_LAYER_INTERFACE_UNSUPPORTED`, exactly as {@link getGaslessFeeQuote} does.\n * @throws Viem's encoding error when an ABI-level call does not encode, and viem transport errors.\n *\n * @example\n * ```ts\n * import { getGaslessBatchFeeQuote } from \"@symmio/trading-core\";\n * import { formatUnits } from \"viem\";\n *\n * const quote = await getGaslessBatchFeeQuote(config, {\n *   account: subAccount,\n *   calls: [\n *     { functionName: \"allocate\", args: [amount] },\n *     { functionName: \"editAccountName\", args: [subAccount, \"Main\"] },\n *   ],\n * });\n * formatUnits(quote.totalFee18, 18); // \"0.1\"\n * ```\n */\nexport async function getGaslessBatchFeeQuote(\n  config: Config,\n  parameters: GetGaslessBatchFeeQuoteParameters,\n): Promise<GetGaslessBatchFeeQuoteReturnType> {\n  const { account, calls } = parameters;\n  resolveGaslessService(config, { chainId: parameters.chainId });\n  const chain = config.getChainConfig(parameters.chainId);\n  const chainId = chain.chainId;\n\n  const entries = resolveGaslessBatchEntries(chain.addresses, calls);\n  const walletIds = distinctGaslessBatchWalletIds(entries);\n\n  /**\n   * A wallet entry's signed target must be the real wallet address — the\n   * preview rejects any other with `InvalidWalletOperationTarget` — so only a\n   * batch with wallet entries pays for the owner and address reads.\n   */\n  let walletTargets = new Map<bigint, Address>();\n  if (walletIds.length > 0) {\n    const { ownerWallet } = await resolveGaslessWalletIdentities(config, { chainId, account });\n    walletTargets = await readGaslessBatchWalletTargets(config, { chainId, owner: ownerWallet, walletIds });\n  }\n\n  const built = buildGaslessBatchOperations(entries, {\n    signer: zeroAddress,\n    account,\n    deadline: 0n,\n    instantNonce: 0n,\n    walletTargets,\n    walletNonces: new Map(),\n    salt: () => zeroHash,\n  });\n\n  return getGaslessFeeQuote(config, {\n    chainId,\n    operations: built.operations.map((operation, index) => ({ operation, walletId: built.walletIds[index] })),\n  });\n}\n"],"mappings":";;;;;;AAoFA,eAAsB,EACpB,GACA,GAC4C;CAC5C,IAAM,EAAE,YAAS,aAAU;CAC3B,EAAsB,GAAQ,EAAE,SAAS,EAAW,QAAQ,CAAC;CAC7D,IAAM,IAAQ,EAAO,eAAe,EAAW,OAAO,GAChD,IAAU,EAAM,SAEhB,IAAU,EAA2B,EAAM,WAAW,CAAK,GAC3D,IAAY,EAA8B,CAAO,GAOnD,oBAAgB,IAAI,IAAqB;CAC7C,IAAI,EAAU,SAAS,GAAG;EACxB,IAAM,EAAE,mBAAgB,MAAM,EAA+B,GAAQ;GAAE;GAAS;EAAQ,CAAC;EACzF,IAAgB,MAAM,EAA8B,GAAQ;GAAE;GAAS,OAAO;GAAa;EAAU,CAAC;CACxG;CAEA,IAAM,IAAQ,EAA4B,GAAS;EACjD,QAAQ;EACR;EACA,UAAU;EACV,cAAc;EACd;EACA,8BAAc,IAAI,IAAI;EACtB,YAAY;CACd,CAAC;CAED,OAAO,EAAmB,GAAQ;EAChC;EACA,YAAY,EAAM,WAAW,KAAK,GAAW,OAAW;GAAE;GAAW,UAAU,EAAM,UAAU;EAAO,EAAE;CAC1G,CAAC;AACH"}

package/dist/gasless/get-gasless-batch-fee-quote/index.d.ts

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

package/dist/gasless/get-gasless-batch-fee-quote/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/gasless/get-gasless-batch-fee-quote/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,SAAS,CAAC"}

package/dist/gasless/get-gasless-batch-fee-quote/query.d.ts

@@ -0,0 +1,47 @@
+import { Config } from '../../core/config/index.js';
+import { Compute, ConfigKeyParameter, ExactPartial } from '../../shared/types/properties.js';
+import { QueryParameter, SymmioQueryOptions } from '../../shared/types/query.js';
+import { GetGaslessBatchFeeQuoteParameters, GetGaslessBatchFeeQuoteReturnType } from './get-gasless-batch-fee-quote.js';
+/** Data resolved by the {@link getGaslessBatchFeeQuoteQueryOptions} query. */
+export type GetGaslessBatchFeeQuoteData = GetGaslessBatchFeeQuoteReturnType;
+/**
+ * Build the TanStack Query key for {@link getGaslessBatchFeeQuoteQueryOptions}.
+ *
+ * Each call is keyed by its **encoded calldata**, not its ABI: an
+ * `{ abi, functionName, args }` call and the raw `{ data }` it encodes to share
+ * one cache entry, and an omitted `walletId` / `value` keys as `0n`.
+ *
+ * @param options - Partial query parameters.
+ * @returns A stable, hashable query key.
+ */
+export declare function getGaslessBatchFeeQuoteQueryKey(options?: Compute<ExactPartial<GetGaslessBatchFeeQuoteParameters> & ConfigKeyParameter>): readonly ["getGaslessBatchFeeQuote", Record<string, unknown>];
+/** Query-key type produced by {@link getGaslessBatchFeeQuoteQueryKey}. */
+export type GetGaslessBatchFeeQuoteQueryKey = ReturnType<typeof getGaslessBatchFeeQuoteQueryKey>;
+/**
+ * Options accepted by {@link getGaslessBatchFeeQuoteQueryOptions}.
+ */
+export type GetGaslessBatchFeeQuoteOptions = Compute<GetGaslessBatchFeeQuoteParameters & QueryParameter<GetGaslessBatchFeeQuoteData, Error, GetGaslessBatchFeeQuoteData, GetGaslessBatchFeeQuoteQueryKey>>;
+/** TanStack Query options returned by {@link getGaslessBatchFeeQuoteQueryOptions}. */
+export type GetGaslessBatchFeeQuoteQueryOptions = SymmioQueryOptions<GetGaslessBatchFeeQuoteData, Error, GetGaslessBatchFeeQuoteData, GetGaslessBatchFeeQuoteQueryKey>;
+/**
+ * Build TanStack Query options for {@link getGaslessBatchFeeQuote}.
+ *
+ * The key covers the account, the chain and every call's encoded calldata, so
+ * changing an argument re-quotes instead of reusing a stale quote.
+ *
+ * @param config - The SDK config.
+ * @param options - Query parameters and TanStack overrides.
+ * @returns Options to pass to `useQuery` / `queryClient.fetchQuery`.
+ *
+ * @example
+ * ```ts
+ * useQuery(
+ *   getGaslessBatchFeeQuoteQueryOptions(config, {
+ *     account: subAccount,
+ *     calls: [{ functionName: "allocate", args: [amount] }],
+ *   }),
+ * );
+ * ```
+ */
+export declare function getGaslessBatchFeeQuoteQueryOptions(config: Config, options: GetGaslessBatchFeeQuoteOptions): GetGaslessBatchFeeQuoteQueryOptions;
+//# sourceMappingURL=query.d.ts.map

package/dist/gasless/get-gasless-batch-fee-quote/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../src/gasless/get-gasless-batch-fee-quote/query.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAC/F,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAUnF,OAAO,EAEL,KAAK,iCAAiC,EACtC,KAAK,iCAAiC,EACvC,MAAM,+BAA+B,CAAC;AAEvC,8EAA8E;AAC9E,MAAM,MAAM,2BAA2B,GAAG,iCAAiC,CAAC;AAwC5E;;;;;;;;;GASG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,GAAE,OAAO,CAAC,YAAY,CAAC,iCAAiC,CAAC,GAAG,kBAAkB,CAAM,iEAM5F;AAED,0EAA0E;AAC1E,MAAM,MAAM,+BAA+B,GAAG,UAAU,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAEjG;;GAEG;AACH,MAAM,MAAM,8BAA8B,GAAG,OAAO,CAClD,iCAAiC,GAC/B,cAAc,CAAC,2BAA2B,EAAE,KAAK,EAAE,2BAA2B,EAAE,+BAA+B,CAAC,CACnH,CAAC;AAEF,sFAAsF;AACtF,MAAM,MAAM,mCAAmC,GAAG,kBAAkB,CAClE,2BAA2B,EAC3B,KAAK,EACL,2BAA2B,EAC3B,+BAA+B,CAChC,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mCAAmC,CACjD,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,8BAA8B,GACtC,mCAAmC,CAWrC"}