@symmio/trading-core 3.0.0 → 3.1.0

package/dist/gasless/get-gasless-wallet-nonce/get-gasless-wallet-nonce.d.ts

@@ -0,0 +1,51 @@
+import { Address } from 'viem';
+import { Config } from '../../core/config/index.js';
+import { ChainIdParameter, Compute } from '../../shared/types/properties.js';
+/**
+ * Parameters for {@link getGaslessWalletNonce}.
+ */
+export type GetGaslessWalletNonceParameters = Compute<ChainIdParameter & {
+    /** The owner wallet the gasless wallet belongs to — an owner address, never a GaslessWallet address. */
+    owner: Address;
+    /**
+     * Which of the owner's GaslessWallets the operation executes from. Defaults
+     * to `0n`, the original wallet, which keeps its pre-upgrade nonce stream.
+     * Range `0n` through `2^256 - 1`.
+     */
+    walletId?: bigint;
+    /**
+     * The signer account the nonce is keyed under — the operation's
+     * `signerAccount.addr` (the owner itself for an owner-signed call, or a
+     * sub-account for a session-key signer).
+     */
+    account: Address;
+}>;
+/** Return type of {@link getGaslessWalletNonce}. */
+export type GetGaslessWalletNonceReturnType = bigint;
+/**
+ * Read the GaslessLayer's **wallet-operation** replay nonce —
+ * `walletOperationNonces(owner, walletId, signerAccount)`, the last nonce the
+ * selected wallet consumed for that signer account.
+ *
+ * A separate counter from the InstantLayer's operation nonces — the two are
+ * not interchangeable. Wallet-execute operations sign with `nonce + 1`, read
+ * immediately before signing. Every `(walletId, signerAccount)` pair is its own
+ * stream: wallet `0` keeps the original per-signer-account counter, and each
+ * positive id counts separately for its own wallet address, so nonces from one
+ * id never apply to another.
+ *
+ * @param config - The SDK config.
+ * @param parameters - Owner wallet, optional wallet id (default `0n`), signer account, optional chain id.
+ * @returns The current wallet-operation nonce. Sign with `nonce + 1n`.
+ * @throws {SymmError} `GASLESS_WALLET_ID_INVALID` for a wallet id outside the `uint256` range
+ *   (or a JavaScript `number`), before any RPC call.
+ * @throws {SymmError} `GASLESS_NOT_CONFIGURED` / `GASLESS_UNSUPPORTED_CONTRACTS_VERSION`.
+ *
+ * @example
+ * ```ts
+ * const current = await getGaslessWalletNonce(config, { owner, walletId: 2n, account: subAccount });
+ * const nextNonce = current + 1n;
+ * ```
+ */
+export declare function getGaslessWalletNonce(config: Config, parameters: GetGaslessWalletNonceParameters): Promise<GetGaslessWalletNonceReturnType>;
+//# sourceMappingURL=get-gasless-wallet-nonce.d.ts.map

package/dist/gasless/get-gasless-wallet-nonce/get-gasless-wallet-nonce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-gasless-wallet-nonce.d.ts","sourceRoot":"","sources":["../../../src/gasless/get-gasless-wallet-nonce/get-gasless-wallet-nonce.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAC;AAK/E;;GAEG;AACH,MAAM,MAAM,+BAA+B,GAAG,OAAO,CACnD,gBAAgB,GAAG;IACjB,wGAAwG;IACxG,KAAK,EAAE,OAAO,CAAC;IACf;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;CAClB,CACF,CAAC;AAEF,oDAAoD;AACpD,MAAM,MAAM,+BAA+B,GAAG,MAAM,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,+BAA+B,GAC1C,OAAO,CAAC,+BAA+B,CAAC,CAY1C"}

package/dist/gasless/get-gasless-wallet-nonce/get-gasless-wallet-nonce.js

@@ -0,0 +1,21 @@
+import { gaslessLayerAbi as e } from "../../symmio-contracts/abi/v0.8.6/gasless-layer.js";
+import { resolveGaslessService as t } from "../resolve-gasless.js";
+import { assertGaslessWalletId as n } from "../wallet-id.js";
+//#region src/gasless/get-gasless-wallet-nonce/get-gasless-wallet-nonce.ts
+async function r(r, i) {
+	let { chainId: a, owner: o, account: s } = i, c = n(i.walletId ?? 0n), l = t(r, { chainId: a });
+	return r.getClient({ chainId: a }).readContract({
+		address: l.gaslessLayerAddress,
+		abi: e,
+		functionName: "walletOperationNonces",
+		args: [
+			o,
+			c,
+			s
+		]
+	});
+}
+//#endregion
+export { r as getGaslessWalletNonce };
+
+//# sourceMappingURL=get-gasless-wallet-nonce.js.map

