@symmio/trading-core 3.0.0 → 3.1.0

package/dist/symmio-contracts/instant-layer/query/get-revocation-cooldown.d.ts

@@ -0,0 +1,36 @@
+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 { GetRevocationCooldownParameters, GetRevocationCooldownReturnType } from '../actions/get-revocation-cooldown.js';
+/** Data resolved by the {@link getRevocationCooldownQueryOptions} query. */
+export type GetRevocationCooldownData = GetRevocationCooldownReturnType;
+/**
+ * Build the TanStack Query key for {@link getRevocationCooldownQueryOptions}.
+ *
+ * @param options - Partial query parameters.
+ * @returns A stable, hashable query key.
+ */
+export declare function getRevocationCooldownQueryKey(options?: Compute<ExactPartial<GetRevocationCooldownParameters> & ConfigKeyParameter>): readonly ["getRevocationCooldown", Record<string, unknown>];
+/** Query-key type produced by {@link getRevocationCooldownQueryKey}. */
+export type GetRevocationCooldownQueryKey = ReturnType<typeof getRevocationCooldownQueryKey>;
+/**
+ * Options accepted by {@link getRevocationCooldownQueryOptions}: an optional
+ * chain id and TanStack overrides.
+ */
+export type GetRevocationCooldownOptions = Compute<GetRevocationCooldownParameters & QueryParameter<GetRevocationCooldownData, Error, GetRevocationCooldownData, GetRevocationCooldownQueryKey>>;
+/** TanStack Query options returned by {@link getRevocationCooldownQueryOptions}. */
+export type GetRevocationCooldownQueryOptions = SymmioQueryOptions<GetRevocationCooldownData, Error, GetRevocationCooldownData, GetRevocationCooldownQueryKey>;
+/**
+ * Build TanStack Query options for {@link getRevocationCooldown}.
+ *
+ * @param config - The SDK config.
+ * @param options - Optional chain id and TanStack overrides.
+ * @returns Options to pass to `useQuery` / `queryClient.fetchQuery`.
+ *
+ * @example
+ * ```ts
+ * useQuery(getRevocationCooldownQueryOptions(config, {}));
+ * ```
+ */
+export declare function getRevocationCooldownQueryOptions(config: Config, options?: GetRevocationCooldownOptions): GetRevocationCooldownQueryOptions;
+//# sourceMappingURL=get-revocation-cooldown.d.ts.map

package/dist/symmio-contracts/instant-layer/query/get-revocation-cooldown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-revocation-cooldown.d.ts","sourceRoot":"","sources":["../../../../src/symmio-contracts/instant-layer/query/get-revocation-cooldown.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAClG,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AAEtF,OAAO,EAEL,KAAK,+BAA+B,EACpC,KAAK,+BAA+B,EACrC,MAAM,oCAAoC,CAAC;AAE5C,4EAA4E;AAC5E,MAAM,MAAM,yBAAyB,GAAG,+BAA+B,CAAC;AAExE;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,GAAE,OAAO,CAAC,YAAY,CAAC,+BAA+B,CAAC,GAAG,kBAAkB,CAAM,+DAG1F;AAED,wEAAwE;AACxE,MAAM,MAAM,6BAA6B,GAAG,UAAU,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAE7F;;;GAGG;AACH,MAAM,MAAM,4BAA4B,GAAG,OAAO,CAChD,+BAA+B,GAC7B,cAAc,CAAC,yBAAyB,EAAE,KAAK,EAAE,yBAAyB,EAAE,6BAA6B,CAAC,CAC7G,CAAC;AAEF,oFAAoF;AACpF,MAAM,MAAM,iCAAiC,GAAG,kBAAkB,CAChE,yBAAyB,EACzB,KAAK,EACL,yBAAyB,EACzB,6BAA6B,CAC9B,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,wBAAgB,iCAAiC,CAC/C,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,4BAAiC,GACzC,iCAAiC,CAOnC"}

package/dist/symmio-contracts/instant-layer/query/get-revocation-cooldown.js

@@ -0,0 +1,21 @@
+import { filterQueryOptions as e } from "../../../shared/utils/query.js";
+import { getRevocationCooldown as t } from "../actions/get-revocation-cooldown.js";
+//#region src/symmio-contracts/instant-layer/query/get-revocation-cooldown.ts
+function n(t = {}) {
+	return ["getRevocationCooldown", e(t)];
+}
+function r(e, r = {}) {
+	return {
+		...r.query,
+		queryKey: n({
+			...r,
+			configKey: e.getChainConfigKey(r.chainId)
+		}),
+		enabled: r.query?.enabled ?? !0,
+		queryFn: () => t(e, { chainId: r.chainId })
+	};
+}
+//#endregion
+export { n as getRevocationCooldownQueryKey, r as getRevocationCooldownQueryOptions };
+
+//# sourceMappingURL=get-revocation-cooldown.js.map

package/dist/symmio-contracts/instant-layer/query/get-revocation-cooldown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-revocation-cooldown.js","names":[],"sources":["../../../../src/symmio-contracts/instant-layer/query/get-revocation-cooldown.ts"],"sourcesContent":["import type { Config } from \"../../../core/config\";\nimport type { Compute, ConfigKeyParameter, ExactPartial } from \"../../../shared/types/properties\";\nimport type { QueryParameter, SymmioQueryOptions } from \"../../../shared/types/query\";\nimport { filterQueryOptions } from \"../../../shared/utils/query\";\nimport {\n  getRevocationCooldown,\n  type GetRevocationCooldownParameters,\n  type GetRevocationCooldownReturnType,\n} from \"../actions/get-revocation-cooldown\";\n\n/** Data resolved by the {@link getRevocationCooldownQueryOptions} query. */\nexport type GetRevocationCooldownData = GetRevocationCooldownReturnType;\n\n/**\n * Build the TanStack Query key for {@link getRevocationCooldownQueryOptions}.\n *\n * @param options - Partial query parameters.\n * @returns A stable, hashable query key.\n */\nexport function getRevocationCooldownQueryKey(\n  options: Compute<ExactPartial<GetRevocationCooldownParameters> & ConfigKeyParameter> = {},\n) {\n  return [\"getRevocationCooldown\", filterQueryOptions(options)] as const;\n}\n\n/** Query-key type produced by {@link getRevocationCooldownQueryKey}. */\nexport type GetRevocationCooldownQueryKey = ReturnType<typeof getRevocationCooldownQueryKey>;\n\n/**\n * Options accepted by {@link getRevocationCooldownQueryOptions}: an optional\n * chain id and TanStack overrides.\n */\nexport type GetRevocationCooldownOptions = Compute<\n  GetRevocationCooldownParameters &\n    QueryParameter<GetRevocationCooldownData, Error, GetRevocationCooldownData, GetRevocationCooldownQueryKey>\n>;\n\n/** TanStack Query options returned by {@link getRevocationCooldownQueryOptions}. */\nexport type GetRevocationCooldownQueryOptions = SymmioQueryOptions<\n  GetRevocationCooldownData,\n  Error,\n  GetRevocationCooldownData,\n  GetRevocationCooldownQueryKey\n>;\n\n/**\n * Build TanStack Query options for {@link getRevocationCooldown}.\n *\n * @param config - The SDK config.\n * @param options - Optional chain id and TanStack overrides.\n * @returns Options to pass to `useQuery` / `queryClient.fetchQuery`.\n *\n * @example\n * ```ts\n * useQuery(getRevocationCooldownQueryOptions(config, {}));\n * ```\n */\nexport function getRevocationCooldownQueryOptions(\n  config: Config,\n  options: GetRevocationCooldownOptions = {},\n): GetRevocationCooldownQueryOptions {\n  return {\n    ...options.query,\n    queryKey: getRevocationCooldownQueryKey({ ...options, configKey: config.getChainConfigKey(options.chainId) }),\n    enabled: options.query?.enabled ?? true,\n    queryFn: () => getRevocationCooldown(config, { chainId: options.chainId }),\n  };\n}\n"],"mappings":";;;AAmBA,SAAgB,EACd,IAAuF,CAAC,GACxF;CACA,OAAO,CAAC,yBAAyB,EAAmB,CAAO,CAAC;AAC9D;AAkCA,SAAgB,EACd,GACA,IAAwC,CAAC,GACN;CACnC,OAAO;EACL,GAAG,EAAQ;EACX,UAAU,EAA8B;GAAE,GAAG;GAAS,WAAW,EAAO,kBAAkB,EAAQ,OAAO;EAAE,CAAC;EAC5G,SAAS,EAAQ,OAAO,WAAW;EACnC,eAAe,EAAsB,GAAQ,EAAE,SAAS,EAAQ,QAAQ,CAAC;CAC3E;AACF"}

package/dist/symmio-contracts/instant-layer/query/initiate-revoke-delegation.d.ts

@@ -0,0 +1,22 @@
+import { Config } from '../../../core/config/index.js';
+import { InitiateRevokeDelegationParameters } from '../actions/initiate-revoke-delegation.js';
+/**
+ * Build TanStack Mutation options for {@link initiateRevokeDelegation}.
+ *
+ * The returned `mutationFn` takes the action's parameters and forwards them to
+ * `initiateRevokeDelegation(config, …)`. Framework layers compose invalidation
+ * and error normalization on top.
+ *
+ * @param config - The SDK config (must have a `getWalletClient` resolver).
+ * @returns Options to pass to `useMutation`.
+ *
+ * @example
+ * ```ts
+ * useMutation(initiateRevokeDelegationMutationOptions(config));
+ * ```
+ */
+export declare function initiateRevokeDelegationMutationOptions(config: Config): {
+    mutationKey: readonly ["initiateRevokeDelegation"];
+    mutationFn: (variables: InitiateRevokeDelegationParameters) => Promise<`0x${string}`>;
+};
+//# sourceMappingURL=initiate-revoke-delegation.d.ts.map

package/dist/symmio-contracts/instant-layer/query/initiate-revoke-delegation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initiate-revoke-delegation.d.ts","sourceRoot":"","sources":["../../../../src/symmio-contracts/instant-layer/query/initiate-revoke-delegation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAEL,KAAK,kCAAkC,EACxC,MAAM,uCAAuC,CAAC;AAE/C;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uCAAuC,CAAC,MAAM,EAAE,MAAM;;4BAG1C,kCAAkC;EAE7D"}

package/dist/symmio-contracts/instant-layer/query/initiate-revoke-delegation.js

@@ -0,0 +1,12 @@
+import { initiateRevokeDelegation as e } from "../actions/initiate-revoke-delegation.js";
+//#region src/symmio-contracts/instant-layer/query/initiate-revoke-delegation.ts
+function t(t) {
+	return {
+		mutationKey: ["initiateRevokeDelegation"],
+		mutationFn: (n) => e(t, n)
+	};
+}
+//#endregion
+export { t as initiateRevokeDelegationMutationOptions };
+
+//# sourceMappingURL=initiate-revoke-delegation.js.map

