@symmio/trading-core 3.0.0 → 3.1.0

package/dist/gasless/relayable-writes.d.ts

@@ -0,0 +1,163 @@
+import { AbiFunction, Hex } from 'viem';
+/**
+ * Which contract a relayable write targets.
+ *
+ * The transparent dispatcher does not read it — the seam that builds the call
+ * supplies the concrete address — but a gasless batch resolves each call's
+ * target from it (`relayGaslessBatch`), which is why it must name the contract
+ * that actually declares the function.
+ */
+export type GaslessRelayableTarget = "symmio" | "accountLayer" | "instantLayer";
+/** One relayable write: its target contract and the workflow label to relay under. */
+export interface GaslessRelayableWrite {
+    /** Contract the InstantLayer calls with this calldata. */
+    target: GaslessRelayableTarget;
+    /** Stable `operationType` label stored with relayed requests of this kind. */
+    operationType: string;
+}
+/**
+ * The selector → relayable-write map behind the transparent gasless mode.
+ * Selectors are derived from the shipped v0.8.6 ABIs at module load (never
+ * hardcoded), so an ABI change fails loudly here. Gasless is a perps-core-only
+ * facility, which makes the shipped ABIs exactly the deployment it targets.
+ *
+ * The map gates only what the SDK *attempts* — whether the vendor's fee policy
+ * accepts a selector is enforced server-side and surfaces as a submit error,
+ * so vendor policy never needs to be mirrored here.
+ *
+ * @internal
+ */
+export declare const GASLESS_RELAYABLE_WRITES: ReadonlyMap<Hex, GaslessRelayableWrite>;
+/**
+ * Every relayable write's ABI item, keyed by function name — the names a
+ * gasless batch call may use without passing an ABI
+ * (`{ functionName: "allocate", args }`), and each one's exact inputs.
+ *
+ * Derived from the same shipped ABIs as {@link GASLESS_RELAYABLE_SELECTORS}, so
+ * it holds exactly the relayable functions and can never name one the relayer
+ * would refuse. Use it to list the writes a batch can carry, or to show a
+ * call's signature.
+ *
+ * @example
+ * ```ts
+ * import { formatAbiItem } from "viem/utils";
+ *
+ * for (const item of GASLESS_RELAYABLE_FUNCTIONS.values()) console.log(formatAbiItem(item, { includeName: true }));
+ * // "allocate(uint256 amount)", …
+ * ```
+ */
+export declare const GASLESS_RELAYABLE_FUNCTIONS: ReadonlyMap<string, AbiFunction>;
+/**
+ * Every selector the transparent gasless mode can relay.
+ *
+ * **Not a delegation set.** This list includes `grantDelegation`, because the
+ * relayer carries it like any other write — but delegating that selector buys a
+ * session key nothing. The InstantLayer routes an operation whose target is the
+ * InstantLayer itself to `_verifyGrantOperation`, which reverts unless the
+ * signer is the account owner, and `grantDelegation` is `onlyOwner` on top of
+ * that: a delegate-signed grant is rejected by the contract outright. Handing a
+ * key the selector would only turn a clear "the owner must sign this" into an
+ * opaque relay rejection, so no delegation set carries it. To onboard a key,
+ * use `getSessionKeySelectors`.
+ */
+export declare const GASLESS_RELAYABLE_SELECTORS: readonly Hex[];
+/**
+ * The selectors safe to delegate to a session key for gasless account
+ * management — everything a key needs to run an account unattended **except**
+ * moving collateral out of it (see {@link GASLESS_SESSION_KEY_WITHDRAW_SELECTORS}).
+ *
+ * **Enumerated deliberately — never derived from {@link GASLESS_RELAYABLE_WRITES}.**
+ * Relayability and delegability are different questions. The first asks whether
+ * the relayer will carry a write at all; the second asks whether a browser-held
+ * key may sign it with no wallet prompt. Deriving this list from the map would
+ * widen a session key's authority every time a write becomes relayable, so each
+ * selector is listed here on its own merits.
+ *
+ * Deliberately absent, though relayable:
+ *
+ * - `initiateWithdraw` — the one write that picks a destination for the
+ *   sub-account's collateral. It lives in
+ *   {@link GASLESS_SESSION_KEY_WITHDRAW_SELECTORS}, granted only on an explicit
+ *   opt-in.
+ * - `createSubAccounts` — the one relayable AccountLayer write with **no**
+ *   `onlyAccountOwner` guard, so the InstantLayer's per-account delegation scope
+ *   never confines it: a key granted this selector is not bounded to the account
+ *   that granted it. It stays owner-signed for that reason, not because creating
+ *   an account is sensitive.
+ * - `deleteSubAccount` — destroys the account the delegation is scoped to, which
+ *   is not a step a key should take unattended.
+ * - `depositForAccount` and `depositAndAllocateForAccount` — `CoreFacet` funds
+ *   these straight from the signer's own token balance, so they reach collateral
+ *   that has not entered the sub-account yet.
+ * - `grantDelegation` — the contract rejects a delegate-signed grant (see
+ *   {@link GASLESS_RELAYABLE_SELECTORS}), so it would relay only to revert.
+ *
+ * `editAccountName` and `forceClosePosition` **are** in the set: the first is
+ * scope-confined by `onlyAccountOwner` and writes nothing but a bounded display
+ * string, and the second is guarded identically to the two force-cancels beside
+ * it and can only finish a close the owner already initiated.
+ *
+ * Pair it with `grantDelegation` (itself relayable, so the onboarding grant
+ * needs no gas either) to give a key promptless account management. In an app
+ * that also trades, prefer `getSessionKeySelectors`, which unions this set with
+ * the trade lifecycle and resolves the chain's contracts generation for you.
+ *
+ * @example
+ * ```ts
+ * await grantDelegation(config, {
+ *   account: { addr: subAccount, isPartyB: false },
+ *   delegatedSigner: sessionKey,
+ *   selectors: GASLESS_SESSION_KEY_SELECTORS,
+ *   expiryTimestamp,
+ *   gasless: true,
+ * });
+ * ```
+ */
+export declare const GASLESS_SESSION_KEY_SELECTORS: readonly Hex[];
+/**
+ * The withdrawal authority a session key only gets on an explicit opt-in:
+ * `initiateWithdraw`, and nothing else.
+ *
+ * It is split out of {@link GASLESS_SESSION_KEY_SELECTORS} because it is the one
+ * delegable write that names a destination.
+ * `initiateWithdraw(WithdrawPart[] parts, bool speedUp, bytes data)` carries a
+ * caller-supplied `receiver` in every part, so a key holding this selector can
+ * send the sub-account's collateral to an address of its own choosing — that is
+ * authority over the funds, not merely over the account's bookkeeping.
+ *
+ * The other two withdrawal writes stay in the base set precisely because they
+ * cannot do that: `finalizeWithdrawRequest(address user, uint256 requestId)` and
+ * `requestCancelWithdraw(uint256 requestId)` take no receiver at all. They can
+ * only settle or cancel a request whose destination an owner-signed
+ * `initiateWithdraw` already fixed, so the worst a key can do with them is
+ * complete or unwind a transfer the owner authorized.
+ *
+ * Grant it when a key must run withdrawals end to end unattended, and treat the
+ * grant as what it is: the key can drain the sub-account until the delegation
+ * expires or is revoked.
+ *
+ * @example
+ * ```ts
+ * await grantDelegation(config, {
+ *   account: { addr: subAccount, isPartyB: false },
+ *   delegatedSigner: sessionKey,
+ *   selectors: [...GASLESS_SESSION_KEY_SELECTORS, ...GASLESS_SESSION_KEY_WITHDRAW_SELECTORS],
+ *   expiryTimestamp,
+ *   gasless: true,
+ * });
+ * ```
+ */
+export declare const GASLESS_SESSION_KEY_WITHDRAW_SELECTORS: readonly Hex[];
+/**
+ * Whether a calldata selector is relayable by the transparent gasless mode.
+ *
+ * @param selector - A `0x`-prefixed 4-byte selector (calldata's first 4 bytes).
+ * @returns `true` when the gasless dispatcher would attempt to relay it.
+ *
+ * @example
+ * ```ts
+ * isGaslessRelayableSelector(calldata.slice(0, 10) as Hex);
+ * ```
+ */
+export declare function isGaslessRelayableSelector(selector: Hex): boolean;
+//# sourceMappingURL=relayable-writes.d.ts.map