package/dist/gasless/get-gasless-wallet-nonce/get-gasless-wallet-nonce.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-gasless-wallet-nonce.js","names":[],"sources":["../../../src/gasless/get-gasless-wallet-nonce/get-gasless-wallet-nonce.ts"],"sourcesContent":["import type { Address } from \"viem\";\nimport type { Config } from \"../../core/config\";\nimport type { ChainIdParameter, Compute } from \"../../shared/types/properties\";\nimport { gaslessLayerAbi } from \"../../symmio-contracts/abi/v0.8.6/gasless-layer\";\nimport { resolveGaslessService } from \"../resolve-gasless\";\nimport { assertGaslessWalletId } from \"../wallet-id\";\n\n/**\n * Parameters for {@link getGaslessWalletNonce}.\n */\nexport type GetGaslessWalletNonceParameters = Compute<\n  ChainIdParameter & {\n    /** The owner wallet the gasless wallet belongs to — an owner address, never a GaslessWallet address. */\n    owner: Address;\n    /**\n     * Which of the owner's GaslessWallets the operation executes from. Defaults\n     * to `0n`, the original wallet, which keeps its pre-upgrade nonce stream.\n     * Range `0n` through `2^256 - 1`.\n     */\n    walletId?: bigint;\n    /**\n     * The signer account the nonce is keyed under — the operation's\n     * `signerAccount.addr` (the owner itself for an owner-signed call, or a\n     * sub-account for a session-key signer).\n     */\n    account: Address;\n  }\n>;\n\n/** Return type of {@link getGaslessWalletNonce}. */\nexport type GetGaslessWalletNonceReturnType = bigint;\n\n/**\n * Read the GaslessLayer's **wallet-operation** replay nonce —\n * `walletOperationNonces(owner, walletId, signerAccount)`, the last nonce the\n * selected wallet consumed for that signer account.\n *\n * A separate counter from the InstantLayer's operation nonces — the two are\n * not interchangeable. Wallet-execute operations sign with `nonce + 1`, read\n * immediately before signing. Every `(walletId, signerAccount)` pair is its own\n * stream: wallet `0` keeps the original per-signer-account counter, and each\n * positive id counts separately for its own wallet address, so nonces from one\n * id never apply to another.\n *\n * @param config - The SDK config.\n * @param parameters - Owner wallet, optional wallet id (default `0n`), signer account, optional chain id.\n * @returns The current wallet-operation nonce. Sign with `nonce + 1n`.\n * @throws {SymmError} `GASLESS_WALLET_ID_INVALID` for a wallet id outside the `uint256` range\n *   (or a JavaScript `number`), before any RPC call.\n * @throws {SymmError} `GASLESS_NOT_CONFIGURED` / `GASLESS_UNSUPPORTED_CONTRACTS_VERSION`.\n *\n * @example\n * ```ts\n * const current = await getGaslessWalletNonce(config, { owner, walletId: 2n, account: subAccount });\n * const nextNonce = current + 1n;\n * ```\n */\nexport async function getGaslessWalletNonce(\n  config: Config,\n  parameters: GetGaslessWalletNonceParameters,\n): Promise<GetGaslessWalletNonceReturnType> {\n  const { chainId, owner, account } = parameters;\n  const walletId = assertGaslessWalletId(parameters.walletId ?? 0n);\n  const gasless = resolveGaslessService(config, { chainId });\n  const client = config.getClient({ chainId });\n\n  return client.readContract({\n    address: gasless.gaslessLayerAddress,\n    abi: gaslessLayerAbi,\n    functionName: \"walletOperationNonces\",\n    args: [owner, walletId, account],\n  });\n}\n"],"mappings":";;;;AAyDA,eAAsB,EACpB,GACA,GAC0C;CAC1C,IAAM,EAAE,YAAS,UAAO,eAAY,GAC9B,IAAW,EAAsB,EAAW,YAAY,EAAE,GAC1D,IAAU,EAAsB,GAAQ,EAAE,WAAQ,CAAC;CAGzD,OAFe,EAAO,UAAU,EAAE,WAAQ,CAEnC,EAAO,aAAa;EACzB,SAAS,EAAQ;EACjB,KAAK;EACL,cAAc;EACd,MAAM;GAAC;GAAO;GAAU;EAAO;CACjC,CAAC;AACH"}

package/dist/gasless/get-gasless-wallet-nonce/index.d.ts

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

package/dist/gasless/get-gasless-wallet-nonce/index.d.ts.map

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

package/dist/gasless/get-gasless-wallet-nonce/query.d.ts

@@ -0,0 +1,47 @@
+import { Config } from '../../core/config/index.js';
+import { Compute, ConfigKeyParameter, ExactPartial } from '../../shared/types/properties.js';
+import { QueryParameter, SymmioQueryOptions } from '../../shared/types/query.js';
+import { GetGaslessWalletNonceParameters, GetGaslessWalletNonceReturnType } from './get-gasless-wallet-nonce.js';
+/** Data resolved by the {@link getGaslessWalletNonceQueryOptions} query. */
+export type GetGaslessWalletNonceData = GetGaslessWalletNonceReturnType;
+/**
+ * Build the TanStack Query key for {@link getGaslessWalletNonceQueryOptions}.
+ *
+ * An omitted `walletId` keys as `0n`, so `{ owner, account }` and
+ * `{ owner, walletId: 0n, account }` share one cache entry — they read the same
+ * nonce stream. `predicateMatch` compares only the fields its partial sets, so
+ * `predicateMatch(getGaslessWalletNonceQueryKey, { account })` still matches the
+ * account's nonce on every wallet.
+ *
+ * @param options - Partial query parameters.
+ * @returns A stable, hashable query key.
+ *
+ * @example
+ * ```ts
+ * getGaslessWalletNonceQueryKey({ owner, account });
+ * // → ["getGaslessWalletNonce", { owner, account, walletId: "0" }]
+ * ```
+ */
+export declare function getGaslessWalletNonceQueryKey(options?: Compute<ExactPartial<GetGaslessWalletNonceParameters> & ConfigKeyParameter>): readonly ["getGaslessWalletNonce", Record<string, unknown>];
+/** Query-key type produced by {@link getGaslessWalletNonceQueryKey}. */
+export type GetGaslessWalletNonceQueryKey = ReturnType<typeof getGaslessWalletNonceQueryKey>;
+/**
+ * Options accepted by {@link getGaslessWalletNonceQueryOptions}.
+ */
+export type GetGaslessWalletNonceOptions = Compute<GetGaslessWalletNonceParameters & QueryParameter<GetGaslessWalletNonceData, Error, GetGaslessWalletNonceData, GetGaslessWalletNonceQueryKey>>;
+/** TanStack Query options returned by {@link getGaslessWalletNonceQueryOptions}. */
+export type GetGaslessWalletNonceQueryOptions = SymmioQueryOptions<GetGaslessWalletNonceData, Error, GetGaslessWalletNonceData, GetGaslessWalletNonceQueryKey>;
+/**
+ * Build TanStack Query options for {@link getGaslessWalletNonce}.
+ *
+ * @param config - The SDK config.
+ * @param options - Query parameters and TanStack overrides.
+ * @returns Options to pass to `useQuery` / `queryClient.fetchQuery`.
+ *
+ * @example
+ * ```ts
+ * useQuery(getGaslessWalletNonceQueryOptions(config, { owner, walletId: 1n, account: subAccount }));
+ * ```
+ */
+export declare function getGaslessWalletNonceQueryOptions(config: Config, options: GetGaslessWalletNonceOptions): GetGaslessWalletNonceQueryOptions;
+//# sourceMappingURL=query.d.ts.map