package/dist/symmio-contracts/instant-layer/query/initiate-revoke-delegation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"initiate-revoke-delegation.js","names":[],"sources":["../../../../src/symmio-contracts/instant-layer/query/initiate-revoke-delegation.ts"],"sourcesContent":["import type { Config } from \"../../../core/config\";\nimport {\n  initiateRevokeDelegation,\n  type InitiateRevokeDelegationParameters,\n} from \"../actions/initiate-revoke-delegation\";\n\n/**\n * Build TanStack Mutation options for {@link initiateRevokeDelegation}.\n *\n * The returned `mutationFn` takes the action's parameters and forwards them to\n * `initiateRevokeDelegation(config, …)`. Framework layers compose invalidation\n * and error normalization on top.\n *\n * @param config - The SDK config (must have a `getWalletClient` resolver).\n * @returns Options to pass to `useMutation`.\n *\n * @example\n * ```ts\n * useMutation(initiateRevokeDelegationMutationOptions(config));\n * ```\n */\nexport function initiateRevokeDelegationMutationOptions(config: Config) {\n  return {\n    mutationKey: [\"initiateRevokeDelegation\"] as const,\n    mutationFn: (variables: InitiateRevokeDelegationParameters) => initiateRevokeDelegation(config, variables),\n  };\n}\n"],"mappings":";;AAqBA,SAAgB,EAAwC,GAAgB;CACtE,OAAO;EACL,aAAa,CAAC,0BAA0B;EACxC,aAAa,MAAkD,EAAyB,GAAQ,CAAS;CAC3G;AACF"}

package/dist/symmio-contracts/symmio/actions/allocate.d.ts

@@ -1,10 +1,10 @@
 import { Address, Hash } from 'viem';
 import { Config } from '../../../core/config/index.js';
-import { Compute, WriteContractParameter } from '../../../shared/types/properties.js';
+import { Compute, GaslessWriteParameter, WriteContractParameter } from '../../../shared/types/properties.js';
 /**
  * Parameters for {@link allocate}.
  */