package/dist/gasless/relayable-writes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relayable-writes.d.ts","sourceRoot":"","sources":["../../src/gasless/relayable-writes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgC,KAAK,WAAW,EAAE,KAAK,GAAG,EAAE,MAAM,MAAM,CAAC;AAahF;;;;;;;GAOG;AACH,MAAM,MAAM,sBAAsB,GAAG,QAAQ,GAAG,cAAc,GAAG,cAAc,CAAC;AAEhF,sFAAsF;AACtF,MAAM,WAAW,qBAAqB;IACpC,0DAA0D;IAC1D,MAAM,EAAE,sBAAsB,CAAC;IAC/B,8EAA8E;IAC9E,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB,EAAE,WAAW,CAAC,GAAG,EAAE,qBAAqB,CAgE3E,CAAC;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,2BAA2B,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CASxE,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,2BAA2B,EAAE,SAAS,GAAG,EAAyC,CAAC;AAEhG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,eAAO,MAAM,6BAA6B,EAAE,SAAS,GAAG,EAcvD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,sCAAsC,EAAE,SAAS,GAAG,EAEhE,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,GAAG,GAAG,OAAO,CAEjE"}

package/dist/gasless/relayable-writes.js

@@ -0,0 +1,113 @@
+import { accountLayerAbi as e } from "../symmio-contracts/abi/v0.8.6/account-layer.js";
+import { instantLayerAbi as t } from "../symmio-contracts/abi/v0.8.6/instant-layer.js";
+import { symmioAbi as n } from "../symmio-contracts/abi/v0.8.6/symmio.js";
+import { toFunctionSelector as r } from "viem";
+//#region src/gasless/relayable-writes.ts
+function i(e, t) {
+	let n = e.find((e) => e.type === "function" && e.name === t);
+	if (!n) throw Error(`relayable-writes: ABI is missing function "${t}" — the shipped ABI changed shape.`);
+	return r(n);
+}
+var a = new Map([
+	[i(n, "allocate"), {
+		target: "symmio",
+		operationType: "allocate"
+	}],
+	[i(n, "deallocate"), {
+		target: "symmio",
+		operationType: "deallocate"
+	}],
+	[i(n, "initiateWithdraw"), {
+		target: "symmio",
+		operationType: "initiateWithdraw"
+	}],
+	[i(n, "requestCancelWithdraw"), {
+		target: "symmio",
+		operationType: "requestCancelWithdraw"
+	}],
+	[i(n, "finalizeWithdrawRequest"), {
+		target: "symmio",
+		operationType: "finalizeWithdrawRequest"
+	}],
+	[i(n, "requestToCancelQuote"), {
+		target: "symmio",
+		operationType: "requestToCancelQuote"
+	}],
+	[i(n, "requestToCancelCloseRequest"), {
+		target: "symmio",
+		operationType: "requestToCancelCloseRequest"
+	}],
+	[i(n, "forceCancelQuote"), {
+		target: "symmio",
+		operationType: "forceCancelQuote"
+	}],
+	[i(n, "forceCancelCloseRequest"), {
+		target: "symmio",
+		operationType: "forceCancelCloseRequest"
+	}],
+	[i(n, "forceClosePosition"), {
+		target: "symmio",
+		operationType: "forceClosePosition"
+	}],
+	[i(n, "approveOperationalFeeWithMultiplier"), {
+		target: "symmio",
+		operationType: "approveOperationalFee"
+	}],
+	[i(e, "addMargin"), {
+		target: "accountLayer",
+		operationType: "addMargin"
+	}],
+	[i(e, "removeMargin"), {
+		target: "accountLayer",
+		operationType: "removeMargin"
+	}],
+	[i(e, "createSubAccounts"), {
+		target: "accountLayer",
+		operationType: "createSubAccounts"
+	}],
+	[i(e, "deleteSubAccount"), {
+		target: "accountLayer",
+		operationType: "deleteSubAccount"
+	}],
+	[i(e, "editAccountName"), {
+		target: "accountLayer",
+		operationType: "editAccountName"
+	}],
+	[i(e, "depositForAccount"), {
+		target: "accountLayer",
+		operationType: "depositForAccount"
+	}],
+	[i(e, "depositAndAllocateForAccount"), {
+		target: "accountLayer",
+		operationType: "depositAndAllocateForAccount"
+	}],
+	[i(t, "grantDelegation"), {
+		target: "instantLayer",
+		operationType: "grantDelegation"
+	}]
+]), o = new Map([
+	n,
+	e,
+	t
+].flatMap((e) => e.filter((e) => e.type === "function" && a.has(r(e))).map((e) => [e.name, e]))), s = [...a.keys()], c = [
+	i(n, "allocate"),
+	i(n, "deallocate"),
+	i(n, "requestCancelWithdraw"),
+	i(n, "finalizeWithdrawRequest"),
+	i(n, "requestToCancelQuote"),
+	i(n, "requestToCancelCloseRequest"),
+	i(n, "forceCancelQuote"),
+	i(n, "forceCancelCloseRequest"),
+	i(n, "forceClosePosition"),
+	i(n, "approveOperationalFeeWithMultiplier"),
+	i(e, "addMargin"),
+	i(e, "removeMargin"),
+	i(e, "editAccountName")
+], l = [i(n, "initiateWithdraw")];
+function u(e) {
+	return a.has(e.toLowerCase());
+}
+//#endregion
+export { o as GASLESS_RELAYABLE_FUNCTIONS, s as GASLESS_RELAYABLE_SELECTORS, a as GASLESS_RELAYABLE_WRITES, c as GASLESS_SESSION_KEY_SELECTORS, l as GASLESS_SESSION_KEY_WITHDRAW_SELECTORS, u as isGaslessRelayableSelector };
+
+//# sourceMappingURL=relayable-writes.js.map