package/dist/gasless/get-gasless-wallet-nonce/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../src/gasless/get-gasless-wallet-nonce/query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAE,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAC/F,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEnF,OAAO,EAEL,KAAK,+BAA+B,EACpC,KAAK,+BAA+B,EACrC,MAAM,4BAA4B,CAAC;AAEpC,4EAA4E;AAC5E,MAAM,MAAM,yBAAyB,GAAG,+BAA+B,CAAC;AAExE;;;;;;;;;;;;;;;;;GAiBG;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;;GAEG;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,EAAE,4BAA4B,GACpC,iCAAiC,CASnC"}

package/dist/gasless/get-gasless-wallet-nonce/query.js

@@ -0,0 +1,25 @@
+import { filterQueryOptions as e } from "../../shared/utils/query.js";
+import { getGaslessWalletNonce as t } from "./get-gasless-wallet-nonce.js";
+//#region src/gasless/get-gasless-wallet-nonce/query.ts
+function n(t = {}) {
+	return ["getGaslessWalletNonce", e({
+		...t,
+		walletId: t.walletId ?? 0n
+	})];
+}
+function r(e, r) {
+	let { query: i, ...a } = r;
+	return {
+		...i,
+		queryKey: n({
+			...a,
+			configKey: e.getChainConfigKey(a.chainId)
+		}),
+		enabled: i?.enabled ?? !0,
+		queryFn: () => t(e, a)
+	};
+}
+//#endregion
+export { n as getGaslessWalletNonceQueryKey, r as getGaslessWalletNonceQueryOptions };
+
+//# sourceMappingURL=query.js.map

package/dist/gasless/get-gasless-wallet-nonce/query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.js","names":[],"sources":["../../../src/gasless/get-gasless-wallet-nonce/query.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  getGaslessWalletNonce,\n  type GetGaslessWalletNonceParameters,\n  type GetGaslessWalletNonceReturnType,\n} from \"./get-gasless-wallet-nonce\";\n\n/** Data resolved by the {@link getGaslessWalletNonceQueryOptions} query. */\nexport type GetGaslessWalletNonceData = GetGaslessWalletNonceReturnType;\n\n/**\n * Build the TanStack Query key for {@link getGaslessWalletNonceQueryOptions}.\n *\n * An omitted `walletId` keys as `0n`, so `{ owner, account }` and\n * `{ owner, walletId: 0n, account }` share one cache entry — they read the same\n * nonce stream. `predicateMatch` compares only the fields its partial sets, so\n * `predicateMatch(getGaslessWalletNonceQueryKey, { account })` still matches the\n * account's nonce on every wallet.\n *\n * @param options - Partial query parameters.\n * @returns A stable, hashable query key.\n *\n * @example\n * ```ts\n * getGaslessWalletNonceQueryKey({ owner, account });\n * // → [\"getGaslessWalletNonce\", { owner, account, walletId: \"0\" }]\n * ```\n */\nexport function getGaslessWalletNonceQueryKey(\n  options: Compute<ExactPartial<GetGaslessWalletNonceParameters> & ConfigKeyParameter> = {},\n) {\n  return [\"getGaslessWalletNonce\", filterQueryOptions({ ...options, walletId: options.walletId ?? 0n })] as const;\n}\n\n/** Query-key type produced by {@link getGaslessWalletNonceQueryKey}. */\nexport type GetGaslessWalletNonceQueryKey = ReturnType<typeof getGaslessWalletNonceQueryKey>;\n\n/**\n * Options accepted by {@link getGaslessWalletNonceQueryOptions}.\n */\nexport type GetGaslessWalletNonceOptions = Compute<\n  GetGaslessWalletNonceParameters &\n    QueryParameter<GetGaslessWalletNonceData, Error, GetGaslessWalletNonceData, GetGaslessWalletNonceQueryKey>\n>;\n\n/** TanStack Query options returned by {@link getGaslessWalletNonceQueryOptions}. */\nexport type GetGaslessWalletNonceQueryOptions = SymmioQueryOptions<\n  GetGaslessWalletNonceData,\n  Error,\n  GetGaslessWalletNonceData,\n  GetGaslessWalletNonceQueryKey\n>;\n\n/**\n * Build TanStack Query options for {@link getGaslessWalletNonce}.\n *\n * @param config - The SDK config.\n * @param options - Query parameters and TanStack overrides.\n * @returns Options to pass to `useQuery` / `queryClient.fetchQuery`.\n *\n * @example\n * ```ts\n * useQuery(getGaslessWalletNonceQueryOptions(config, { owner, walletId: 1n, account: subAccount }));\n * ```\n */\nexport function getGaslessWalletNonceQueryOptions(\n  config: Config,\n  options: GetGaslessWalletNonceOptions,\n): GetGaslessWalletNonceQueryOptions {\n  /** Every parameter reaches the action: a hand-listed subset would silently drop a new one, such as `walletId`. */\n  const { query, ...parameters } = options;\n  return {\n    ...query,\n    queryKey: getGaslessWalletNonceQueryKey({ ...parameters, configKey: config.getChainConfigKey(parameters.chainId) }),\n    enabled: query?.enabled ?? true,\n    queryFn: () => getGaslessWalletNonce(config, parameters),\n  };\n}\n"],"mappings":";;;AA+BA,SAAgB,EACd,IAAuF,CAAC,GACxF;CACA,OAAO,CAAC,yBAAyB,EAAmB;EAAE,GAAG;EAAS,UAAU,EAAQ,YAAY;CAAG,CAAC,CAAC;AACvG;AAiCA,SAAgB,EACd,GACA,GACmC;CAEnC,IAAM,EAAE,UAAO,GAAG,MAAe;CACjC,OAAO;EACL,GAAG;EACH,UAAU,EAA8B;GAAE,GAAG;GAAY,WAAW,EAAO,kBAAkB,EAAW,OAAO;EAAE,CAAC;EAClH,SAAS,GAAO,WAAW;EAC3B,eAAe,EAAsB,GAAQ,CAAU;CACzD;AACF"}