-export type AllocateParameters = Compute<WriteContractParameter & {
+export type AllocateParameters = Compute<WriteContractParameter & GaslessWriteParameter & {
     /**
      * The subaccount to allocate into. The call is routed through the
      * AccountLayer `_call` proxy; the connected wallet must be its on-chain `owner`.

package/dist/symmio-contracts/symmio/actions/allocate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"allocate.d.ts","sourceRoot":"","sources":["../../../../src/symmio-contracts/symmio/actions/allocate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,MAAM,CAAC;AACnE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAIxF;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,CACtC,sBAAsB,GAAG;IACvB;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAC;CAChB,CACF,CAAC;AAEF,uEAAuE;AACvE,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAgB1G"}
+{"version":3,"file":"allocate.d.ts","sourceRoot":"","sources":["../../../../src/symmio-contracts/symmio/actions/allocate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,MAAM,CAAC;AACnE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAI/G;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,CACtC,sBAAsB,GACpB,qBAAqB,GAAG;IACtB;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAC;CAChB,CACJ,CAAC;AAEF,uEAAuE;AACvE,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAiB1G"}

package/dist/symmio-contracts/symmio/actions/allocate.js

@@ -13,7 +13,8 @@ async function r(r, i) {
 		}),
 		chainId: a,
 		from: i.from,
-		simulateBeforeWrite: i.simulateBeforeWrite
+		simulateBeforeWrite: i.simulateBeforeWrite,
+		gasless: i.gasless
 	});
 }
 //#endregion

package/dist/symmio-contracts/symmio/actions/allocate.js.map

@@ -1 +1 @@
-{"version":3,"file":"allocate.js","names":[],"sources":["../../../../src/symmio-contracts/symmio/actions/allocate.ts"],"sourcesContent":["import { encodeFunctionData, type Address, type Hash } from \"viem\";\nimport type { Config } from \"../../../core/config\";\nimport type { Compute, WriteContractParameter } from \"../../../shared/types/properties\";\nimport { symmioAbi } from \"../../abi/v0.8.6/symmio\";\nimport { callAsSubAccount } from \"../internal/call-as-sub-account\";\n\n/**\n * Parameters for {@link allocate}.\n */\nexport type AllocateParameters = Compute<\n  WriteContractParameter & {\n    /**\n     * The subaccount to allocate into. The call is routed through the\n     * AccountLayer `_call` proxy; the connected wallet must be its on-chain `owner`.\n     */\n    account: Address;\n    /**\n     * Amount to move from the available balance into the allocated balance, in\n     * **18 decimals** (not the collateral token's decimals). Capped by the\n     * per-user balance limit.\n     */\n    amount: bigint;\n  }\n>;\n\n/** Return type of {@link allocate}: the submitted transaction hash. */\nexport type AllocateReturnType = Hash;\n\n/**\n * Move collateral from a subaccount's **available balance** into its **allocated\n * (tradeable) balance** on the SYMMIO core.\n *\n * Allocated balance is what Party A actually trades against. The subaccount's\n * available balance is debited and its allocated balance credited, in 18-decimal\n * units, capped by the per-user balance limit. The subaccount must not be\n * suspended or currently in liquidation as Party A.\n *\n * Encodes the SYMMIO core `allocate(amount)` call and routes it through\n * `AccountLayer._call(account, …)` so the core attributes it to the subaccount.\n *\n * Dry-runs the call with {@link simulateAllocate} first unless `simulateBeforeWrite`\n * is `false` (per-call, falling back to the config default).\n *\n * @param config - The SDK config (must have a `getWalletClient` resolver).\n * @param parameters - Subaccount, amount (18 decimals), optional chain id.\n * @returns The submitted transaction hash. The caller waits on the receipt.\n * @throws {SymmError} when the chain is unsupported or no wallet is available.\n * @throws Viem's write errors (`ContractFunctionExecutionError`, ...).\n *\n * @example\n * ```ts\n * const hash = await allocate(config, { account: \"0xsub…\", amount: 1_000000000000000000n });\n * ```\n */\nexport async function allocate(config: Config, parameters: AllocateParameters): Promise<AllocateReturnType> {\n  const { chainId, account, amount } = parameters;\n\n  const data = encodeFunctionData({\n    abi: symmioAbi,\n    functionName: \"allocate\",\n    args: [amount],\n  });\n\n  return callAsSubAccount(config, {\n    account,\n    data,\n    chainId,\n    from: parameters.from,\n    simulateBeforeWrite: parameters.simulateBeforeWrite,\n  });\n}\n"],"mappings":";;;;AAsDA,eAAsB,EAAS,GAAgB,GAA6D;CAC1G,IAAM,EAAE,YAAS,YAAS,cAAW;CAQrC,OAAO,EAAiB,GAAQ;EAC9B;EACA,MARW,EAAmB;GAC9B,KAAK;GACL,cAAc;GACd,MAAM,CAAC,CAAM;EACf,CAIE;EACA;EACA,MAAM,EAAW;EACjB,qBAAqB,EAAW;CAClC,CAAC;AACH"}
+{"version":3,"file":"allocate.js","names":[],"sources":["../../../../src/symmio-contracts/symmio/actions/allocate.ts"],"sourcesContent":["import { encodeFunctionData, type Address, type Hash } from \"viem\";\nimport type { Config } from \"../../../core/config\";\nimport type { Compute, GaslessWriteParameter, WriteContractParameter } from \"../../../shared/types/properties\";\nimport { symmioAbi } from \"../../abi/v0.8.6/symmio\";\nimport { callAsSubAccount } from \"../internal/call-as-sub-account\";\n\n/**\n * Parameters for {@link allocate}.\n */\nexport type AllocateParameters = Compute<\n  WriteContractParameter &\n    GaslessWriteParameter & {\n      /**\n       * The subaccount to allocate into. The call is routed through the\n       * AccountLayer `_call` proxy; the connected wallet must be its on-chain `owner`.\n       */\n      account: Address;\n      /**\n       * Amount to move from the available balance into the allocated balance, in\n       * **18 decimals** (not the collateral token's decimals). Capped by the\n       * per-user balance limit.\n       */\n      amount: bigint;\n    }\n>;\n\n/** Return type of {@link allocate}: the submitted transaction hash. */\nexport type AllocateReturnType = Hash;\n\n/**\n * Move collateral from a subaccount's **available balance** into its **allocated\n * (tradeable) balance** on the SYMMIO core.\n *\n * Allocated balance is what Party A actually trades against. The subaccount's\n * available balance is debited and its allocated balance credited, in 18-decimal\n * units, capped by the per-user balance limit. The subaccount must not be\n * suspended or currently in liquidation as Party A.\n *\n * Encodes the SYMMIO core `allocate(amount)` call and routes it through\n * `AccountLayer._call(account, …)` so the core attributes it to the subaccount.\n *\n * Dry-runs the call with {@link simulateAllocate} first unless `simulateBeforeWrite`\n * is `false` (per-call, falling back to the config default).\n *\n * @param config - The SDK config (must have a `getWalletClient` resolver).\n * @param parameters - Subaccount, amount (18 decimals), optional chain id.\n * @returns The submitted transaction hash. The caller waits on the receipt.\n * @throws {SymmError} when the chain is unsupported or no wallet is available.\n * @throws Viem's write errors (`ContractFunctionExecutionError`, ...).\n *\n * @example\n * ```ts\n * const hash = await allocate(config, { account: \"0xsub…\", amount: 1_000000000000000000n });\n * ```\n */\nexport async function allocate(config: Config, parameters: AllocateParameters): Promise<AllocateReturnType> {\n  const { chainId, account, amount } = parameters;\n\n  const data = encodeFunctionData({\n    abi: symmioAbi,\n    functionName: \"allocate\",\n    args: [amount],\n  });\n\n  return callAsSubAccount(config, {\n    account,\n    data,\n    chainId,\n    from: parameters.from,\n    simulateBeforeWrite: parameters.simulateBeforeWrite,\n    gasless: parameters.gasless,\n  });\n}\n"],"mappings":";;;;AAuDA,eAAsB,EAAS,GAAgB,GAA6D;CAC1G,IAAM,EAAE,YAAS,YAAS,cAAW;CAQrC,OAAO,EAAiB,GAAQ;EAC9B;EACA,MARW,EAAmB;GAC9B,KAAK;GACL,cAAc;GACd,MAAM,CAAC,CAAM;EACf,CAIE;EACA;EACA,MAAM,EAAW;EACjB,qBAAqB,EAAW;EAChC,SAAS,EAAW;CACtB,CAAC;AACH"}

package/dist/symmio-contracts/symmio/actions/approve-operational-fee.d.ts

@@ -0,0 +1,87 @@
+import { Address, Hash } from 'viem';
+import { Config } from '../../../core/config/index.js';
+import { Compute, GaslessWriteParameter, WriteContractParameter } from '../../../shared/types/properties.js';
+/**
+ * Fee multiplier meaning "list price" (basis points). The default the diamond
+ * applies when a pair has never set one.
+ */
+export declare const OPERATIONAL_FEE_LIST_PRICE_MULTIPLIER = 10000n;
+/**
+ * Parameters for {@link approveOperationalFee}.
+ */
+export type ApproveOperationalFeeParameters = Compute<WriteContractParameter & GaslessWriteParameter & {
+    /**
+     * The sub-account that pays operational fees. The call is routed through
+     * the AccountLayer `_call` proxy so the diamond sees this sub-account as
+     * `msg.sender` — the allowance is keyed by payer, and a direct wallet call
+     * would grant it from the wrong account. The connected wallet must be the
+     * sub-account's `owner`.
+     */
+    account: Address;
+    /**
+     * The fee chargers to approve. Defaults to the chain's
+     * `gasless.gaslessLayerAddress` — the GaslessLayer **proxy**, which is
+     * the charger for relayed operations. Never the relayer's executor
+     * address.
+     */
+    chargers?: readonly Address[];
+    /**
+     * Allowance per charger, parallel to `chargers`, in **18-decimal Core
+     * units** — the scale of the Core balance the fee is drawn from, not the
+     * collateral token's decimals. `parseUnits("5", 18)` is a budget of 5
+     * collateral tokens; `collateralToCore18` converts a token amount.
+     *
+     * Each value **replaces** the current allowance (ERC-20 `approve`
+     * style, not an increment), and every charge decrements it. Choose a
+     * bounded budget for the operations you intend to relay rather than
+     * `maxUint256`. A raise applies immediately; a **reduction** can be
+     * timelocked on-chain, in which case the old value keeps applying until
+     * `reductionReadyAt`.
+     */
+    amounts: readonly bigint[];
+    /**
+     * Fee multiplier per charger in basis points; `10000n` = list price.
+     * Defaults to {@link OPERATIONAL_FEE_LIST_PRICE_MULTIPLIER} for every
+     * charger. The call always sets the multiplier, so omitting this resets
+     * a previously set one to list price.
+     */
+    feeMultipliers?: readonly bigint[];
+}>;
+/** Return type of {@link approveOperationalFee}: the submitted transaction hash. */
+export type ApproveOperationalFeeReturnType = Hash;
+/**
+ * Approve operational-fee allowances (`approveOperationalFeeWithMultiplier`)
+ * for the gasless fee charger, as the paying sub-account.
+ *
+ * The GaslessLayer proxy can only charge a payer up to this allowance, so grant
+ * it **before** relying on gasless execution. When the relayer itself is down,
+ * this wallet-paid path (via `AccountLayer._call`) is the only way to grant it.
+ * The approval is also itself relayable: pass `gasless: true` once the
+ * transparent gasless mode is active to have the relayer submit it.
+ *
+ * Amounts are **18-decimal Core units**. Approving only permits the charge — it
+ * does not add collateral, and the fee is still drawn from the payer's Core
+ * balance. Whatever its allowance, a payer short of balance fails with
+ * `OperationalFee: Insufficient balance`. Read the allowance back with
+ * `getOperationalFeeAllowance` after the transaction lands, before relying on it.
+ *
+ * @param config - The SDK config (must have a `getWalletClient` resolver).
+ * @param parameters - Paying sub-account, chargers/amounts/multipliers, write options.
+ * @returns The submitted transaction hash.
+ * @throws {SymmError} `GASLESS_CHARGER_REQUIRED` when no `chargers` are given and
+ *   the chain has no gasless block to default from.
+ * @throws {SymmError} `OPERATIONAL_FEE_APPROVAL_MISMATCH` when the array lengths disagree.
+ *
+ * @example
+ * ```ts
+ * import { parseUnits } from "viem";
+ *
+ * // A bounded fee budget of 5 collateral tokens, in 18-decimal Core units.
+ * const hash = await approveOperationalFee(config, {
+ *   account: subAccount,
+ *   amounts: [parseUnits("5", 18)],
+ * });
+ * ```
+ */
+export declare function approveOperationalFee(config: Config, parameters: ApproveOperationalFeeParameters): Promise<ApproveOperationalFeeReturnType>;
+//# sourceMappingURL=approve-operational-fee.d.ts.map

package/dist/symmio-contracts/symmio/actions/approve-operational-fee.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approve-operational-fee.d.ts","sourceRoot":"","sources":["../../../../src/symmio-contracts/symmio/actions/approve-operational-fee.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,MAAM,CAAC;AACnE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAGnD,OAAO,KAAK,EAAE,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAI/G;;;GAGG;AACH,eAAO,MAAM,qCAAqC,SAAU,CAAC;AAE7D;;GAEG;AACH,MAAM,MAAM,+BAA+B,GAAG,OAAO,CACnD,sBAAsB,GACpB,qBAAqB,GAAG;IACtB;;;;;;OAMG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IAC9B;;;;;;;;;;;;OAYG;IACH,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B;;;;;OAKG;IACH,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC,CACJ,CAAC;AAEF,oFAAoF;AACpF,MAAM,MAAM,+BAA+B,GAAG,IAAI,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,+BAA+B,GAC1C,OAAO,CAAC,+BAA+B,CAAC,CA4B1C"}

package/dist/symmio-contracts/symmio/actions/approve-operational-fee.js

@@ -0,0 +1,38 @@
+import { symmioAbi as e } from "../../abi/v0.8.6/symmio.js";
+import { SymmError as t } from "../../../shared/errors/symm-error.js";
+import { resolveGaslessService as n } from "../../../gasless/resolve-gasless.js";
+import { callAsSubAccount as r } from "../internal/call-as-sub-account.js";
+import { encodeFunctionData as i } from "viem";
+//#region src/symmio-contracts/symmio/actions/approve-operational-fee.ts
+var a = 10000n;
+async function o(n, a) {
+	let { chainId: o, account: c, amounts: l } = a, u = a.chargers ?? [s(n, o)], d = a.feeMultipliers ?? u.map(() => 10000n);
+	if (u.length !== l.length || u.length !== d.length) throw new t("validation", "OPERATIONAL_FEE_APPROVAL_MISMATCH", `approveOperationalFee: chargers (${u.length}), amounts (${l.length}) and feeMultipliers (${d.length}) must have the same length.`);
+	return r(n, {
+		account: c,
+		data: i({
+			abi: e,
+			functionName: "approveOperationalFeeWithMultiplier",
+			args: [
+				[...u],
+				[...l],
+				[...d]
+			]
+		}),
+		chainId: o,
+		from: a.from,
+		simulateBeforeWrite: a.simulateBeforeWrite,
+		gasless: a.gasless
+	});
+}
+function s(e, r) {
+	try {
+		return n(e, { chainId: r }).gaslessLayerAddress;
+	} catch {
+		throw new t("validation", "GASLESS_CHARGER_REQUIRED", "approveOperationalFee: pass `chargers` explicitly — the chain has no gasless block to default them from.");
+	}
+}
+//#endregion
+export { a as OPERATIONAL_FEE_LIST_PRICE_MULTIPLIER, o as approveOperationalFee };
+
+//# sourceMappingURL=approve-operational-fee.js.map

package/dist/symmio-contracts/symmio/actions/approve-operational-fee.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"approve-operational-fee.js","names":[],"sources":["../../../../src/symmio-contracts/symmio/actions/approve-operational-fee.ts"],"sourcesContent":["import { encodeFunctionData, type Address, type Hash } from \"viem\";\nimport type { Config } from \"../../../core/config\";\nimport { resolveGaslessService } from \"../../../gasless/resolve-gasless\";\nimport { SymmError } from \"../../../shared/errors/symm-error\";\nimport type { Compute, GaslessWriteParameter, WriteContractParameter } from \"../../../shared/types/properties\";\nimport { symmioAbi } from \"../../abi/v0.8.6/symmio\";\nimport { callAsSubAccount } from \"../internal/call-as-sub-account\";\n\n/**\n * Fee multiplier meaning \"list price\" (basis points). The default the diamond\n * applies when a pair has never set one.\n */\nexport const OPERATIONAL_FEE_LIST_PRICE_MULTIPLIER = 10_000n;\n\n/**\n * Parameters for {@link approveOperationalFee}.\n */\nexport type ApproveOperationalFeeParameters = Compute<\n  WriteContractParameter &\n    GaslessWriteParameter & {\n      /**\n       * The sub-account that pays operational fees. The call is routed through\n       * the AccountLayer `_call` proxy so the diamond sees this sub-account as\n       * `msg.sender` — the allowance is keyed by payer, and a direct wallet call\n       * would grant it from the wrong account. The connected wallet must be the\n       * sub-account's `owner`.\n       */\n      account: Address;\n      /**\n       * The fee chargers to approve. Defaults to the chain's\n       * `gasless.gaslessLayerAddress` — the GaslessLayer **proxy**, which is\n       * the charger for relayed operations. Never the relayer's executor\n       * address.\n       */\n      chargers?: readonly Address[];\n      /**\n       * Allowance per charger, parallel to `chargers`, in **18-decimal Core\n       * units** — the scale of the Core balance the fee is drawn from, not the\n       * collateral token's decimals. `parseUnits(\"5\", 18)` is a budget of 5\n       * collateral tokens; `collateralToCore18` converts a token amount.\n       *\n       * Each value **replaces** the current allowance (ERC-20 `approve`\n       * style, not an increment), and every charge decrements it. Choose a\n       * bounded budget for the operations you intend to relay rather than\n       * `maxUint256`. A raise applies immediately; a **reduction** can be\n       * timelocked on-chain, in which case the old value keeps applying until\n       * `reductionReadyAt`.\n       */\n      amounts: readonly bigint[];\n      /**\n       * Fee multiplier per charger in basis points; `10000n` = list price.\n       * Defaults to {@link OPERATIONAL_FEE_LIST_PRICE_MULTIPLIER} for every\n       * charger. The call always sets the multiplier, so omitting this resets\n       * a previously set one to list price.\n       */\n      feeMultipliers?: readonly bigint[];\n    }\n>;\n\n/** Return type of {@link approveOperationalFee}: the submitted transaction hash. */\nexport type ApproveOperationalFeeReturnType = Hash;\n\n/**\n * Approve operational-fee allowances (`approveOperationalFeeWithMultiplier`)\n * for the gasless fee charger, as the paying sub-account.\n *\n * The GaslessLayer proxy can only charge a payer up to this allowance, so grant\n * it **before** relying on gasless execution. When the relayer itself is down,\n * this wallet-paid path (via `AccountLayer._call`) is the only way to grant it.\n * The approval is also itself relayable: pass `gasless: true` once the\n * transparent gasless mode is active to have the relayer submit it.\n *\n * Amounts are **18-decimal Core units**. Approving only permits the charge — it\n * does not add collateral, and the fee is still drawn from the payer's Core\n * balance. Whatever its allowance, a payer short of balance fails with\n * `OperationalFee: Insufficient balance`. Read the allowance back with\n * `getOperationalFeeAllowance` after the transaction lands, before relying on it.\n *\n * @param config - The SDK config (must have a `getWalletClient` resolver).\n * @param parameters - Paying sub-account, chargers/amounts/multipliers, write options.\n * @returns The submitted transaction hash.\n * @throws {SymmError} `GASLESS_CHARGER_REQUIRED` when no `chargers` are given and\n *   the chain has no gasless block to default from.\n * @throws {SymmError} `OPERATIONAL_FEE_APPROVAL_MISMATCH` when the array lengths disagree.\n *\n * @example\n * ```ts\n * import { parseUnits } from \"viem\";\n *\n * // A bounded fee budget of 5 collateral tokens, in 18-decimal Core units.\n * const hash = await approveOperationalFee(config, {\n *   account: subAccount,\n *   amounts: [parseUnits(\"5\", 18)],\n * });\n * ```\n */\nexport async function approveOperationalFee(\n  config: Config,\n  parameters: ApproveOperationalFeeParameters,\n): Promise<ApproveOperationalFeeReturnType> {\n  const { chainId, account, amounts } = parameters;\n\n  const chargers = parameters.chargers ?? [resolveDefaultCharger(config, chainId)];\n  const feeMultipliers = parameters.feeMultipliers ?? chargers.map(() => OPERATIONAL_FEE_LIST_PRICE_MULTIPLIER);\n\n  if (chargers.length !== amounts.length || chargers.length !== feeMultipliers.length) {\n    throw new SymmError(\n      \"validation\",\n      \"OPERATIONAL_FEE_APPROVAL_MISMATCH\",\n      `approveOperationalFee: chargers (${chargers.length}), amounts (${amounts.length}) and feeMultipliers (${feeMultipliers.length}) must have the same length.`,\n    );\n  }\n\n  const data = encodeFunctionData({\n    abi: symmioAbi,\n    functionName: \"approveOperationalFeeWithMultiplier\",\n    args: [[...chargers], [...amounts], [...feeMultipliers]],\n  });\n\n  return callAsSubAccount(config, {\n    account,\n    data,\n    chainId,\n    from: parameters.from,\n    simulateBeforeWrite: parameters.simulateBeforeWrite,\n    gasless: parameters.gasless,\n  });\n}\n\nfunction resolveDefaultCharger(config: Config, chainId: number | undefined): Address {\n  try {\n    return resolveGaslessService(config, { chainId }).gaslessLayerAddress;\n  } catch {\n    throw new SymmError(\n      \"validation\",\n      \"GASLESS_CHARGER_REQUIRED\",\n      \"approveOperationalFee: pass `chargers` explicitly — the chain has no gasless block to default them from.\",\n    );\n  }\n}\n"],"mappings":";;;;;;AAYA,IAAa,IAAwC;AAoFrD,eAAsB,EACpB,GACA,GAC0C;CAC1C,IAAM,EAAE,YAAS,YAAS,eAAY,GAEhC,IAAW,EAAW,YAAY,CAAC,EAAsB,GAAQ,CAAO,CAAC,GACzE,IAAiB,EAAW,kBAAkB,EAAS,UAAA,MAA+C;CAE5G,IAAI,EAAS,WAAW,EAAQ,UAAU,EAAS,WAAW,EAAe,QAC3E,MAAM,IAAI,EACR,cACA,qCACA,oCAAoC,EAAS,OAAO,cAAc,EAAQ,OAAO,wBAAwB,EAAe,OAAO,6BACjI;CASF,OAAO,EAAiB,GAAQ;EAC9B;EACA,MARW,EAAmB;GAC9B,KAAK;GACL,cAAc;GACd,MAAM;IAAC,CAAC,GAAG,CAAQ;IAAG,CAAC,GAAG,CAAO;IAAG,CAAC,GAAG,CAAc;GAAC;EACzD,CAIE;EACA;EACA,MAAM,EAAW;EACjB,qBAAqB,EAAW;EAChC,SAAS,EAAW;CACtB,CAAC;AACH;AAEA,SAAS,EAAsB,GAAgB,GAAsC;CACnF,IAAI;EACF,OAAO,EAAsB,GAAQ,EAAE,WAAQ,CAAC,EAAE;CACpD,QAAQ;EACN,MAAM,IAAI,EACR,cACA,4BACA,0GACF;CACF;AACF"}

package/dist/symmio-contracts/symmio/actions/deallocate-and-initiate-withdraw.d.ts

@@ -1,12 +1,12 @@
 import { Address, Hash, Hex } from 'viem';
 import { Config } from '../../../core/config/index.js';
-import { Compute, WriteContractParameter } from '../../../shared/types/properties.js';
+import { Compute, GaslessWriteParameter, WriteContractParameter } from '../../../shared/types/properties.js';
 import { SingleUpnlSig } from '../../account-layer/types.js';
 import { WithdrawReceiverPart } from '../types.js';
 /**
  * Parameters for {@link deallocateAndInitiateWithdraw}.
  */
-export type DeallocateAndInitiateWithdrawParameters = Compute<WriteContractParameter & {
+export type DeallocateAndInitiateWithdrawParameters = Compute<WriteContractParameter & GaslessWriteParameter & {
     /**
      * The subaccount to deallocate from and initiate the withdrawal for. Both
      * inner calls are routed through the AccountLayer `_call` proxy so the core

package/dist/symmio-contracts/symmio/actions/deallocate-and-initiate-withdraw.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deallocate-and-initiate-withdraw.d.ts","sourceRoot":"","sources":["../../../../src/symmio-contracts/symmio/actions/deallocate-and-initiate-withdraw.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,GAAG,EAAE,MAAM,MAAM,CAAC;AAC7E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,KAAK,EAAE,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAExF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE/D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAErD;;GAEG;AACH,MAAM,MAAM,uCAAuC,GAAG,OAAO,CAC3D,sBAAsB,GAAG;IACvB;;;;;OAKG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,KAAK,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACvC;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,YAAY,CAAC,EAAE,GAAG,CAAC;IACnB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB,CACF,CAAC;AAEF,4FAA4F;AAC5F,MAAM,MAAM,uCAAuC,GAAG,IAAI,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAsB,6BAA6B,CACjD,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,uCAAuC,GAClD,OAAO,CAAC,uCAAuC,CAAC,CAyBlD"}
+{"version":3,"file":"deallocate-and-initiate-withdraw.d.ts","sourceRoot":"","sources":["../../../../src/symmio-contracts/symmio/actions/deallocate-and-initiate-withdraw.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,GAAG,EAAE,MAAM,MAAM,CAAC;AAC7E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,KAAK,EAAE,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAE/G,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE/D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAErD;;GAEG;AACH,MAAM,MAAM,uCAAuC,GAAG,OAAO,CAC3D,sBAAsB,GACpB,qBAAqB,GAAG;IACtB;;;;;OAKG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,KAAK,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACvC;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,YAAY,CAAC,EAAE,GAAG,CAAC;IACnB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB,CACJ,CAAC;AAEF,4FAA4F;AAC5F,MAAM,MAAM,uCAAuC,GAAG,IAAI,CAAC;AAE3D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAsB,6BAA6B,CACjD,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,uCAAuC,GAClD,OAAO,CAAC,uCAAuC,CAAC,CA0BlD"}

package/dist/symmio-contracts/symmio/actions/deallocate-and-initiate-withdraw.js

@@ -25,7 +25,8 @@ async function i(i, a) {
 		})],
 		chainId: o,
 		from: f,
-		simulateBeforeWrite: a.simulateBeforeWrite
+		simulateBeforeWrite: a.simulateBeforeWrite,
+		gasless: a.gasless
 	});
 }
 //#endregion

package/dist/symmio-contracts/symmio/actions/deallocate-and-initiate-withdraw.js.map

@@ -1 +1 @@
-{"version":3,"file":"deallocate-and-initiate-withdraw.js","names":[],"sources":["../../../../src/symmio-contracts/symmio/actions/deallocate-and-initiate-withdraw.ts"],"sourcesContent":["import { encodeFunctionData, type Address, type Hash, type Hex } from \"viem\";\nimport type { Config } from \"../../../core/config\";\nimport { getDeallocateUpnlSig } from \"../../../muon/deallocate-upnl-sig/get-deallocate-upnl-sig\";\nimport type { Compute, WriteContractParameter } from \"../../../shared/types/properties\";\nimport { symmioAbi } from \"../../abi/v0.8.6/symmio\";\nimport type { SingleUpnlSig } from \"../../account-layer/types\";\nimport { callAsSubAccount } from \"../internal/call-as-sub-account\";\nimport type { WithdrawReceiverPart } from \"../types\";\n\n/**\n * Parameters for {@link deallocateAndInitiateWithdraw}.\n */\nexport type DeallocateAndInitiateWithdrawParameters = Compute<\n  WriteContractParameter & {\n    /**\n     * The subaccount to deallocate from and initiate the withdrawal for. Both\n     * inner calls are routed through the AccountLayer `_call` proxy so the core\n     * attributes them to this subaccount; the connected wallet must be its\n     * on-chain `owner`.\n     */\n    account: Address;\n    /**\n     * Amount to move from the allocated balance back into the available balance,\n     * in **18 decimals** (not the collateral token's decimals). This is the\n     * `deallocate` leg; the freed collateral is what the withdrawal then requests.\n     */\n    amount: bigint;\n    /**\n     * The receiver parts the withdrawal is split into. A plain same-chain\n     * withdrawal is a single part with both provider fields set to the zero\n     * address — see `createClassicWithdrawPart`.\n     */\n    parts: readonly WithdrawReceiverPart[];\n    /**\n     * Opt into the cooldown speed-up flow. Only effective for speed-up-eligible\n     * users; ignored otherwise.\n     * @default false\n     */\n    speedUp?: boolean;\n    /**\n     * Opaque provider data forwarded to express/virtual providers (e.g. a signed\n     * option). Pass `0x` for a classic withdrawal.\n     * @default \"0x\"\n     */\n    providerData?: Hex;\n    /**\n     * A fresh Muon uPnL (`uPnl_A`) attestation for `account`, required by the\n     * `deallocate` leg to prove the subaccount stays solvent. It is timestamped\n     * and short-lived, so **omit it** to have the action fetch a fresh one (via\n     * {@link getDeallocateUpnlSig}) immediately before submitting; pass one only\n     * to reuse a signature you already fetched.\n     */\n    upnlSig?: SingleUpnlSig;\n  }\n>;\n\n/** Return type of {@link deallocateAndInitiateWithdraw}: the submitted transaction hash. */\nexport type DeallocateAndInitiateWithdrawReturnType = Hash;\n\n/**\n * Batch a subaccount's **deallocate** and **initiate-withdraw** into a single\n * atomic transaction — the cross-margin / Base withdraw path.\n *\n * Encodes the SYMMIO core `deallocate(amount, upnlSig)` and\n * `initiateWithdraw(parts, speedUp, data)` calls and routes **both** through one\n * `AccountLayer._call(account, [deallocateData, withdrawData])`. `_call` runs the\n * calldatas in order in a single transaction and reverts the whole transaction if\n * any inner call reverts, so the two legs are all-or-nothing: the caller never\n * ends up with a deallocation that failed to produce its withdraw request.\n *\n * **Order matters.** `deallocate` (allocated → available) is encoded first so the\n * freed collateral exists in the available balance before `initiateWithdraw`\n * requests it.\n *\n * @remarks\n * The `deallocate` leg is subject to the on-chain **deallocate debounce** and\n * requires a fresh Muon `upnlSig`; a stale attestation or too-soon a call reverts\n * the whole batch. Dry-runs the batched `_call` with the pre-flight simulation\n * first unless `simulateBeforeWrite` is `false` (per-call, falling back to the\n * config default). For separate control over the two legs, call {@link deallocate}\n * and {@link initiateWithdraw} individually.\n *\n * @param config - The SDK config (must have a `getWalletClient` resolver).\n * @param parameters - Subaccount, amount (18 decimals), receiver parts, optional\n *   speed-up / provider data, optional Muon `upnlSig` (fetched automatically via\n *   {@link getDeallocateUpnlSig} when omitted), optional chain id.\n * @returns The submitted transaction hash. The caller waits on the receipt.\n * @throws {SymmError} when the chain is unsupported or no wallet is available.\n * @throws Viem's write errors (`ContractFunctionExecutionError`, ...).\n *\n * @example\n * ```ts\n * const part = createClassicWithdrawPart({ id: 0n, amount: 1_000000n, receiver: \"0xabc…\", chainId: 42161n });\n * // upnlSig fetched automatically:\n * const hash = await deallocateAndInitiateWithdraw(config, {\n *   account: \"0xsub…\",\n *   amount: 1_000000000000000000n,\n *   parts: [part],\n * });\n * ```\n */\nexport async function deallocateAndInitiateWithdraw(\n  config: Config,\n  parameters: DeallocateAndInitiateWithdrawParameters,\n): Promise<DeallocateAndInitiateWithdrawReturnType> {\n  const { chainId, account, amount, parts, speedUp = false, providerData = \"0x\", from } = parameters;\n\n  const upnlSig = parameters.upnlSig ?? (await getDeallocateUpnlSig(config, { virtualAccount: account, chainId }));\n\n  const deallocateData = encodeFunctionData({\n    abi: symmioAbi,\n    functionName: \"deallocate\",\n    args: [amount, upnlSig],\n  });\n\n  const withdrawData = encodeFunctionData({\n    abi: symmioAbi,\n    functionName: \"initiateWithdraw\",\n    args: [parts, speedUp, providerData],\n  });\n\n  // Order matters: deallocate (allocated → available) MUST precede initiateWithdraw.\n  return callAsSubAccount(config, {\n    account,\n    data: [deallocateData, withdrawData],\n    chainId,\n    from,\n    simulateBeforeWrite: parameters.simulateBeforeWrite,\n  });\n}\n"],"mappings":";;;;;AAqGA,eAAsB,EACpB,GACA,GACkD;CAClD,IAAM,EAAE,YAAS,YAAS,WAAQ,UAAO,aAAU,IAAO,kBAAe,MAAM,YAAS;CAiBxF,OAAO,EAAiB,GAAQ;EAC9B;EACA,MAAM,CAfe,EAAmB;GACxC,KAAK;GACL,cAAc;GACd,MAAM,CAAC,GALO,EAAW,WAAY,MAAM,EAAqB,GAAQ;IAAE,gBAAgB;IAAS;GAAQ,CAAC,CAKtF;EACxB,CAWS,GATY,EAAmB;GACtC,KAAK;GACL,cAAc;GACd,MAAM;IAAC;IAAO;IAAS;GAAY;EACrC,CAKyB,CAAY;EACnC;EACA;EACA,qBAAqB,EAAW;CAClC,CAAC;AACH"}
+{"version":3,"file":"deallocate-and-initiate-withdraw.js","names":[],"sources":["../../../../src/symmio-contracts/symmio/actions/deallocate-and-initiate-withdraw.ts"],"sourcesContent":["import { encodeFunctionData, type Address, type Hash, type Hex } from \"viem\";\nimport type { Config } from \"../../../core/config\";\nimport { getDeallocateUpnlSig } from \"../../../muon/deallocate-upnl-sig/get-deallocate-upnl-sig\";\nimport type { Compute, GaslessWriteParameter, WriteContractParameter } from \"../../../shared/types/properties\";\nimport { symmioAbi } from \"../../abi/v0.8.6/symmio\";\nimport type { SingleUpnlSig } from \"../../account-layer/types\";\nimport { callAsSubAccount } from \"../internal/call-as-sub-account\";\nimport type { WithdrawReceiverPart } from \"../types\";\n\n/**\n * Parameters for {@link deallocateAndInitiateWithdraw}.\n */\nexport type DeallocateAndInitiateWithdrawParameters = Compute<\n  WriteContractParameter &\n    GaslessWriteParameter & {\n      /**\n       * The subaccount to deallocate from and initiate the withdrawal for. Both\n       * inner calls are routed through the AccountLayer `_call` proxy so the core\n       * attributes them to this subaccount; the connected wallet must be its\n       * on-chain `owner`.\n       */\n      account: Address;\n      /**\n       * Amount to move from the allocated balance back into the available balance,\n       * in **18 decimals** (not the collateral token's decimals). This is the\n       * `deallocate` leg; the freed collateral is what the withdrawal then requests.\n       */\n      amount: bigint;\n      /**\n       * The receiver parts the withdrawal is split into. A plain same-chain\n       * withdrawal is a single part with both provider fields set to the zero\n       * address — see `createClassicWithdrawPart`.\n       */\n      parts: readonly WithdrawReceiverPart[];\n      /**\n       * Opt into the cooldown speed-up flow. Only effective for speed-up-eligible\n       * users; ignored otherwise.\n       * @default false\n       */\n      speedUp?: boolean;\n      /**\n       * Opaque provider data forwarded to express/virtual providers (e.g. a signed\n       * option). Pass `0x` for a classic withdrawal.\n       * @default \"0x\"\n       */\n      providerData?: Hex;\n      /**\n       * A fresh Muon uPnL (`uPnl_A`) attestation for `account`, required by the\n       * `deallocate` leg to prove the subaccount stays solvent. It is timestamped\n       * and short-lived, so **omit it** to have the action fetch a fresh one (via\n       * {@link getDeallocateUpnlSig}) immediately before submitting; pass one only\n       * to reuse a signature you already fetched.\n       */\n      upnlSig?: SingleUpnlSig;\n    }\n>;\n\n/** Return type of {@link deallocateAndInitiateWithdraw}: the submitted transaction hash. */\nexport type DeallocateAndInitiateWithdrawReturnType = Hash;\n\n/**\n * Batch a subaccount's **deallocate** and **initiate-withdraw** into a single\n * atomic transaction — the cross-margin / Base withdraw path.\n *\n * Encodes the SYMMIO core `deallocate(amount, upnlSig)` and\n * `initiateWithdraw(parts, speedUp, data)` calls and routes **both** through one\n * `AccountLayer._call(account, [deallocateData, withdrawData])`. `_call` runs the\n * calldatas in order in a single transaction and reverts the whole transaction if\n * any inner call reverts, so the two legs are all-or-nothing: the caller never\n * ends up with a deallocation that failed to produce its withdraw request.\n *\n * **Order matters.** `deallocate` (allocated → available) is encoded first so the\n * freed collateral exists in the available balance before `initiateWithdraw`\n * requests it.\n *\n * @remarks\n * The `deallocate` leg is subject to the on-chain **deallocate debounce** and\n * requires a fresh Muon `upnlSig`; a stale attestation or too-soon a call reverts\n * the whole batch. Dry-runs the batched `_call` with the pre-flight simulation\n * first unless `simulateBeforeWrite` is `false` (per-call, falling back to the\n * config default). For separate control over the two legs, call {@link deallocate}\n * and {@link initiateWithdraw} individually.\n *\n * @param config - The SDK config (must have a `getWalletClient` resolver).\n * @param parameters - Subaccount, amount (18 decimals), receiver parts, optional\n *   speed-up / provider data, optional Muon `upnlSig` (fetched automatically via\n *   {@link getDeallocateUpnlSig} when omitted), optional chain id.\n * @returns The submitted transaction hash. The caller waits on the receipt.\n * @throws {SymmError} when the chain is unsupported or no wallet is available.\n * @throws Viem's write errors (`ContractFunctionExecutionError`, ...).\n *\n * @example\n * ```ts\n * const part = createClassicWithdrawPart({ id: 0n, amount: 1_000000n, receiver: \"0xabc…\", chainId: 42161n });\n * // upnlSig fetched automatically:\n * const hash = await deallocateAndInitiateWithdraw(config, {\n *   account: \"0xsub…\",\n *   amount: 1_000000000000000000n,\n *   parts: [part],\n * });\n * ```\n */\nexport async function deallocateAndInitiateWithdraw(\n  config: Config,\n  parameters: DeallocateAndInitiateWithdrawParameters,\n): Promise<DeallocateAndInitiateWithdrawReturnType> {\n  const { chainId, account, amount, parts, speedUp = false, providerData = \"0x\", from } = parameters;\n\n  const upnlSig = parameters.upnlSig ?? (await getDeallocateUpnlSig(config, { virtualAccount: account, chainId }));\n\n  const deallocateData = encodeFunctionData({\n    abi: symmioAbi,\n    functionName: \"deallocate\",\n    args: [amount, upnlSig],\n  });\n\n  const withdrawData = encodeFunctionData({\n    abi: symmioAbi,\n    functionName: \"initiateWithdraw\",\n    args: [parts, speedUp, providerData],\n  });\n\n  // Order matters: deallocate (allocated → available) MUST precede initiateWithdraw.\n  return callAsSubAccount(config, {\n    account,\n    data: [deallocateData, withdrawData],\n    chainId,\n    from,\n    simulateBeforeWrite: parameters.simulateBeforeWrite,\n    gasless: parameters.gasless,\n  });\n}\n"],"mappings":";;;;;AAsGA,eAAsB,EACpB,GACA,GACkD;CAClD,IAAM,EAAE,YAAS,YAAS,WAAQ,UAAO,aAAU,IAAO,kBAAe,MAAM,YAAS;CAiBxF,OAAO,EAAiB,GAAQ;EAC9B;EACA,MAAM,CAfe,EAAmB;GACxC,KAAK;GACL,cAAc;GACd,MAAM,CAAC,GALO,EAAW,WAAY,MAAM,EAAqB,GAAQ;IAAE,gBAAgB;IAAS;GAAQ,CAAC,CAKtF;EACxB,CAWS,GATY,EAAmB;GACtC,KAAK;GACL,cAAc;GACd,MAAM;IAAC;IAAO;IAAS;GAAY;EACrC,CAKyB,CAAY;EACnC;EACA;EACA,qBAAqB,EAAW;EAChC,SAAS,EAAW;CACtB,CAAC;AACH"}

package/dist/symmio-contracts/symmio/actions/deallocate.d.ts

@@ -1,11 +1,11 @@
 import { Address, Hash } from 'viem';
 import { Config } from '../../../core/config/index.js';
-import { Compute, WriteContractParameter } from '../../../shared/types/properties.js';
+import { Compute, GaslessWriteParameter, WriteContractParameter } from '../../../shared/types/properties.js';
 import { SingleUpnlSig } from '../../account-layer/types.js';
 /**
  * Parameters for {@link deallocate}.
  */
-export type DeallocateParameters = Compute<WriteContractParameter & {
+export type DeallocateParameters = Compute<WriteContractParameter & GaslessWriteParameter & {
     /**
      * The subaccount to deallocate from. The call is routed through the
      * AccountLayer `_call` proxy; the connected wallet must be its on-chain `owner`.

package/dist/symmio-contracts/symmio/actions/deallocate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deallocate.d.ts","sourceRoot":"","sources":["../../../../src/symmio-contracts/symmio/actions/deallocate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,MAAM,CAAC;AACnE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,KAAK,EAAE,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAExF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAG/D;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,OAAO,CACxC,sBAAsB,GAAG;IACvB;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB,CACF,CAAC;AAEF,yEAAyE;AACzE,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAsB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,oBAAoB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAmBhH"}
+{"version":3,"file":"deallocate.d.ts","sourceRoot":"","sources":["../../../../src/symmio-contracts/symmio/actions/deallocate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,MAAM,CAAC;AACnE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,KAAK,EAAE,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAE/G,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAG/D;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,OAAO,CACxC,sBAAsB,GACpB,qBAAqB,GAAG;IACtB;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB,CACJ,CAAC;AAEF,yEAAyE;AACzE,MAAM,MAAM,oBAAoB,GAAG,IAAI,CAAC;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAsB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,oBAAoB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAoBhH"}

package/dist/symmio-contracts/symmio/actions/deallocate.js

@@ -17,7 +17,8 @@ async function i(i, a) {
 		}),
 		chainId: o,
 		from: a.from,
-		simulateBeforeWrite: a.simulateBeforeWrite
+		simulateBeforeWrite: a.simulateBeforeWrite,
+		gasless: a.gasless
 	});
 }
 //#endregion

package/dist/symmio-contracts/symmio/actions/deallocate.js.map

@@ -1 +1 @@
-{"version":3,"file":"deallocate.js","names":[],"sources":["../../../../src/symmio-contracts/symmio/actions/deallocate.ts"],"sourcesContent":["import { encodeFunctionData, type Address, type Hash } from \"viem\";\nimport type { Config } from \"../../../core/config\";\nimport { getDeallocateUpnlSig } from \"../../../muon/deallocate-upnl-sig/get-deallocate-upnl-sig\";\nimport type { Compute, WriteContractParameter } from \"../../../shared/types/properties\";\nimport { symmioAbi } from \"../../abi/v0.8.6/symmio\";\nimport type { SingleUpnlSig } from \"../../account-layer/types\";\nimport { callAsSubAccount } from \"../internal/call-as-sub-account\";\n\n/**\n * Parameters for {@link deallocate}.\n */\nexport type DeallocateParameters = Compute<\n  WriteContractParameter & {\n    /**\n     * The subaccount to deallocate from. The call is routed through the\n     * AccountLayer `_call` proxy; the connected wallet must be its on-chain `owner`.\n     */\n    account: Address;\n    /**\n     * Amount to move from the allocated balance back into the available balance,\n     * in **18 decimals** (not the collateral token's decimals).\n     */\n    amount: bigint;\n    /**\n     * A fresh Muon uPnL (`uPnl_A`) attestation for `account`. The contract\n     * verifies it to prove the subaccount stays solvent after the deallocation.\n     * It is timestamped and short-lived, so **omit it** to have the action fetch a\n     * fresh one (via {@link getDeallocateUpnlSig}) immediately before submitting;\n     * pass one only to reuse a signature you already fetched.\n     */\n    upnlSig?: SingleUpnlSig;\n  }\n>;\n\n/** Return type of {@link deallocate}: the submitted transaction hash. */\nexport type DeallocateReturnType = Hash;\n\n/**\n * Move collateral from a subaccount's **allocated (tradeable) balance** back into\n * its **available balance** on the SYMMIO core.\n *\n * The reverse of {@link allocate}: the subaccount's allocated balance is debited\n * and its available balance credited, in 18-decimal units, after the contract\n * verifies the Muon uPnL signature keeps the subaccount solvent. The freed\n * collateral can then be withdrawn (subject to the separate withdraw cooldown).\n *\n * Encodes the SYMMIO core `deallocate(amount, upnlSig)` call and routes it through\n * `AccountLayer._call(account, …)` so the core attributes it to the subaccount.\n *\n * @remarks\n * Subject to the on-chain **deallocate debounce**: calling too soon after a prior\n * deallocate reverts (\"Too many deallocate in a short window\"). This is distinct\n * from the withdraw cooldown that later gates moving the freed collateral to the\n * wallet. The `upnlSig` must be freshly fetched — a stale attestation reverts.\n *\n * Dry-runs the call with {@link simulateDeallocate} first unless `simulateBeforeWrite`\n * is `false` (per-call, falling back to the config default).\n *\n * @param config - The SDK config (must have a `getWalletClient` resolver).\n * @param parameters - Subaccount, amount (18 decimals), optional Muon `upnlSig`\n *   (fetched automatically via {@link getDeallocateUpnlSig} when omitted), optional chain id.\n * @returns The submitted transaction hash. The caller waits on the receipt.\n * @throws {SymmError} when the chain is unsupported or no wallet is available.\n * @throws Viem's write errors (`ContractFunctionExecutionError`, ...).\n *\n * @example\n * ```ts\n * // upnlSig fetched automatically:\n * const hash = await deallocate(config, { account: \"0xsub…\", amount: 1_000000000000000000n });\n * // or reuse a pre-fetched signature:\n * const upnlSig = await getDeallocateUpnlSig(config, { virtualAccount: \"0xsub…\" });\n * await deallocate(config, { account: \"0xsub…\", amount: 1_000000000000000000n, upnlSig });\n * ```\n */\nexport async function deallocate(config: Config, parameters: DeallocateParameters): Promise<DeallocateReturnType> {\n  const { chainId, account, amount } = parameters;\n\n  const upnlSig =\n    parameters.upnlSig ?? (await getDeallocateUpnlSig(config, { virtualAccount: parameters.account, chainId }));\n\n  const data = encodeFunctionData({\n    abi: symmioAbi,\n    functionName: \"deallocate\",\n    args: [amount, upnlSig],\n  });\n\n  return callAsSubAccount(config, {\n    account,\n    data,\n    chainId,\n    from: parameters.from,\n    simulateBeforeWrite: parameters.simulateBeforeWrite,\n  });\n}\n"],"mappings":";;;;;AA0EA,eAAsB,EAAW,GAAgB,GAAiE;CAChH,IAAM,EAAE,YAAS,YAAS,cAAW;CAWrC,OAAO,EAAiB,GAAQ;EAC9B;EACA,MARW,EAAmB;GAC9B,KAAK;GACL,cAAc;GACd,MAAM,CAAC,GALP,EAAW,WAAY,MAAM,EAAqB,GAAQ;IAAE,gBAAgB,EAAW;IAAS;GAAQ,CAAC,CAKnF;EACxB,CAIE;EACA;EACA,MAAM,EAAW;EACjB,qBAAqB,EAAW;CAClC,CAAC;AACH"}
+{"version":3,"file":"deallocate.js","names":[],"sources":["../../../../src/symmio-contracts/symmio/actions/deallocate.ts"],"sourcesContent":["import { encodeFunctionData, type Address, type Hash } from \"viem\";\nimport type { Config } from \"../../../core/config\";\nimport { getDeallocateUpnlSig } from \"../../../muon/deallocate-upnl-sig/get-deallocate-upnl-sig\";\nimport type { Compute, GaslessWriteParameter, WriteContractParameter } from \"../../../shared/types/properties\";\nimport { symmioAbi } from \"../../abi/v0.8.6/symmio\";\nimport type { SingleUpnlSig } from \"../../account-layer/types\";\nimport { callAsSubAccount } from \"../internal/call-as-sub-account\";\n\n/**\n * Parameters for {@link deallocate}.\n */\nexport type DeallocateParameters = Compute<\n  WriteContractParameter &\n    GaslessWriteParameter & {\n      /**\n       * The subaccount to deallocate from. The call is routed through the\n       * AccountLayer `_call` proxy; the connected wallet must be its on-chain `owner`.\n       */\n      account: Address;\n      /**\n       * Amount to move from the allocated balance back into the available balance,\n       * in **18 decimals** (not the collateral token's decimals).\n       */\n      amount: bigint;\n      /**\n       * A fresh Muon uPnL (`uPnl_A`) attestation for `account`. The contract\n       * verifies it to prove the subaccount stays solvent after the deallocation.\n       * It is timestamped and short-lived, so **omit it** to have the action fetch a\n       * fresh one (via {@link getDeallocateUpnlSig}) immediately before submitting;\n       * pass one only to reuse a signature you already fetched.\n       */\n      upnlSig?: SingleUpnlSig;\n    }\n>;\n\n/** Return type of {@link deallocate}: the submitted transaction hash. */\nexport type DeallocateReturnType = Hash;\n\n/**\n * Move collateral from a subaccount's **allocated (tradeable) balance** back into\n * its **available balance** on the SYMMIO core.\n *\n * The reverse of {@link allocate}: the subaccount's allocated balance is debited\n * and its available balance credited, in 18-decimal units, after the contract\n * verifies the Muon uPnL signature keeps the subaccount solvent. The freed\n * collateral can then be withdrawn (subject to the separate withdraw cooldown).\n *\n * Encodes the SYMMIO core `deallocate(amount, upnlSig)` call and routes it through\n * `AccountLayer._call(account, …)` so the core attributes it to the subaccount.\n *\n * @remarks\n * Subject to the on-chain **deallocate debounce**: calling too soon after a prior\n * deallocate reverts (\"Too many deallocate in a short window\"). This is distinct\n * from the withdraw cooldown that later gates moving the freed collateral to the\n * wallet. The `upnlSig` must be freshly fetched — a stale attestation reverts.\n *\n * Dry-runs the call with {@link simulateDeallocate} first unless `simulateBeforeWrite`\n * is `false` (per-call, falling back to the config default).\n *\n * @param config - The SDK config (must have a `getWalletClient` resolver).\n * @param parameters - Subaccount, amount (18 decimals), optional Muon `upnlSig`\n *   (fetched automatically via {@link getDeallocateUpnlSig} when omitted), optional chain id.\n * @returns The submitted transaction hash. The caller waits on the receipt.\n * @throws {SymmError} when the chain is unsupported or no wallet is available.\n * @throws Viem's write errors (`ContractFunctionExecutionError`, ...).\n *\n * @example\n * ```ts\n * // upnlSig fetched automatically:\n * const hash = await deallocate(config, { account: \"0xsub…\", amount: 1_000000000000000000n });\n * // or reuse a pre-fetched signature:\n * const upnlSig = await getDeallocateUpnlSig(config, { virtualAccount: \"0xsub…\" });\n * await deallocate(config, { account: \"0xsub…\", amount: 1_000000000000000000n, upnlSig });\n * ```\n */\nexport async function deallocate(config: Config, parameters: DeallocateParameters): Promise<DeallocateReturnType> {\n  const { chainId, account, amount } = parameters;\n\n  const upnlSig =\n    parameters.upnlSig ?? (await getDeallocateUpnlSig(config, { virtualAccount: parameters.account, chainId }));\n\n  const data = encodeFunctionData({\n    abi: symmioAbi,\n    functionName: \"deallocate\",\n    args: [amount, upnlSig],\n  });\n\n  return callAsSubAccount(config, {\n    account,\n    data,\n    chainId,\n    from: parameters.from,\n    simulateBeforeWrite: parameters.simulateBeforeWrite,\n    gasless: parameters.gasless,\n  });\n}\n"],"mappings":";;;;;AA2EA,eAAsB,EAAW,GAAgB,GAAiE;CAChH,IAAM,EAAE,YAAS,YAAS,cAAW;CAWrC,OAAO,EAAiB,GAAQ;EAC9B;EACA,MARW,EAAmB;GAC9B,KAAK;GACL,cAAc;GACd,MAAM,CAAC,GALP,EAAW,WAAY,MAAM,EAAqB,GAAQ;IAAE,gBAAgB,EAAW;IAAS;GAAQ,CAAC,CAKnF;EACxB,CAIE;EACA;EACA,MAAM,EAAW;EACjB,qBAAqB,EAAW;EAChC,SAAS,EAAW;CACtB,CAAC;AACH"}

package/dist/symmio-contracts/symmio/actions/finalize-withdraw-request.d.ts

@@ -1,10 +1,10 @@
 import { Address, Hash } from 'viem';
 import { Config } from '../../../core/config/index.js';
-import { Compute, WriteContractParameter } from '../../../shared/types/properties.js';
+import { Compute, GaslessWriteParameter, WriteContractParameter } from '../../../shared/types/properties.js';
 /**
  * Parameters for {@link finalizeWithdrawRequest}.
  */
-export type FinalizeWithdrawRequestParameters = Compute<WriteContractParameter & {
+export type FinalizeWithdrawRequestParameters = Compute<WriteContractParameter & GaslessWriteParameter & {
     /** The subaccount that owns the request (the request's on-chain `user`). */
     user: Address;
     /** Id of the withdraw request to finalize. */
@@ -24,16 +24,28 @@ export type FinalizeWithdrawRequestReturnType = Hash;
  * Dry-runs the call with {@link simulateFinalizeWithdrawRequest} first unless
  * `simulateBeforeWrite` is `false` (per-call, falling back to the config default).
  *
+ * Relayable: pass `gasless` (or run the chain in `gasless.execution.mode`) to
+ * sign the same calldata as an InstantLayer operation instead of sending a
+ * transaction. The operation is signed by `user` — the request's own owner
+ * sub-account, which is therefore the account charged the operational fee —
+ * unless `gasless.account` names another. This completes the gasless withdraw:
+ * the initiating leg relays too, so neither step needs native gas.
+ *
  * @param config - The SDK config (must have a `getWalletClient` resolver).
  * @param parameters - The request's owner subaccount, request id, optional chain id.
- * @returns The submitted transaction hash. The caller waits on the receipt.
+ * @returns The submitted transaction hash — the relayer's broadcast hash when relayed.
  * @throws {SymmError} when the chain is unsupported or no wallet is available.
+ * @throws {SymmError} `GASLESS_NOT_CONFIGURED` when `gasless` is explicitly `true`
+ *   on a chain that carries no gasless service.
  * @throws Viem's write errors (`ContractFunctionExecutionError`, ...) — including
  *   when the cooldown has not yet elapsed.
  *
  * @example
  * ```ts
  * const hash = await finalizeWithdrawRequest(config, { user: "0xsub…", requestId: 1n });
+ *
+ * // …or relayed, paying the fee from SYMMIO collateral instead of native gas:
+ * const relayed = await finalizeWithdrawRequest(config, { user: "0xsub…", requestId: 1n, gasless: true });
  * ```
  */
 export declare function finalizeWithdrawRequest(config: Config, parameters: FinalizeWithdrawRequestParameters): Promise<FinalizeWithdrawRequestReturnType>;

package/dist/symmio-contracts/symmio/actions/finalize-withdraw-request.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"finalize-withdraw-request.d.ts","sourceRoot":"","sources":["../../../../src/symmio-contracts/symmio/actions/finalize-withdraw-request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC1C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAKxF;;GAEG;AACH,MAAM,MAAM,iCAAiC,GAAG,OAAO,CACrD,sBAAsB,GAAG;IACvB,4EAA4E;IAC5E,IAAI,EAAE,OAAO,CAAC;IACd,8CAA8C;IAC9C,SAAS,EAAE,MAAM,CAAC;CACnB,CACF,CAAC;AAEF,sFAAsF;AACtF,MAAM,MAAM,iCAAiC,GAAG,IAAI,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,iCAAiC,GAC5C,OAAO,CAAC,iCAAiC,CAAC,CAkB5C"}
+{"version":3,"file":"finalize-withdraw-request.d.ts","sourceRoot":"","sources":["../../../../src/symmio-contracts/symmio/actions/finalize-withdraw-request.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAE1C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,KAAK,EAAE,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAK/G;;GAEG;AACH,MAAM,MAAM,iCAAiC,GAAG,OAAO,CACrD,sBAAsB,GACpB,qBAAqB,GAAG;IACtB,4EAA4E;IAC5E,IAAI,EAAE,OAAO,CAAC;IACd,8CAA8C;IAC9C,SAAS,EAAE,MAAM,CAAC;CACnB,CACJ,CAAC;AAEF,sFAAsF;AACtF,MAAM,MAAM,iCAAiC,GAAG,IAAI,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,iCAAiC,GAC5C,OAAO,CAAC,iCAAiC,CAAC,CA6C5C"}

package/dist/symmio-contracts/symmio/actions/finalize-withdraw-request.js

@@ -1,27 +1,44 @@
 import { symmioAbi as e } from "../../abi/v0.8.6/symmio.js";
-import { shouldSimulateBeforeWrite as t } from "../../../shared/utils/simulate-before-write.js";
-import { simulateFinalizeWithdrawRequest as n } from "./simulate-finalize-withdraw-request.js";
+import { maybeRelayAsGasless as t } from "../../../gasless/dispatch/maybe-relay-as-gasless.js";
+import { shouldSimulateBeforeWrite as n } from "../../../shared/utils/simulate-before-write.js";
+import { simulateFinalizeWithdrawRequest as r } from "./simulate-finalize-withdraw-request.js";
+import { encodeFunctionData as i } from "viem";
 //#region src/symmio-contracts/symmio/actions/finalize-withdraw-request.ts
-async function r(r, i) {
-	let { chainId: a, user: o, requestId: s, from: c } = i, { addresses: l } = r.getChainConfig(a), u = await r.getWalletClient({
-		chainId: a,
-		from: c
+async function a(a, o) {
+	let { chainId: s, user: c, requestId: l, from: u } = o, { addresses: d } = a.getChainConfig(s), f = await t(a, {
+		chainId: s,
+		from: u,
+		gasless: o.gasless,
+		signerAccount: c,
+		calls: [{
+			target: d.symmioAddress,
+			callData: i({
+				abi: e,
+				functionName: "finalizeWithdrawRequest",
+				args: [c, l]
+			})
+		}]
 	});
-	return t(r, i) && await n(r, {
-		chainId: a,
-		user: o,
-		requestId: s,
-		from: u.account.address
-	}), u.writeContract({
-		address: l.symmioAddress,
+	if (f !== null) return f;
+	let p = await a.getWalletClient({
+		chainId: s,
+		from: u
+	});
+	return n(a, o) && await r(a, {
+		chainId: s,
+		user: c,
+		requestId: l,
+		from: p.account.address
+	}), p.writeContract({
+		address: d.symmioAddress,
 		abi: e,
 		functionName: "finalizeWithdrawRequest",
-		args: [o, s],
-		account: u.account,
-		chain: u.chain
+		args: [c, l],
+		account: p.account,
+		chain: p.chain
 	});
 }
 //#endregion
-export { r as finalizeWithdrawRequest };
+export { a as finalizeWithdrawRequest };
 
 //# sourceMappingURL=finalize-withdraw-request.js.map

package/dist/symmio-contracts/symmio/actions/finalize-withdraw-request.js.map

@@ -1 +1 @@
-{"version":3,"file":"finalize-withdraw-request.js","names":[],"sources":["../../../../src/symmio-contracts/symmio/actions/finalize-withdraw-request.ts"],"sourcesContent":["import type { Address, Hash } from \"viem\";\nimport type { Config } from \"../../../core/config\";\nimport type { Compute, WriteContractParameter } from \"../../../shared/types/properties\";\nimport { shouldSimulateBeforeWrite } from \"../../../shared/utils/simulate-before-write\";\nimport { symmioAbi } from \"../../abi/v0.8.6/symmio\";\nimport { simulateFinalizeWithdrawRequest } from \"./simulate-finalize-withdraw-request\";\n\n/**\n * Parameters for {@link finalizeWithdrawRequest}.\n */\nexport type FinalizeWithdrawRequestParameters = Compute<\n  WriteContractParameter & {\n    /** The subaccount that owns the request (the request's on-chain `user`). */\n    user: Address;\n    /** Id of the withdraw request to finalize. */\n    requestId: bigint;\n  }\n>;\n\n/** Return type of {@link finalizeWithdrawRequest}: the submitted transaction hash. */\nexport type FinalizeWithdrawRequestReturnType = Hash;\n\n/**\n * Finalize a matured withdraw request, paying out collateral to its receivers.\n *\n * Calls the SYMMIO core `finalizeWithdrawRequest(user, requestId)` **directly** —\n * the function is permissionless (it only checks that the cooldown has elapsed and\n * the status is valid), so it does not need the AccountLayer `_call` proxy and any\n * wallet may submit it. Funds go to the `receiver` baked into each part, not to\n * the caller.\n *\n * Dry-runs the call with {@link simulateFinalizeWithdrawRequest} first unless\n * `simulateBeforeWrite` is `false` (per-call, falling back to the config default).\n *\n * @param config - The SDK config (must have a `getWalletClient` resolver).\n * @param parameters - The request's owner subaccount, request id, optional chain id.\n * @returns The submitted transaction hash. The caller waits on the receipt.\n * @throws {SymmError} when the chain is unsupported or no wallet is available.\n * @throws Viem's write errors (`ContractFunctionExecutionError`, ...) — including\n *   when the cooldown has not yet elapsed.\n *\n * @example\n * ```ts\n * const hash = await finalizeWithdrawRequest(config, { user: \"0xsub…\", requestId: 1n });\n * ```\n */\nexport async function finalizeWithdrawRequest(\n  config: Config,\n  parameters: FinalizeWithdrawRequestParameters,\n): Promise<FinalizeWithdrawRequestReturnType> {\n  const { chainId, user, requestId, from } = parameters;\n\n  const { addresses } = config.getChainConfig(chainId);\n  const walletClient = await config.getWalletClient({ chainId, from });\n\n  if (shouldSimulateBeforeWrite(config, parameters)) {\n    await simulateFinalizeWithdrawRequest(config, { chainId, user, requestId, from: walletClient.account.address });\n  }\n\n  return walletClient.writeContract({\n    address: addresses.symmioAddress,\n    abi: symmioAbi,\n    functionName: \"finalizeWithdrawRequest\",\n    args: [user, requestId],\n    account: walletClient.account,\n    chain: walletClient.chain,\n  });\n}\n"],"mappings":";;;;AA8CA,eAAsB,EACpB,GACA,GAC4C;CAC5C,IAAM,EAAE,YAAS,SAAM,cAAW,YAAS,GAErC,EAAE,iBAAc,EAAO,eAAe,CAAO,GAC7C,IAAe,MAAM,EAAO,gBAAgB;EAAE;EAAS;CAAK,CAAC;CAMnE,OAJI,EAA0B,GAAQ,CAAU,KAC9C,MAAM,EAAgC,GAAQ;EAAE;EAAS;EAAM;EAAW,MAAM,EAAa,QAAQ;CAAQ,CAAC,GAGzG,EAAa,cAAc;EAChC,SAAS,EAAU;EACnB,KAAK;EACL,cAAc;EACd,MAAM,CAAC,GAAM,CAAS;EACtB,SAAS,EAAa;EACtB,OAAO,EAAa;CACtB,CAAC;AACH"}
+{"version":3,"file":"finalize-withdraw-request.js","names":[],"sources":["../../../../src/symmio-contracts/symmio/actions/finalize-withdraw-request.ts"],"sourcesContent":["import type { Address, Hash } from \"viem\";\nimport { encodeFunctionData } from \"viem\";\nimport type { Config } from \"../../../core/config\";\nimport { maybeRelayAsGasless } from \"../../../gasless/dispatch/maybe-relay-as-gasless\";\nimport type { Compute, GaslessWriteParameter, WriteContractParameter } from \"../../../shared/types/properties\";\nimport { shouldSimulateBeforeWrite } from \"../../../shared/utils/simulate-before-write\";\nimport { symmioAbi } from \"../../abi/v0.8.6/symmio\";\nimport { simulateFinalizeWithdrawRequest } from \"./simulate-finalize-withdraw-request\";\n\n/**\n * Parameters for {@link finalizeWithdrawRequest}.\n */\nexport type FinalizeWithdrawRequestParameters = Compute<\n  WriteContractParameter &\n    GaslessWriteParameter & {\n      /** The subaccount that owns the request (the request's on-chain `user`). */\n      user: Address;\n      /** Id of the withdraw request to finalize. */\n      requestId: bigint;\n    }\n>;\n\n/** Return type of {@link finalizeWithdrawRequest}: the submitted transaction hash. */\nexport type FinalizeWithdrawRequestReturnType = Hash;\n\n/**\n * Finalize a matured withdraw request, paying out collateral to its receivers.\n *\n * Calls the SYMMIO core `finalizeWithdrawRequest(user, requestId)` **directly** —\n * the function is permissionless (it only checks that the cooldown has elapsed and\n * the status is valid), so it does not need the AccountLayer `_call` proxy and any\n * wallet may submit it. Funds go to the `receiver` baked into each part, not to\n * the caller.\n *\n * Dry-runs the call with {@link simulateFinalizeWithdrawRequest} first unless\n * `simulateBeforeWrite` is `false` (per-call, falling back to the config default).\n *\n * Relayable: pass `gasless` (or run the chain in `gasless.execution.mode`) to\n * sign the same calldata as an InstantLayer operation instead of sending a\n * transaction. The operation is signed by `user` — the request's own owner\n * sub-account, which is therefore the account charged the operational fee —\n * unless `gasless.account` names another. This completes the gasless withdraw:\n * the initiating leg relays too, so neither step needs native gas.\n *\n * @param config - The SDK config (must have a `getWalletClient` resolver).\n * @param parameters - The request's owner subaccount, request id, optional chain id.\n * @returns The submitted transaction hash — the relayer's broadcast hash when relayed.\n * @throws {SymmError} when the chain is unsupported or no wallet is available.\n * @throws {SymmError} `GASLESS_NOT_CONFIGURED` when `gasless` is explicitly `true`\n *   on a chain that carries no gasless service.\n * @throws Viem's write errors (`ContractFunctionExecutionError`, ...) — including\n *   when the cooldown has not yet elapsed.\n *\n * @example\n * ```ts\n * const hash = await finalizeWithdrawRequest(config, { user: \"0xsub…\", requestId: 1n });\n *\n * // …or relayed, paying the fee from SYMMIO collateral instead of native gas:\n * const relayed = await finalizeWithdrawRequest(config, { user: \"0xsub…\", requestId: 1n, gasless: true });\n * ```\n */\nexport async function finalizeWithdrawRequest(\n  config: Config,\n  parameters: FinalizeWithdrawRequestParameters,\n): Promise<FinalizeWithdrawRequestReturnType> {\n  const { chainId, user, requestId, from } = parameters;\n\n  const { addresses } = config.getChainConfig(chainId);\n\n  /**\n   * Transparent gasless seam — see {@link addMargin}. Unlike the other core\n   * writes this one targets the diamond directly rather than through the\n   * AccountLayer `_call` proxy (it is permissionless), so the relay signs it\n   * as an operation of the request's own owner sub-account: `user` is the\n   * billing/authority account unless `gasless.account` overrides it.\n   * `null` means: proceed on the wallet path below, unchanged.\n   */\n  const relayed = await maybeRelayAsGasless(config, {\n    chainId,\n    from,\n    gasless: parameters.gasless,\n    signerAccount: user,\n    calls: [\n      {\n        target: addresses.symmioAddress,\n        callData: encodeFunctionData({\n          abi: symmioAbi,\n          functionName: \"finalizeWithdrawRequest\",\n          args: [user, requestId],\n        }),\n      },\n    ],\n  });\n  if (relayed !== null) return relayed;\n\n  const walletClient = await config.getWalletClient({ chainId, from });\n\n  if (shouldSimulateBeforeWrite(config, parameters)) {\n    await simulateFinalizeWithdrawRequest(config, { chainId, user, requestId, from: walletClient.account.address });\n  }\n\n  return walletClient.writeContract({\n    address: addresses.symmioAddress,\n    abi: symmioAbi,\n    functionName: \"finalizeWithdrawRequest\",\n    args: [user, requestId],\n    account: walletClient.account,\n    chain: walletClient.chain,\n  });\n}\n"],"mappings":";;;;;;AA6DA,eAAsB,EACpB,GACA,GAC4C;CAC5C,IAAM,EAAE,YAAS,SAAM,cAAW,YAAS,GAErC,EAAE,iBAAc,EAAO,eAAe,CAAO,GAU7C,IAAU,MAAM,EAAoB,GAAQ;EAChD;EACA;EACA,SAAS,EAAW;EACpB,eAAe;EACf,OAAO,CACL;GACE,QAAQ,EAAU;GAClB,UAAU,EAAmB;IAC3B,KAAK;IACL,cAAc;IACd,MAAM,CAAC,GAAM,CAAS;GACxB,CAAC;EACH,CACF;CACF,CAAC;CACD,IAAI,MAAY,MAAM,OAAO;CAE7B,IAAM,IAAe,MAAM,EAAO,gBAAgB;EAAE;EAAS;CAAK,CAAC;CAMnE,OAJI,EAA0B,GAAQ,CAAU,KAC9C,MAAM,EAAgC,GAAQ;EAAE;EAAS;EAAM;EAAW,MAAM,EAAa,QAAQ;CAAQ,CAAC,GAGzG,EAAa,cAAc;EAChC,SAAS,EAAU;EACnB,KAAK;EACL,cAAc;EACd,MAAM,CAAC,GAAM,CAAS;EACtB,SAAS,EAAa;EACtB,OAAO,EAAa;CACtB,CAAC;AACH"}

package/dist/symmio-contracts/symmio/actions/force-cancel-close-request.d.ts

@@ -1,10 +1,10 @@
 import { Address, Hash } from 'viem';
 import { Config } from '../../../core/config/index.js';
-import { Compute, WriteContractParameter } from '../../../shared/types/properties.js';
+import { Compute, GaslessWriteParameter, WriteContractParameter } from '../../../shared/types/properties.js';
 /**
  * Parameters for {@link forceCancelCloseRequest}.
  */
-export type ForceCancelCloseRequestParameters = Compute<WriteContractParameter & {
+export type ForceCancelCloseRequestParameters = Compute<WriteContractParameter & GaslessWriteParameter & {
     /**
      * The subaccount (partyA) that owns the quote. Routed through the AccountLayer
      * `_call` proxy so the core sees this subaccount as the caller; the connected