package/dist/gasless/relayable-writes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relayable-writes.js","names":[],"sources":["../../src/gasless/relayable-writes.ts"],"sourcesContent":["import { toFunctionSelector, type Abi, type AbiFunction, type Hex } from \"viem\";\nimport { accountLayerAbi } from \"../symmio-contracts/abi/v0.8.6/account-layer\";\nimport { instantLayerAbi } from \"../symmio-contracts/abi/v0.8.6/instant-layer\";\nimport { symmioAbi } from \"../symmio-contracts/abi/v0.8.6/symmio\";\n\nfunction selectorFromAbi(abi: Abi, name: string): Hex {\n  const fragment = abi.find((item) => item.type === \"function\" && item.name === name) as AbiFunction | undefined;\n  if (!fragment) {\n    throw new Error(`relayable-writes: ABI is missing function \"${name}\" — the shipped ABI changed shape.`);\n  }\n  return toFunctionSelector(fragment);\n}\n\n/**\n * Which contract a relayable write targets.\n *\n * The transparent dispatcher does not read it — the seam that builds the call\n * supplies the concrete address — but a gasless batch resolves each call's\n * target from it (`relayGaslessBatch`), which is why it must name the contract\n * that actually declares the function.\n */\nexport type GaslessRelayableTarget = \"symmio\" | \"accountLayer\" | \"instantLayer\";\n\n/** One relayable write: its target contract and the workflow label to relay under. */\nexport interface GaslessRelayableWrite {\n  /** Contract the InstantLayer calls with this calldata. */\n  target: GaslessRelayableTarget;\n  /** Stable `operationType` label stored with relayed requests of this kind. */\n  operationType: string;\n}\n\n/**\n * The selector → relayable-write map behind the transparent gasless mode.\n * Selectors are derived from the shipped v0.8.6 ABIs at module load (never\n * hardcoded), so an ABI change fails loudly here. Gasless is a perps-core-only\n * facility, which makes the shipped ABIs exactly the deployment it targets.\n *\n * The map gates only what the SDK *attempts* — whether the vendor's fee policy\n * accepts a selector is enforced server-side and surfaces as a submit error,\n * so vendor policy never needs to be mirrored here.\n *\n * @internal\n */\nexport const GASLESS_RELAYABLE_WRITES: ReadonlyMap<Hex, GaslessRelayableWrite> = new Map<Hex, GaslessRelayableWrite>([\n  /** AccountLayer._call-proxied core-diamond writes (signerAccount = the sub-account). */\n  [selectorFromAbi(symmioAbi as Abi, \"allocate\"), { target: \"symmio\", operationType: \"allocate\" }],\n  [selectorFromAbi(symmioAbi as Abi, \"deallocate\"), { target: \"symmio\", operationType: \"deallocate\" }],\n  [selectorFromAbi(symmioAbi as Abi, \"initiateWithdraw\"), { target: \"symmio\", operationType: \"initiateWithdraw\" }],\n  [\n    selectorFromAbi(symmioAbi as Abi, \"requestCancelWithdraw\"),\n    { target: \"symmio\", operationType: \"requestCancelWithdraw\" },\n  ],\n  [\n    selectorFromAbi(symmioAbi as Abi, \"finalizeWithdrawRequest\"),\n    { target: \"symmio\", operationType: \"finalizeWithdrawRequest\" },\n  ],\n  [\n    selectorFromAbi(symmioAbi as Abi, \"requestToCancelQuote\"),\n    { target: \"symmio\", operationType: \"requestToCancelQuote\" },\n  ],\n  [\n    selectorFromAbi(symmioAbi as Abi, \"requestToCancelCloseRequest\"),\n    { target: \"symmio\", operationType: \"requestToCancelCloseRequest\" },\n  ],\n  [selectorFromAbi(symmioAbi as Abi, \"forceCancelQuote\"), { target: \"symmio\", operationType: \"forceCancelQuote\" }],\n  [\n    selectorFromAbi(symmioAbi as Abi, \"forceCancelCloseRequest\"),\n    { target: \"symmio\", operationType: \"forceCancelCloseRequest\" },\n  ],\n  [selectorFromAbi(symmioAbi as Abi, \"forceClosePosition\"), { target: \"symmio\", operationType: \"forceClosePosition\" }],\n  [\n    selectorFromAbi(symmioAbi as Abi, \"approveOperationalFeeWithMultiplier\"),\n    { target: \"symmio\", operationType: \"approveOperationalFee\" },\n  ],\n  /**\n   * Direct AccountLayer writes. The billing `signerAccount` differs per write:\n   * the VA's parent sub-account for margin, the named sub-account for the rest,\n   * and `gasless.account` (required) for `createSubAccounts`, whose accounts do\n   * not exist yet.\n   */\n  [selectorFromAbi(accountLayerAbi as Abi, \"addMargin\"), { target: \"accountLayer\", operationType: \"addMargin\" }],\n  [selectorFromAbi(accountLayerAbi as Abi, \"removeMargin\"), { target: \"accountLayer\", operationType: \"removeMargin\" }],\n  [\n    selectorFromAbi(accountLayerAbi as Abi, \"createSubAccounts\"),\n    { target: \"accountLayer\", operationType: \"createSubAccounts\" },\n  ],\n  [\n    selectorFromAbi(accountLayerAbi as Abi, \"deleteSubAccount\"),\n    { target: \"accountLayer\", operationType: \"deleteSubAccount\" },\n  ],\n  [\n    selectorFromAbi(accountLayerAbi as Abi, \"editAccountName\"),\n    { target: \"accountLayer\", operationType: \"editAccountName\" },\n  ],\n  [\n    selectorFromAbi(accountLayerAbi as Abi, \"depositForAccount\"),\n    { target: \"accountLayer\", operationType: \"depositForAccount\" },\n  ],\n  [\n    selectorFromAbi(accountLayerAbi as Abi, \"depositAndAllocateForAccount\"),\n    { target: \"accountLayer\", operationType: \"depositAndAllocateForAccount\" },\n  ],\n  /** Direct InstantLayer write (signerAccount = the granting sub-account itself). */\n  [\n    selectorFromAbi(instantLayerAbi as Abi, \"grantDelegation\"),\n    { target: \"instantLayer\", operationType: \"grantDelegation\" },\n  ],\n]);\n\n/**\n * Every relayable write's ABI item, keyed by function name — the names a\n * gasless batch call may use without passing an ABI\n * (`{ functionName: \"allocate\", args }`), and each one's exact inputs.\n *\n * Derived from the same shipped ABIs as {@link GASLESS_RELAYABLE_SELECTORS}, so\n * it holds exactly the relayable functions and can never name one the relayer\n * would refuse. Use it to list the writes a batch can carry, or to show a\n * call's signature.\n *\n * @example\n * ```ts\n * import { formatAbiItem } from \"viem/utils\";\n *\n * for (const item of GASLESS_RELAYABLE_FUNCTIONS.values()) console.log(formatAbiItem(item, { includeName: true }));\n * // \"allocate(uint256 amount)\", …\n * ```\n */\nexport const GASLESS_RELAYABLE_FUNCTIONS: ReadonlyMap<string, AbiFunction> = new Map(\n  [symmioAbi, accountLayerAbi, instantLayerAbi].flatMap((abi) =>\n    (abi as Abi)\n      .filter(\n        (item): item is AbiFunction =>\n          item.type === \"function\" && GASLESS_RELAYABLE_WRITES.has(toFunctionSelector(item)),\n      )\n      .map((item) => [item.name, item] as const),\n  ),\n);\n\n/**\n * Every selector the transparent gasless mode can relay.\n *\n * **Not a delegation set.** This list includes `grantDelegation`, because the\n * relayer carries it like any other write — but delegating that selector buys a\n * session key nothing. The InstantLayer routes an operation whose target is the\n * InstantLayer itself to `_verifyGrantOperation`, which reverts unless the\n * signer is the account owner, and `grantDelegation` is `onlyOwner` on top of\n * that: a delegate-signed grant is rejected by the contract outright. Handing a\n * key the selector would only turn a clear \"the owner must sign this\" into an\n * opaque relay rejection, so no delegation set carries it. To onboard a key,\n * use `getSessionKeySelectors`.\n */\nexport const GASLESS_RELAYABLE_SELECTORS: readonly Hex[] = [...GASLESS_RELAYABLE_WRITES.keys()];\n\n/**\n * The selectors safe to delegate to a session key for gasless account\n * management — everything a key needs to run an account unattended **except**\n * moving collateral out of it (see {@link GASLESS_SESSION_KEY_WITHDRAW_SELECTORS}).\n *\n * **Enumerated deliberately — never derived from {@link GASLESS_RELAYABLE_WRITES}.**\n * Relayability and delegability are different questions. The first asks whether\n * the relayer will carry a write at all; the second asks whether a browser-held\n * key may sign it with no wallet prompt. Deriving this list from the map would\n * widen a session key's authority every time a write becomes relayable, so each\n * selector is listed here on its own merits.\n *\n * Deliberately absent, though relayable:\n *\n * - `initiateWithdraw` — the one write that picks a destination for the\n *   sub-account's collateral. It lives in\n *   {@link GASLESS_SESSION_KEY_WITHDRAW_SELECTORS}, granted only on an explicit\n *   opt-in.\n * - `createSubAccounts` — the one relayable AccountLayer write with **no**\n *   `onlyAccountOwner` guard, so the InstantLayer's per-account delegation scope\n *   never confines it: a key granted this selector is not bounded to the account\n *   that granted it. It stays owner-signed for that reason, not because creating\n *   an account is sensitive.\n * - `deleteSubAccount` — destroys the account the delegation is scoped to, which\n *   is not a step a key should take unattended.\n * - `depositForAccount` and `depositAndAllocateForAccount` — `CoreFacet` funds\n *   these straight from the signer's own token balance, so they reach collateral\n *   that has not entered the sub-account yet.\n * - `grantDelegation` — the contract rejects a delegate-signed grant (see\n *   {@link GASLESS_RELAYABLE_SELECTORS}), so it would relay only to revert.\n *\n * `editAccountName` and `forceClosePosition` **are** in the set: the first is\n * scope-confined by `onlyAccountOwner` and writes nothing but a bounded display\n * string, and the second is guarded identically to the two force-cancels beside\n * it and can only finish a close the owner already initiated.\n *\n * Pair it with `grantDelegation` (itself relayable, so the onboarding grant\n * needs no gas either) to give a key promptless account management. In an app\n * that also trades, prefer `getSessionKeySelectors`, which unions this set with\n * the trade lifecycle and resolves the chain's contracts generation for you.\n *\n * @example\n * ```ts\n * await grantDelegation(config, {\n *   account: { addr: subAccount, isPartyB: false },\n *   delegatedSigner: sessionKey,\n *   selectors: GASLESS_SESSION_KEY_SELECTORS,\n *   expiryTimestamp,\n *   gasless: true,\n * });\n * ```\n */\nexport const GASLESS_SESSION_KEY_SELECTORS: readonly Hex[] = [\n  selectorFromAbi(symmioAbi as Abi, \"allocate\"),\n  selectorFromAbi(symmioAbi as Abi, \"deallocate\"),\n  selectorFromAbi(symmioAbi as Abi, \"requestCancelWithdraw\"),\n  selectorFromAbi(symmioAbi as Abi, \"finalizeWithdrawRequest\"),\n  selectorFromAbi(symmioAbi as Abi, \"requestToCancelQuote\"),\n  selectorFromAbi(symmioAbi as Abi, \"requestToCancelCloseRequest\"),\n  selectorFromAbi(symmioAbi as Abi, \"forceCancelQuote\"),\n  selectorFromAbi(symmioAbi as Abi, \"forceCancelCloseRequest\"),\n  selectorFromAbi(symmioAbi as Abi, \"forceClosePosition\"),\n  selectorFromAbi(symmioAbi as Abi, \"approveOperationalFeeWithMultiplier\"),\n  selectorFromAbi(accountLayerAbi as Abi, \"addMargin\"),\n  selectorFromAbi(accountLayerAbi as Abi, \"removeMargin\"),\n  selectorFromAbi(accountLayerAbi as Abi, \"editAccountName\"),\n];\n\n/**\n * The withdrawal authority a session key only gets on an explicit opt-in:\n * `initiateWithdraw`, and nothing else.\n *\n * It is split out of {@link GASLESS_SESSION_KEY_SELECTORS} because it is the one\n * delegable write that names a destination.\n * `initiateWithdraw(WithdrawPart[] parts, bool speedUp, bytes data)` carries a\n * caller-supplied `receiver` in every part, so a key holding this selector can\n * send the sub-account's collateral to an address of its own choosing — that is\n * authority over the funds, not merely over the account's bookkeeping.\n *\n * The other two withdrawal writes stay in the base set precisely because they\n * cannot do that: `finalizeWithdrawRequest(address user, uint256 requestId)` and\n * `requestCancelWithdraw(uint256 requestId)` take no receiver at all. They can\n * only settle or cancel a request whose destination an owner-signed\n * `initiateWithdraw` already fixed, so the worst a key can do with them is\n * complete or unwind a transfer the owner authorized.\n *\n * Grant it when a key must run withdrawals end to end unattended, and treat the\n * grant as what it is: the key can drain the sub-account until the delegation\n * expires or is revoked.\n *\n * @example\n * ```ts\n * await grantDelegation(config, {\n *   account: { addr: subAccount, isPartyB: false },\n *   delegatedSigner: sessionKey,\n *   selectors: [...GASLESS_SESSION_KEY_SELECTORS, ...GASLESS_SESSION_KEY_WITHDRAW_SELECTORS],\n *   expiryTimestamp,\n *   gasless: true,\n * });\n * ```\n */\nexport const GASLESS_SESSION_KEY_WITHDRAW_SELECTORS: readonly Hex[] = [\n  selectorFromAbi(symmioAbi as Abi, \"initiateWithdraw\"),\n];\n\n/**\n * Whether a calldata selector is relayable by the transparent gasless mode.\n *\n * @param selector - A `0x`-prefixed 4-byte selector (calldata's first 4 bytes).\n * @returns `true` when the gasless dispatcher would attempt to relay it.\n *\n * @example\n * ```ts\n * isGaslessRelayableSelector(calldata.slice(0, 10) as Hex);\n * ```\n */\nexport function isGaslessRelayableSelector(selector: Hex): boolean {\n  return GASLESS_RELAYABLE_WRITES.has(selector.toLowerCase() as Hex);\n}\n"],"mappings":"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"}