package/dist/gasless/get-session-key-selectors.d.ts

@@ -0,0 +1,83 @@
+import { Hex } from 'viem';
+import { Config } from '../core/config/index.js';
+import { ChainIdParameter, Compute } from '../shared/types/properties.js';
+/**
+ * Which authority to include in a session key's delegation grant.
+ *
+ * Each flag is a separate decision, so an app grants exactly the authority its
+ * key needs and nothing more.
+ */
+export interface SessionKeySelectorScope {
+    /**
+     * Include the instant trade lifecycle — open, close and margin top-up —
+     * resolved for the chain's contracts generation. Defaults to `true`.
+     */
+    trade?: boolean;
+    /**
+     * Include gasless account management (`GASLESS_SESSION_KEY_SELECTORS`):
+     * allocation, margin, cancellations, force-cancels, the operational-fee
+     * approval, renaming, and settling or cancelling an already-initiated
+     * withdrawal. Defaults to `true`.
+     */
+    account?: boolean;
+    /**
+     * Include `initiateWithdraw` (`GASLESS_SESSION_KEY_WITHDRAW_SELECTORS`).
+     * Defaults to **`false`**: its parts carry a caller-supplied `receiver`, so a
+     * key holding it can send the sub-account's collateral to an address of its
+     * own choosing. Opt in only for a key that must run withdrawals unattended.
+     */
+    withdraw?: boolean;
+}
+/**
+ * Parameters for {@link getSessionKeySelectors}: the target chain plus the
+ * authority scope to grant.
+ */
+export type GetSessionKeySelectorsParameters = Compute<ChainIdParameter & SessionKeySelectorScope>;
+/**
+ * Build the selector set to grant a session key — **this is the function to
+ * call**. {@link GASLESS_SESSION_KEY_SELECTORS} and
+ * {@link GASLESS_SESSION_KEY_WITHDRAW_SELECTORS} are its low-level pieces, and
+ * the trade lifecycle is a third piece that is chain-dependent; this resolves
+ * all three for one chain and hands back a single array for `grantDelegation`.
+ *
+ * The default scope — trade **and** account management, **without**
+ * `initiateWithdraw` — is the onboarding grant: one signature buys a key
+ * promptless, gas-free authority over the whole trading lifecycle and the
+ * account's own bookkeeping, while the one write that names a destination for
+ * collateral stays behind an explicit `withdraw: true`.
+ *
+ * The returned order is stable and meaningful — account selectors, then the
+ * withdraw selector, then the trade selectors — so two grants diff readably in a
+ * UI. Values are lowercase and de-duplicated.
+ *
+ * @param config - The SDK config.
+ * @param parameters - Optional `chainId` (defaults to the config's
+ *   `defaultChainId`) and scope flags.
+ * @returns The de-duplicated, lowercase selector set for the requested scope.
+ * @throws {SymmError} `UNSUPPORTED_CHAIN` when the chain is not configured.
+ * @throws {SymmError} `SESSION_KEY_SELECTORS_UNSUPPORTED_CHAIN` when the `account`
+ *   or `withdraw` scope is requested on a chain whose `contractsVersion` is not
+ *   `"0.8.6"`. Those selectors come from the v0.8.6 ABIs and include
+ *   `approveOperationalFeeWithMultiplier`, which does not exist on a v0.8.5
+ *   diamond. A trade-only request (`{ account: false }`) works on both
+ *   generations.
+ *
+ * @example
+ * ```ts
+ * await grantDelegation(config, {
+ *   account: { addr: subAccount, isPartyB: false },
+ *   delegatedSigner: sessionKey,
+ *   selectors: getSessionKeySelectors(config, { chainId }),
+ *   expiryTimestamp,
+ *   gasless: true,
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * // A key that also withdraws unattended — it can move the collateral out.
+ * const selectors = getSessionKeySelectors(config, { chainId, withdraw: true });
+ * ```
+ */
+export declare function getSessionKeySelectors(config: Config, parameters?: GetSessionKeySelectorsParameters): readonly Hex[];
+//# sourceMappingURL=get-session-key-selectors.d.ts.map

package/dist/gasless/get-session-key-selectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-session-key-selectors.d.ts","sourceRoot":"","sources":["../../src/gasless/get-session-key-selectors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAChC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAE7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAI5E;;;;;GAKG;AACH,MAAM,WAAW,uBAAuB;IACtC;;;OAGG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;GAGG;AACH,MAAM,MAAM,gCAAgC,GAAG,OAAO,CAAC,gBAAgB,GAAG,uBAAuB,CAAC,CAAC;AAqBnG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,MAAM,EACd,UAAU,GAAE,gCAAqC,GAChD,SAAS,GAAG,EAAE,CAqBhB"}

package/dist/gasless/get-session-key-selectors.js

@@ -0,0 +1,25 @@
+import { SymmError as e } from "../shared/errors/symm-error.js";
+import { GASLESS_SESSION_KEY_SELECTORS as t, GASLESS_SESSION_KEY_WITHDRAW_SELECTORS as n } from "./relayable-writes.js";
+import { getInstantTradeRequiredSelectors as r } from "../solvers/instant-open/shared/selectors.js";
+//#region src/gasless/get-session-key-selectors.ts
+function i(e) {
+	let t = /* @__PURE__ */ new Set(), n = [];
+	for (let r of e) {
+		let e = r.toLowerCase();
+		t.has(e) || (t.add(e), n.push(e));
+	}
+	return n;
+}
+function a(a, o = {}) {
+	let { chainId: s, trade: c = !0, account: l = !0, withdraw: u = !1 } = o, d = [];
+	if (l || u) {
+		let r = a.getChainConfig(s);
+		if (r.contractsVersion !== "0.8.6") throw new e("config", "SESSION_KEY_SELECTORS_UNSUPPORTED_CHAIN", `Session keys: chain ${r.chainId} runs contracts ${r.contractsVersion}, but the account-management selectors exist only on perps-core ("0.8.6") deployments. Request \`{ account: false, withdraw: false }\` for a trade-only key.`);
+		l && d.push(...t), u && d.push(...n);
+	}
+	return c && d.push(...r(a, { chainId: s })), i(d);
+}
+//#endregion
+export { a as getSessionKeySelectors };
+
+//# sourceMappingURL=get-session-key-selectors.js.map