package/dist/gasless/resolve-gasless.d.ts

@@ -0,0 +1,52 @@
+import { SymmioGaslessConfig } from '../core/chains/types.js';
+import { Config } from '../core/config/index.js';
+/**
+ * Parameters for {@link resolveGaslessService} / {@link supportsGaslessService}.
+ */
+export interface ResolveGaslessServiceParameters {
+    /** Target chain id. Defaults to the config's `defaultChainId`. */
+    chainId?: number;
+}
+/**
+ * Resolve the GaslessQ relayer service for a chain.
+ *
+ * Gasless is **chain-level**: a chain either carries a `gasless` block
+ * ({@link SymmioGaslessConfig}) or it does not — no solver is involved. The
+ * service additionally requires the perps-core contracts generation: the
+ * relayer verifies operations against the GaslessLayer/InstantLayer pair that
+ * only exists on `"0.8.6"` deployments, and backward compatibility with older
+ * contracts is intentionally unsupported. Both conditions fail fast here with
+ * a typed error, so a gasless action never signs a payload the gateway would
+ * reject.
+ *
+ * @param config - The SDK config.
+ * @param parameters - Optional chain override.
+ * @returns The chain's {@link SymmioGaslessConfig}.
+ * @throws {SymmError} `GASLESS_NOT_CONFIGURED` when the chain has no gasless block.
+ * @throws {SymmError} `GASLESS_UNSUPPORTED_CONTRACTS_VERSION` when the chain's
+ *   `contractsVersion` is not `"0.8.6"`.
+ *
+ * @example
+ * ```ts
+ * const { url, gaslessLayerAddress } = resolveGaslessService(config, { chainId });
+ * ```
+ */
+export declare function resolveGaslessService(config: Config, parameters?: ResolveGaslessServiceParameters): SymmioGaslessConfig;
+/**
+ * Whether the chain has a usable GaslessQ relayer service — the boolean twin of
+ * {@link resolveGaslessService}. Non-throwing: returns `false` for a chain
+ * without a gasless block, a non-perps-core chain, or an unknown chain. Use it
+ * for `enabled` gates and UI so gasless features hide instead of erroring where
+ * the relayer is unavailable.
+ *
+ * @param config - The SDK config.
+ * @param parameters - Optional chain override.
+ * @returns `true` when the chain has a usable gasless relayer configured.
+ *
+ * @example
+ * ```ts
+ * if (supportsGaslessService(config, { chainId })) showGaslessToggle();
+ * ```
+ */
+export declare function supportsGaslessService(config: Config, parameters?: ResolveGaslessServiceParameters): boolean;
+//# sourceMappingURL=resolve-gasless.d.ts.map