package/dist/gasless/get-session-key-selectors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-session-key-selectors.js","names":[],"sources":["../../src/gasless/get-session-key-selectors.ts"],"sourcesContent":["import type { Hex } from \"viem\";\nimport type { Config } from \"../core/config\";\nimport { SymmError } from \"../shared/errors/symm-error\";\nimport type { ChainIdParameter, Compute } from \"../shared/types/properties\";\nimport { getInstantTradeRequiredSelectors } from \"../solvers/instant-open/shared/selectors\";\nimport { GASLESS_SESSION_KEY_SELECTORS, GASLESS_SESSION_KEY_WITHDRAW_SELECTORS } from \"./relayable-writes\";\n\n/**\n * Which authority to include in a session key's delegation grant.\n *\n * Each flag is a separate decision, so an app grants exactly the authority its\n * key needs and nothing more.\n */\nexport interface SessionKeySelectorScope {\n  /**\n   * Include the instant trade lifecycle — open, close and margin top-up —\n   * resolved for the chain's contracts generation. Defaults to `true`.\n   */\n  trade?: boolean;\n  /**\n   * Include gasless account management (`GASLESS_SESSION_KEY_SELECTORS`):\n   * allocation, margin, cancellations, force-cancels, the operational-fee\n   * approval, renaming, and settling or cancelling an already-initiated\n   * withdrawal. Defaults to `true`.\n   */\n  account?: boolean;\n  /**\n   * Include `initiateWithdraw` (`GASLESS_SESSION_KEY_WITHDRAW_SELECTORS`).\n   * Defaults to **`false`**: its parts carry a caller-supplied `receiver`, so a\n   * key holding it can send the sub-account's collateral to an address of its\n   * own choosing. Opt in only for a key that must run withdrawals unattended.\n   */\n  withdraw?: boolean;\n}\n\n/**\n * Parameters for {@link getSessionKeySelectors}: the target chain plus the\n * authority scope to grant.\n */\nexport type GetSessionKeySelectorsParameters = Compute<ChainIdParameter & SessionKeySelectorScope>;\n\n/**\n * Normalize to lowercase and drop repeats while preserving first-seen order.\n *\n * The scopes overlap by design (a selector may appear in more than one source\n * set), and `grantDelegation` rejects a duplicate-bearing selector array, so the\n * union has to be de-duplicated before it reaches the contract.\n */\nfunction dedupeSelectors(selectors: readonly Hex[]): readonly Hex[] {\n  const seen = new Set<Hex>();\n  const unique: Hex[] = [];\n  for (const selector of selectors) {\n    const normalized = selector.toLowerCase() as Hex;\n    if (seen.has(normalized)) continue;\n    seen.add(normalized);\n    unique.push(normalized);\n  }\n  return unique;\n}\n\n/**\n * Build the selector set to grant a session key — **this is the function to\n * call**. {@link GASLESS_SESSION_KEY_SELECTORS} and\n * {@link GASLESS_SESSION_KEY_WITHDRAW_SELECTORS} are its low-level pieces, and\n * the trade lifecycle is a third piece that is chain-dependent; this resolves\n * all three for one chain and hands back a single array for `grantDelegation`.\n *\n * The default scope — trade **and** account management, **without**\n * `initiateWithdraw` — is the onboarding grant: one signature buys a key\n * promptless, gas-free authority over the whole trading lifecycle and the\n * account's own bookkeeping, while the one write that names a destination for\n * collateral stays behind an explicit `withdraw: true`.\n *\n * The returned order is stable and meaningful — account selectors, then the\n * withdraw selector, then the trade selectors — so two grants diff readably in a\n * UI. Values are lowercase and de-duplicated.\n *\n * @param config - The SDK config.\n * @param parameters - Optional `chainId` (defaults to the config's\n *   `defaultChainId`) and scope flags.\n * @returns The de-duplicated, lowercase selector set for the requested scope.\n * @throws {SymmError} `UNSUPPORTED_CHAIN` when the chain is not configured.\n * @throws {SymmError} `SESSION_KEY_SELECTORS_UNSUPPORTED_CHAIN` when the `account`\n *   or `withdraw` scope is requested on a chain whose `contractsVersion` is not\n *   `\"0.8.6\"`. Those selectors come from the v0.8.6 ABIs and include\n *   `approveOperationalFeeWithMultiplier`, which does not exist on a v0.8.5\n *   diamond. A trade-only request (`{ account: false }`) works on both\n *   generations.\n *\n * @example\n * ```ts\n * await grantDelegation(config, {\n *   account: { addr: subAccount, isPartyB: false },\n *   delegatedSigner: sessionKey,\n *   selectors: getSessionKeySelectors(config, { chainId }),\n *   expiryTimestamp,\n *   gasless: true,\n * });\n * ```\n *\n * @example\n * ```ts\n * // A key that also withdraws unattended — it can move the collateral out.\n * const selectors = getSessionKeySelectors(config, { chainId, withdraw: true });\n * ```\n */\nexport function getSessionKeySelectors(\n  config: Config,\n  parameters: GetSessionKeySelectorsParameters = {},\n): readonly Hex[] {\n  const { chainId, trade = true, account = true, withdraw = false } = parameters;\n\n  const selectors: Hex[] = [];\n\n  if (account || withdraw) {\n    const chain = config.getChainConfig(chainId);\n    if (chain.contractsVersion !== \"0.8.6\") {\n      throw new SymmError(\n        \"config\",\n        \"SESSION_KEY_SELECTORS_UNSUPPORTED_CHAIN\",\n        `Session keys: chain ${chain.chainId} runs contracts ${chain.contractsVersion}, but the account-management selectors exist only on perps-core (\"0.8.6\") deployments. Request \\`{ account: false, withdraw: false }\\` for a trade-only key.`,\n      );\n    }\n    if (account) selectors.push(...GASLESS_SESSION_KEY_SELECTORS);\n    if (withdraw) selectors.push(...GASLESS_SESSION_KEY_WITHDRAW_SELECTORS);\n  }\n\n  if (trade) selectors.push(...getInstantTradeRequiredSelectors(config, { chainId }));\n\n  return dedupeSelectors(selectors);\n}\n"],"mappings":";;;;AAgDA,SAAS,EAAgB,GAA2C;CAClE,IAAM,oBAAO,IAAI,IAAS,GACpB,IAAgB,CAAC;CACvB,KAAK,IAAM,KAAY,GAAW;EAChC,IAAM,IAAa,EAAS,YAAY;EACpC,EAAK,IAAI,CAAU,MACvB,EAAK,IAAI,CAAU,GACnB,EAAO,KAAK,CAAU;CACxB;CACA,OAAO;AACT;AAgDA,SAAgB,EACd,GACA,IAA+C,CAAC,GAChC;CAChB,IAAM,EAAE,YAAS,WAAQ,IAAM,aAAU,IAAM,cAAW,OAAU,GAE9D,IAAmB,CAAC;CAE1B,IAAI,KAAW,GAAU;EACvB,IAAM,IAAQ,EAAO,eAAe,CAAO;EAC3C,IAAI,EAAM,qBAAqB,SAC7B,MAAM,IAAI,EACR,UACA,2CACA,uBAAuB,EAAM,QAAQ,kBAAkB,EAAM,iBAAiB,6JAChF;EAGF,AADI,KAAS,EAAU,KAAK,GAAG,CAA6B,GACxD,KAAU,EAAU,KAAK,GAAG,CAAsC;CACxE;CAIA,OAFI,KAAO,EAAU,KAAK,GAAG,EAAiC,GAAQ,EAAE,WAAQ,CAAC,CAAC,GAE3E,EAAgB,CAAS;AAClC"}

package/dist/gasless/http.d.ts