package/dist/gasless/resolve-gasless.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-gasless.d.ts","sourceRoot":"","sources":["../../src/gasless/resolve-gasless.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAG7C;;GAEG;AACH,MAAM,WAAW,+BAA+B;IAC9C,kEAAkE;IAClE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,EACd,UAAU,GAAE,+BAAoC,GAC/C,mBAAmB,CAiBrB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,GAAE,+BAAoC,GAAG,OAAO,CAOhH"}

package/dist/gasless/resolve-gasless.js

@@ -0,0 +1,19 @@
+import { SymmError as e } from "../shared/errors/symm-error.js";
+//#region src/gasless/resolve-gasless.ts
+function t(t, n = {}) {
+	let r = t.getChainConfig(n.chainId);
+	if (!r.gasless) throw new e("config", "GASLESS_NOT_CONFIGURED", `Gasless: chain ${r.chainId} has no gasless relayer service configured.`);
+	if (r.contractsVersion !== "0.8.6") throw new e("config", "GASLESS_UNSUPPORTED_CONTRACTS_VERSION", `Gasless: chain ${r.chainId} runs contracts ${r.contractsVersion}, but the gasless relayer supports only perps-core ("0.8.6") deployments.`);
+	return r.gasless;
+}
+function n(e, n = {}) {
+	try {
+		return t(e, n), !0;
+	} catch {
+		return !1;
+	}
+}
+//#endregion
+export { t as resolveGaslessService, n as supportsGaslessService };
+
+//# sourceMappingURL=resolve-gasless.js.map

package/dist/gasless/resolve-gasless.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-gasless.js","names":[],"sources":["../../src/gasless/resolve-gasless.ts"],"sourcesContent":["import type { SymmioGaslessConfig } from \"../core/chains/types\";\nimport type { Config } from \"../core/config\";\nimport { SymmError } from \"../shared/errors/symm-error\";\n\n/**\n * Parameters for {@link resolveGaslessService} / {@link supportsGaslessService}.\n */\nexport interface ResolveGaslessServiceParameters {\n  /** Target chain id. Defaults to the config's `defaultChainId`. */\n  chainId?: number;\n}\n\n/**\n * Resolve the GaslessQ relayer service for a chain.\n *\n * Gasless is **chain-level**: a chain either carries a `gasless` block\n * ({@link SymmioGaslessConfig}) or it does not — no solver is involved. The\n * service additionally requires the perps-core contracts generation: the\n * relayer verifies operations against the GaslessLayer/InstantLayer pair that\n * only exists on `\"0.8.6\"` deployments, and backward compatibility with older\n * contracts is intentionally unsupported. Both conditions fail fast here with\n * a typed error, so a gasless action never signs a payload the gateway would\n * reject.\n *\n * @param config - The SDK config.\n * @param parameters - Optional chain override.\n * @returns The chain's {@link SymmioGaslessConfig}.\n * @throws {SymmError} `GASLESS_NOT_CONFIGURED` when the chain has no gasless block.\n * @throws {SymmError} `GASLESS_UNSUPPORTED_CONTRACTS_VERSION` when the chain's\n *   `contractsVersion` is not `\"0.8.6\"`.\n *\n * @example\n * ```ts\n * const { url, gaslessLayerAddress } = resolveGaslessService(config, { chainId });\n * ```\n */\nexport function resolveGaslessService(\n  config: Config,\n  parameters: ResolveGaslessServiceParameters = {},\n): SymmioGaslessConfig {\n  const chain = config.getChainConfig(parameters.chainId);\n  if (!chain.gasless) {\n    throw new SymmError(\n      \"config\",\n      \"GASLESS_NOT_CONFIGURED\",\n      `Gasless: chain ${chain.chainId} has no gasless relayer service configured.`,\n    );\n  }\n  if (chain.contractsVersion !== \"0.8.6\") {\n    throw new SymmError(\n      \"config\",\n      \"GASLESS_UNSUPPORTED_CONTRACTS_VERSION\",\n      `Gasless: chain ${chain.chainId} runs contracts ${chain.contractsVersion}, but the gasless relayer supports only perps-core (\"0.8.6\") deployments.`,\n    );\n  }\n  return chain.gasless;\n}\n\n/**\n * Whether the chain has a usable GaslessQ relayer service — the boolean twin of\n * {@link resolveGaslessService}. Non-throwing: returns `false` for a chain\n * without a gasless block, a non-perps-core chain, or an unknown chain. Use it\n * for `enabled` gates and UI so gasless features hide instead of erroring where\n * the relayer is unavailable.\n *\n * @param config - The SDK config.\n * @param parameters - Optional chain override.\n * @returns `true` when the chain has a usable gasless relayer configured.\n *\n * @example\n * ```ts\n * if (supportsGaslessService(config, { chainId })) showGaslessToggle();\n * ```\n */\nexport function supportsGaslessService(config: Config, parameters: ResolveGaslessServiceParameters = {}): boolean {\n  try {\n    resolveGaslessService(config, parameters);\n    return true;\n  } catch {\n    return false;\n  }\n}\n"],"mappings":";;AAoCA,SAAgB,EACd,GACA,IAA8C,CAAC,GAC1B;CACrB,IAAM,IAAQ,EAAO,eAAe,EAAW,OAAO;CACtD,IAAI,CAAC,EAAM,SACT,MAAM,IAAI,EACR,UACA,0BACA,kBAAkB,EAAM,QAAQ,4CAClC;CAEF,IAAI,EAAM,qBAAqB,SAC7B,MAAM,IAAI,EACR,UACA,yCACA,kBAAkB,EAAM,QAAQ,kBAAkB,EAAM,iBAAiB,0EAC3E;CAEF,OAAO,EAAM;AACf;AAkBA,SAAgB,EAAuB,GAAgB,IAA8C,CAAC,GAAY;CAChH,IAAI;EAEF,OADA,EAAsB,GAAQ,CAAU,GACjC;CACT,QAAQ;EACN,OAAO;CACT;AACF"}

package/dist/gasless/resolve-wallet-identities.d.ts

@@ -0,0 +1,30 @@
+import { Address } from 'viem';
+import { Config } from '../core/config/index.js';
+/** The identities the GaslessLayer derives from a wallet operation's signer account. @internal */
+export interface GaslessWalletIdentities {
+    /** The account delegations are checked on: a live virtual account's parent, otherwise the account itself. */
+    canonicalAccount: Address;
+    /** The owner the wallet belongs to — `ownerOf(canonicalAccount)`, or the account itself when it has none. */
+    ownerWallet: Address;
+}
+/**
+ * The identities the GaslessLayer derives from a wallet operation, mirroring
+ * `GaslessWalletExecutionLib._walletOwnerForOperation`.
+ *
+ * A **live** virtual account rolls up to its parent (a deleted one stays
+ * itself, so a historical VA cannot widen authority); the wallet then belongs
+ * to `ownerOf(canonicalAccount)`, falling back to the account itself when the
+ * AccountLayer knows no owner — which is exactly what makes a bare EOA resolve
+ * to its own wallet.
+ *
+ * @param config - The SDK config.
+ * @param parameters - The chain and the operation's `signerAccount.addr`.
+ * @returns The canonical account and the wallet owner.
+ *
+ * @internal
+ */
+export declare function resolveGaslessWalletIdentities(config: Config, parameters: {
+    chainId?: number;
+    account: Address;
+}): Promise<GaslessWalletIdentities>;
+//# sourceMappingURL=resolve-wallet-identities.d.ts.map