@@ -0,0 +1,229 @@
+import { AxiosResponse } from 'axios';
+import { SymmioGaslessConfig } from '../core/chains/types.js';
+import { Config } from '../core/config/index.js';
+import { GaslessService } from './types.js';
+import { GaslessSubmitPath } from './unconfirmed-submit.js';
+/** Default HTTP timeout for a gasless submit (`execution.submitTimeoutMs`). @internal */
+export declare const GASLESS_SUBMIT_TIMEOUT_MS = 30000;
+/**
+ * How many times a submit the gateway itself refused (`429`, or a `503`
+ * carrying its `{ error }` envelope) is retried under the same idempotency key.
+ * Both mean the request never reached the service, so a retry cannot duplicate
+ * anything — the bound exists to keep a submit from outliving its caller.
+ *
+ * @internal
+ */
+export declare const GASLESS_SUBMIT_THROTTLE_RETRIES = 2;
+/** The response header the gateway stamps with the protocol instance that answered. @internal */
+export declare const GASLESS_PROTOCOL_INSTANCE_HEADER = "x-gaslessq-protocol-instance";
+/**
+ * A resolved gasless HTTP context for one `(chain, service)` pair: the final
+ * per-service base URL, the request headers, and the protocol instance the
+ * responses must come from.
+ *
+ * @internal
+ */
+export interface GaslessHttpContext {
+    /** Final service base, e.g. `…/v1/instances/<protocol-instance>/operations`. */
+    baseURL: string;
+    /** Request headers: `Accept`, plus `Authorization: Bearer …` only when an `apiKey` is configured. */
+    headers: Record<string, string>;
+    /**
+     * The protocol instance responses are asserted against, or `null` when the
+     * config names none (a proxy root without `protocolInstance`).
+     */
+    protocolInstance: string | null;
+    /**
+     * Whether a response must carry the instance header. `true` for the gateway
+     * URL forms, where the gateway itself stamps every routed response; `false`
+     * for a proxy root, which may not forward the header, so only a header that
+     * is present is checked.
+     */
+    requireInstanceHeader: boolean;
+    /** HTTP timeout applied to submits (POSTs), in ms. */
+    submitTimeoutMs: number;
+    /** The chain the context was resolved for (for error messages and events). */
+    chainId: number;
+}
+/**
+ * Derive the per-service base URL from a chain's gasless config.
+ *
+ * The `url` forms are parsed by `parseGaslessUrl`:
+ * - a gateway **origin** — the SDK appends
+ *   `/v1/instances/{protocolInstance}/{service}`;
+ * - an **instance root** — the SDK appends `/{service}`;
+ * - an instance-pinned **service base** — used as-is, and it must match the
+ *   requested service;
+ * - a **proxy root** — the SDK appends `/{service}`.
+ *
+ * @internal
+ */
+export declare function resolveGaslessHttp(config: Config, parameters: {
+    chainId?: number;
+    service: GaslessService;
+}): GaslessHttpContext;
+/**
+ * Build a {@link GaslessHttpContext} from an already-resolved gasless block.
+ *
+ * Anonymous access is the default: the `Authorization` header is omitted
+ * entirely unless a non-blank `apiKey` is configured.
+ *
+ * @internal
+ */
+export declare function buildGaslessHttpContext(chainId: number, gasless: SymmioGaslessConfig, service: GaslessService): GaslessHttpContext;
+/**
+ * Assert that a successful response came from the expected protocol instance.
+ * The gateway stamps `X-GasLessQ-Protocol-Instance` on every response it
+ * routes. A mismatch means a different deployment answered (a
+ * staging/production cross-wire), and the response must not be trusted.
+ *
+ * Gateway URL forms fail closed on a missing header too. A proxy root only
+ * fails on a header that is present and wrong, since a proxy may not forward
+ * it.
+ *
+ * @internal
+ * @throws {SymmError} `GASLESS_INSTANCE_MISMATCH`
+ */
+export declare function assertGaslessInstance(context: GaslessHttpContext, response: AxiosResponse): void;
+/**
+ * Whether an error is a `GASLESS_INSTANCE_MISMATCH` on a response the gateway
+ * **accepted** (a `2xx`) — the submit created a workflow somewhere, on a
+ * deployment this config does not address.
+ *
+ * Nothing about it can be trusted except that it happened, so it is never
+ * grounds for a wallet-paid retry, and any signature it consumed must be
+ * treated as spent.
+ *
+ * @internal
+ */
+export declare function isGaslessAcceptedInstanceMismatchError(err: unknown): boolean;
+/**
+ * Perform a gasless GET and normalize failures into the house error shape.
+ *
+ * @param context - The resolved HTTP context for the call's service.
+ * @param path - The path under the service base.
+ * @param code - The SDK error code a failure is reported under.
+ * @param options - `signal` cancels the request in flight — pass TanStack's
+ *   query signal, or the caller's own, so a poll nobody is waiting for stops
+ *   spending the deployment's shared request budget.
+ *
+ * @internal
+ */
+export declare function gaslessGet<data>(context: GaslessHttpContext, path: string, code: string, options?: {
+    signal?: AbortSignal;
+}): Promise<data>;
+/**
+ * How long to wait before resending a submit, whether the gateway refused it or
+ * its outcome is unknown.
+ *
+ * `Retry-After` is honored when the gateway sent one and the browser was
+ * allowed to read it, but never trusted as a floor of zero: a cross-origin page
+ * usually sees `null`, and hammering a throttled gateway is what earned the
+ * `429`. So the wait is at least a jittered second, and the jitter keeps a
+ * page's concurrent workflows from retrying in lockstep.
+ *
+ * @param retryAfterMs - The server's requested delay, or `null` when unknown.
+ * @param random - Injectable `Math.random`, for deterministic tests.
+ * @returns The delay in ms.
+ *
+ * @internal
+ */
+export declare function gaslessSubmitRetryDelay(retryAfterMs: number | null, random?: () => number): number;
+/**
+ * POST one gasless **submit** — the only gasless call that can leave a side
+ * effect behind when its response is lost — and decide, for every outcome,
+ * whether the service can have accepted it.
+ *
+ * Three dispositions, all under the caller's single idempotency key (the vendor
+ * returns the existing record for a byte-identical resend, so reusing the key
+ * can never double-execute; a *changed* payload needs a fresh one):
+ *
+ * - **Refused by the gateway** (`429`, or a `503` carrying its `{ error }`
+ *   envelope): the request never reached the service. Resent up to
+ *   {@link GASLESS_SUBMIT_THROTTLE_RETRIES} times after
+ *   {@link gaslessSubmitRetryDelay}, while the wait still fits inside
+ *   `execution.submitTimeoutMs`. Exhausted, the gateway's own error is thrown —
+ *   the one submit failure that is provably *not* accepted, and so the only one
+ *   a wallet-paid retry may follow.
+ * - **Ambiguous** (no response, a timeout, or a `5xx` without the gateway
+ *   envelope): the service may or may not have accepted it. Resent **once**,
+ *   after a {@link gaslessSubmitRetryDelay} backoff, then thrown as
+ *   `GASLESS_SUBMIT_UNCONFIRMED` carrying the exact bytes that were sent, so the
+ *   caller can persist them and replay them later with `resubmitGaslessRequest`.
+ *   Never a rejection, and never grounds for a wallet retry. The backoff is the
+ *   vendor's: a resend that races the first attempt's insert can be answered with
+ *   a `5xx` instead of the record that insert created.
+ * - **Answered** (any other status, or a `2xx`): thrown as-is, or returned. A
+ *   `2xx` without a `request_id` is unconfirmed too — the workflow exists and
+ *   nothing identifies it. A `2xx` from the wrong protocol instance throws
+ *   `GASLESS_INSTANCE_MISMATCH` with the parsed body kept in `responseData`,
+ *   because the `request_id` in it is the only handle on a request that was
+ *   accepted somewhere.
+ *
+ * An ambiguous attempt decides every failure after it. A gateway refusal of the
+ * resend, or a service verdict on it, describes only the resend — the first
+ * attempt may already be executing — so it is thrown as
+ * `GASLESS_SUBMIT_UNCONFIRMED` with that failure as its `cause`. Thrown as-is,
+ * a `429` would read as provably not accepted, and a wallet-paid retry would
+ * execute the intent twice.
+ *
+ * @param context - The resolved HTTP context for the submit's service.
+ * @param path - The submit route (see {@link GASLESS_SUBMIT_ROUTES}).
+ * @param body - The exact JSON body to send.
+ * @param idempotencyKey - The key inside `body`, recorded on an unconfirmed submit.
+ * @returns The acceptance body.
+ *
+ * @internal
+ */
+export declare function postGaslessSubmit<data extends {
+    request_id?: string | null;
+}>(context: GaslessHttpContext, path: GaslessSubmitPath, body: unknown, idempotencyKey: string): Promise<data>;
+/**
+ * The canonical 3-branch error normalization every gasless HTTP call shares.
+ *
+ * An axios failure becomes a `SymmApiError` whose `cause` is a sanitized
+ * snapshot (see `toSanitizedApiError`), never the axios error itself. That
+ * error's request config holds the `Authorization` header and the signed body,
+ * so the `apiKey` cannot leak through a logged or serialized error.
+ * `responseData` stays the raw response body.
+ *
+ * @internal
+ */
+export declare function toGaslessError(err: unknown, context: GaslessHttpContext, code: string): Error;
+/**
+ * How a failed gasless HTTP call was disposed of, from the status and, where
+ * the gateway overloads a status, from the body: the gateway's own
+ * `{ "error": "…" }` envelope versus a service `{ "detail": … }` body.
+ *
+ * - `"rate-limited"` — `429`: dropped at the gateway, never forwarded.
+ * - `"gateway-not-ready"` — `503` with the gateway envelope: its configuration is not ready.
+ * - `"unauthorized"` / `"forbidden"` — `401` / `403`: credentials rejected, or not allowed for this instance or service.
+ * - `"unknown-instance"` — `404` with the gateway envelope: no such instance or service route.
+ * - `"selector-conflict"` — `400` with the gateway envelope: the URL and the instance selector disagree.
+ * - `"client-schema"` — `422`: the service rejected the payload shape (a client bug).
+ * - `"ambiguous"` — no response (network failure or timeout), `408`, or any other `5xx`: the request may or may not have reached the service.
+ * - `"service"` — any other status: the service answered with its own verdict (`detail.code`).
+ *
+ * @internal
+ */
+export type GaslessHttpFailureClass = "rate-limited" | "gateway-not-ready" | "unauthorized" | "forbidden" | "unknown-instance" | "selector-conflict" | "client-schema" | "ambiguous" | "service";
+/**
+ * Classify a failed gasless HTTP call — see {@link GaslessHttpFailureClass}.
+ *
+ * The status is read structurally, so an error a framework layer re-wrapped
+ * (`@symmio/trading-react`'s `SymmioRequestError`, which copies `status` and
+ * `responseData`) classifies exactly like the `SymmApiError` underneath it.
+ *
+ * @param err - Anything caught from a gasless HTTP call.
+ * @returns The class, or `null` when `err` carries no HTTP status.
+ *
+ * @internal
+ */
+export declare function classifyGaslessHttpStatus(err: unknown): GaslessHttpFailureClass | null;
+/**
+ * Generate a random idempotency key for one gasless submit. Reuse the same key
+ * only when retrying the byte-identical request; any change to the payload
+ * needs a fresh key.
+ */
+export declare function generateGaslessIdempotencyKey(): string;
+//# sourceMappingURL=http.d.ts.map

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

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