package/dist/gasless/resolve-wallet-identities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-wallet-identities.d.ts","sourceRoot":"","sources":["../../src/gasless/resolve-wallet-identities.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,KAAK,OAAO,EAAE,MAAM,MAAM,CAAC;AACjE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAI7C,kGAAkG;AAClG,MAAM,WAAW,uBAAuB;IACtC,6GAA6G;IAC7G,gBAAgB,EAAE,OAAO,CAAC;IAC1B,6GAA6G;IAC7G,WAAW,EAAE,OAAO,CAAC;CACtB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,8BAA8B,CAClD,MAAM,EAAE,MAAM,EACd,UAAU,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,GACjD,OAAO,CAAC,uBAAuB,CAAC,CAUlC"}

package/dist/gasless/resolve-wallet-identities.js

@@ -0,0 +1,21 @@
+import { getVirtualAccount as e } from "../symmio-contracts/account-layer/actions/get-virtual-account.js";
+import { getSubAccount as t } from "../symmio-contracts/account-layer/actions/get-sub-account.js";
+import { isAddressEqual as n, zeroAddress as r } from "viem";
+//#region src/gasless/resolve-wallet-identities.ts
+async function i(i, a) {
+	let { chainId: o, account: s } = a, c = await e(i, {
+		chainId: o,
+		account: s
+	}), l = c.isExists ? c.parentAccount : s, u = await t(i, {
+		chainId: o,
+		account: l
+	});
+	return {
+		canonicalAccount: l,
+		ownerWallet: u.isExists && !n(u.owner, r) ? u.owner : l
+	};
+}
+//#endregion
+export { i as resolveGaslessWalletIdentities };
+
+//# sourceMappingURL=resolve-wallet-identities.js.map

package/dist/gasless/resolve-wallet-identities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-wallet-identities.js","names":[],"sources":["../../src/gasless/resolve-wallet-identities.ts"],"sourcesContent":["import { isAddressEqual, zeroAddress, type Address } from \"viem\";\nimport type { Config } from \"../core/config\";\nimport { getSubAccount } from \"../symmio-contracts/account-layer/actions/get-sub-account\";\nimport { getVirtualAccount } from \"../symmio-contracts/account-layer/actions/get-virtual-account\";\n\n/** The identities the GaslessLayer derives from a wallet operation's signer account. @internal */\nexport interface GaslessWalletIdentities {\n  /** The account delegations are checked on: a live virtual account's parent, otherwise the account itself. */\n  canonicalAccount: Address;\n  /** The owner the wallet belongs to — `ownerOf(canonicalAccount)`, or the account itself when it has none. */\n  ownerWallet: Address;\n}\n\n/**\n * The identities the GaslessLayer derives from a wallet operation, mirroring\n * `GaslessWalletExecutionLib._walletOwnerForOperation`.\n *\n * A **live** virtual account rolls up to its parent (a deleted one stays\n * itself, so a historical VA cannot widen authority); the wallet then belongs\n * to `ownerOf(canonicalAccount)`, falling back to the account itself when the\n * AccountLayer knows no owner — which is exactly what makes a bare EOA resolve\n * to its own wallet.\n *\n * @param config - The SDK config.\n * @param parameters - The chain and the operation's `signerAccount.addr`.\n * @returns The canonical account and the wallet owner.\n *\n * @internal\n */\nexport async function resolveGaslessWalletIdentities(\n  config: Config,\n  parameters: { chainId?: number; account: Address },\n): Promise<GaslessWalletIdentities> {\n  const { chainId, account } = parameters;\n\n  const virtualAccount = await getVirtualAccount(config, { chainId, account });\n  const canonicalAccount = virtualAccount.isExists ? virtualAccount.parentAccount : account;\n\n  const detail = await getSubAccount(config, { chainId, account: canonicalAccount });\n  const ownerWallet = detail.isExists && !isAddressEqual(detail.owner, zeroAddress) ? detail.owner : canonicalAccount;\n\n  return { canonicalAccount, ownerWallet };\n}\n"],"mappings":";;;;AA6BA,eAAsB,EACpB,GACA,GACkC;CAClC,IAAM,EAAE,YAAS,eAAY,GAEvB,IAAiB,MAAM,EAAkB,GAAQ;EAAE;EAAS;CAAQ,CAAC,GACrE,IAAmB,EAAe,WAAW,EAAe,gBAAgB,GAE5E,IAAS,MAAM,EAAc,GAAQ;EAAE;EAAS,SAAS;CAAiB,CAAC;CAGjF,OAAO;EAAE;EAAkB,aAFP,EAAO,YAAY,CAAC,EAAe,EAAO,OAAO,CAAW,IAAI,EAAO,QAAQ;CAE5D;AACzC"}

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

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

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

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

package/dist/gasless/resubmit-gasless-request/query.d.ts

@@ -0,0 +1,19 @@
+import { Config } from '../../core/config/index.js';
+import { ResubmitGaslessRequestParameters, ResubmitGaslessRequestReturnType } from './resubmit-gasless-request.js';
+/**
+ * Build TanStack Mutation options for {@link resubmitGaslessRequest}.
+ *
+ * @param config - The SDK config.
+ * @returns Options to pass to `useMutation`.
+ *
+ * @example
+ * ```ts
+ * const resubmit = useMutation(resubmitGaslessRequestMutationOptions(config));
+ * resubmit.mutate(pendingSubmit);
+ * ```
+ */
+export declare function resubmitGaslessRequestMutationOptions(config: Config): {
+    mutationKey: readonly ["resubmitGaslessRequest"];
+    mutationFn: (variables: ResubmitGaslessRequestParameters) => Promise<ResubmitGaslessRequestReturnType>;
+};
+//# sourceMappingURL=query.d.ts.map

package/dist/gasless/resubmit-gasless-request/query.d.ts.map

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

package/dist/gasless/resubmit-gasless-request/query.js

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

package/dist/gasless/resubmit-gasless-request/query.js.map

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

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

@@ -0,0 +1,50 @@
+import { Config } from '../../core/config/index.js';
+import { GaslessDepositSubmitReceipt, GaslessSubmitReceipt } from '../types.js';
+import { GaslessUnconfirmedSubmit } from '../unconfirmed-submit.js';
+/** Parameters for {@link resubmitGaslessRequest}: the recorded submit, unchanged. */
+export type ResubmitGaslessRequestParameters = GaslessUnconfirmedSubmit;
+/** Return type of {@link resubmitGaslessRequest}. */
+export type ResubmitGaslessRequestReturnType = GaslessSubmitReceipt | GaslessDepositSubmitReceipt;
+/**
+ * Resend an **unconfirmed** gasless submit, byte for byte, under its original
+ * idempotency key.
+ *
+ * This is the vendor's prescribed recovery for a lost response: the same key
+ * with the same payload either lands the request or returns the record the
+ * service already created, so it can never execute the intent twice. It is the
+ * *only* safe response to `GASLESS_SUBMIT_UNCONFIRMED` — re-running the intent
+ * through the wallet would double-execute whatever the relayer accepted.
+ *
+ * The body is sent exactly as recorded, never rebuilt: the signatures inside it
+ * cover specific nonces and deadlines, and a regenerated payload would be a
+ * different request under a key the service has already bound.
+ *
+ * A deposit settlement is re-verified the same way the original submit was —
+ * the wallet's deterministic address is read before the POST and checked
+ * against the acceptance — so a replay can never sweep a wallet you did not
+ * fund.
+ *
+ * @param config - The SDK config.
+ * @param submit - The record from `getGaslessUnconfirmedSubmit(err)`, unmodified.
+ * @returns The acceptance receipt: an operation receipt for `/gateway/relay-instant`,
+ *   a deposit receipt for either settlement path.
+ * @throws {SymmError} `GASLESS_NOT_CONFIGURED` / `GASLESS_UNSUPPORTED_CONTRACTS_VERSION` for the recorded chain.
+ * @throws {SymmError} `GASLESS_RESUBMIT_BODY_INVALID` when the record is not a submit this SDK produced.
+ * @throws {SymmApiError} `GASLESS_SUBMIT_UNCONFIRMED` again when the replay is itself
+ *   inconclusive — keep the record and try again later.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   await relayInstantOperations(config, parameters);
+ * } catch (err) {
+ *   const pending = getGaslessUnconfirmedSubmit(err);
+ *   if (!pending) throw err;
+ *   await store.save(pending);
+ *   const receipt = await resubmitGaslessRequest(config, pending);
+ *   await store.clear(pending.idempotencyKey);
+ * }
+ * ```
+ */
+export declare function resubmitGaslessRequest(config: Config, submit: ResubmitGaslessRequestParameters): Promise<ResubmitGaslessRequestReturnType>;
+//# sourceMappingURL=resubmit-gasless-request.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resubmit-gasless-request.d.ts","sourceRoot":"","sources":["../../../src/gasless/resubmit-gasless-request/resubmit-gasless-request.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAMhD,OAAO,KAAK,EAAE,2BAA2B,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAClF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AAItE,qFAAqF;AACrF,MAAM,MAAM,gCAAgC,GAAG,wBAAwB,CAAC;AAExE,qDAAqD;AACrD,MAAM,MAAM,gCAAgC,GAAG,oBAAoB,GAAG,2BAA2B,CAAC;AA0BlG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,gCAAgC,GACvC,OAAO,CAAC,gCAAgC,CAAC,CAmC3C"}

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

@@ -0,0 +1,52 @@
+import { SymmError as e } from "../../shared/errors/symm-error.js";
+import { postGaslessSubmit as t, resolveGaslessHttp as n } from "../http.js";
+import { parseGaslessWalletId as r } from "../wallet-id.js";
+import { toGaslessSubmitReceipt as i } from "../to-gasless-submit-receipt.js";
+import { getGaslessWalletAddress as a } from "../get-gasless-wallet-address/get-gasless-wallet-address.js";
+import { assertGaslessDepositWallet as o, toGaslessDepositReceipt as s } from "../to-gasless-deposit-receipt.js";
+import { isAddress as c } from "viem";
+//#region src/gasless/resubmit-gasless-request/resubmit-gasless-request.ts
+function l(t) {
+	if (typeof t != "object" || !t || Array.isArray(t)) throw new e("validation", "GASLESS_RESUBMIT_BODY_INVALID", "Gasless: the recorded submit has no JSON object body, so there is nothing to resend. Only a GaslessUnconfirmedSubmit taken from getGaslessUnconfirmedSubmit can be resubmitted.");
+	return t;
+}
+function u(t, n) {
+	let r = t[n];
+	if (typeof r != "string" || !c(r)) throw new e("validation", "GASLESS_RESUBMIT_BODY_INVALID", `Gasless: the recorded submit body has no valid "${n}" address, so the acceptance could not be attributed to an owner. Resubmit only a GaslessUnconfirmedSubmit taken from getGaslessUnconfirmedSubmit.`);
+	return r;
+}
+async function d(e, c) {
+	let { chainId: d, path: f, body: p, idempotencyKey: m } = c, h = n(e, {
+		chainId: d,
+		service: c.service
+	}), g = l(p);
+	if (f === "/gateway/relay-instant") {
+		let e = u(g, "userAddress"), n = Array.isArray(g.walletIds) ? g.walletIds.map((e, t) => r(e, `walletIds[${t}]`)) : [];
+		return i(await t(h, f, p, m), {
+			owner: e,
+			walletIds: n,
+			idempotencyKey: m,
+			protocolInstance: h.protocolInstance
+		});
+	}
+	let _ = u(g, "owner"), v = g.walletId === void 0 || g.walletId === null ? 0n : r(g.walletId), y = await a(e, {
+		chainId: d,
+		owner: _,
+		walletId: v
+	}), b = s(await t(h, f, p, m), {
+		owner: _,
+		walletId: v,
+		idempotencyKey: m,
+		protocolInstance: h.protocolInstance
+	});
+	return o(b, {
+		walletId: v,
+		depositAddress: y,
+		url: h.baseURL,
+		path: f
+	}), b;
+}
+//#endregion
+export { d as resubmitGaslessRequest };
+
+//# sourceMappingURL=resubmit-gasless-request.js.map