@switch-win/sdk 1.2.9 → 1.3.1

package/src/limit-orders.ts

@@ -2,8 +2,8 @@
  * Switch Limit Orders (V2) — Helper Functions
  *
  * Provides a complete toolkit for creating, signing, submitting, querying,
- * and cancelling EIP-712 signed limit orders on PulseChain and Robinhood
- * Chain.
+ * and cancelling EIP-712 signed limit orders on PulseChain and Robinhood
+ * Chain.
  *
  * ## How it works
  *
@@ -11,8 +11,8 @@
  * 2. **Sign** via EIP-712 with your wallet (ethers.js `signTypedData`)
  * 3. **Submit** the signed order to the Switch backend with `submitLimitOrder()`
  * 4. The Switch filler bot monitors active orders and fills them when profitable
- * 5. **Cancel** an order on-chain via `invalidateNonce()`; the backend indexer
- *    observes the cancellation event
+ * 5. **Cancel** an order on-chain via `invalidateNonce()`; the backend indexer
+ *    observes the cancellation event
  *
  * @example
  * ```ts
@@ -28,8 +28,8 @@ import type {
   ListLimitOrdersResponse,
   LimitOrderRecord,
   LimitOrderPair,
-  LimitOrderStats,
-  LimitOrderConfigResponse,
+  LimitOrderStats,
+  LimitOrderConfigResponse,
   LimitOrderStatus,
   ErrorResponse,
 } from "./types.js";
@@ -43,15 +43,21 @@ import {
   SWITCH_LIMIT_ORDER,
   SWITCH_ROUTER,
   SWITCH_PLS_FLOW,
-  WPLS,
-  NATIVE_PLS,
-} from "./constants.js";
-import {
-  ROBINHOOD_CHAIN,
-  ROBINHOOD_NATIVE_ETH,
-  ROBINHOOD_SWITCH_CONTRACTS,
-  ROBINHOOD_TOKENS,
-} from "./networks/robinhood.js";
+  WPLS,
+  NATIVE_PLS,
+} from "./constants.js";
+import {
+  ROBINHOOD_CHAIN,
+  ROBINHOOD_NATIVE_ETH,
+  ROBINHOOD_SWITCH_CONTRACTS,
+  ROBINHOOD_TOKENS,
+} from "./networks/robinhood.js";
+import { GASLESS_DEPLOYMENTS, GASLESS_LEGACY_CONTRACTS } from "./gasless.js";
+
+const gaslessContracts = new Set([
+  ...Object.values(GASLESS_DEPLOYMENTS).map(deployment => deployment.contract),
+  ...Object.values(GASLESS_LEGACY_CONTRACTS).flat(),
+].map(address => address.toLowerCase()));
 
 // ── Re-export EIP-712 constants for convenience ─────────────────────────────
 
@@ -117,8 +123,8 @@ export interface BuildLimitOrderOptions {
    *   one tax. Avoids the double sell-tax of maker → LO → pool.)
    * - **Tax output token** → set `feeOnOutput: false` (default)
    *   (Output goes directly to recipient in one transfer.)
-   * - **Both tokens tax** → use `feeOnOutput: false`; execution is restricted
-   *   to tax-compatible Uniswap V2 routing.
+   * - **Both tokens tax** → use `feeOnOutput: false`; execution is restricted
+   *   to tax-compatible Uniswap V2 routing.
    *
    * **Bottom line:** Use `feeOnOutput: false` (default) unless the input
    * token is a tax token. This gives operators maximum flexibility and
@@ -192,16 +198,19 @@ export function buildLimitOrder(options: BuildLimitOrderOptions): LimitOrderPara
  * const signature = await signer._signTypedData(domain, types, order);
  * ```
  */
-export function getEIP712SigningParams(
-  limitOrderContract?: string,
-  chainId: number = 369,
-) {
+export function getEIP712SigningParams(
+  limitOrderContract?: string,
+  chainId: number = 369,
+) {
+  if (limitOrderContract && gaslessContracts.has(limitOrderContract.toLowerCase())) {
+    throw new Error("GaslessSwitch requires its dedicated signing domain. Use getGaslessSigningParams() for V2.");
+  }
   if (limitOrderContract) {
     return {
       domain: {
         name: "SwitchLimitOrder" as const,
         version: "2" as const,
-        chainId,
+        chainId,
         verifyingContract: limitOrderContract,
       },
       types: LIMIT_ORDER_EIP712_TYPES,
@@ -239,8 +248,8 @@ export function getApprovalTarget(limitOrderContract?: string): string {
  *
  * @returns The SwitchRouter contract address
  */
-export function getRouterApprovalTarget(routerContract?: string): string {
-  return routerContract || SWITCH_ROUTER;
+export function getRouterApprovalTarget(routerContract?: string): string {
+  return routerContract || SWITCH_ROUTER;
 }
 
 /**
@@ -249,15 +258,15 @@ export function getRouterApprovalTarget(routerContract?: string): string {
  * Returns `true` only if `tokenOut` is WPLS (the output will be unwrapped
  * to native PLS by the contract).
  */
-export function shouldUnwrapOutput(
-  tokenOut: string,
-  wrappedNativeToken: string = WPLS,
-): boolean {
-  return tokenOut.toLowerCase() === wrappedNativeToken.toLowerCase();
+export function shouldUnwrapOutput(
+  tokenOut: string,
+  wrappedNativeToken: string = WPLS,
+): boolean {
+  return tokenOut.toLowerCase() === wrappedNativeToken.toLowerCase();
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// Native-currency flow (SwitchPLSFlow ABI: PLS on PulseChain, ETH on Robinhood)
+// Native-currency flow (SwitchPLSFlow ABI: PLS on PulseChain, ETH on Robinhood)
 // ═══════════════════════════════════════════════════════════════════════════════
 
 /**
@@ -268,95 +277,95 @@ export function shouldUnwrapOutput(
  *
  * @returns The SwitchPLSFlow contract address
  */
-export function getPLSFlowAddress(nativeFlowContract?: string): string {
-  return nativeFlowContract || SWITCH_PLS_FLOW;
-}
-
-/** Networks supported by the shared Switch limit-order API. */
-export type LimitOrderNetwork = "pulsechain" | "robinhood";
-
-/** Complete deployment metadata needed to create or fill limit orders. */
-export interface LimitOrderNetworkConfig {
-  network: LimitOrderNetwork;
-  chainId: number;
-  chainName: string;
-  nativeSymbol: "PLS" | "ETH";
-  nativeSentinel: string;
-  wrappedNativeToken: string;
-  routerContract: string;
-  limitOrderContract: string;
-  nativeFlowContract: string;
-}
-
-/** Static defaults. Prefer {@link fetchLimitOrderConfig} at application startup. */
-export const LIMIT_ORDER_NETWORK_CONFIGS: Readonly<
-  Record<LimitOrderNetwork, LimitOrderNetworkConfig>
-> = {
-  pulsechain: {
-    network: "pulsechain",
-    chainId: 369,
-    chainName: "PulseChain",
-    nativeSymbol: "PLS",
-    nativeSentinel: NATIVE_PLS,
-    wrappedNativeToken: WPLS,
-    routerContract: SWITCH_ROUTER,
-    limitOrderContract: SWITCH_LIMIT_ORDER,
-    nativeFlowContract: SWITCH_PLS_FLOW,
-  },
-  robinhood: {
-    network: "robinhood",
-    chainId: ROBINHOOD_CHAIN.id,
-    chainName: ROBINHOOD_CHAIN.name,
-    nativeSymbol: "ETH",
-    nativeSentinel: ROBINHOOD_NATIVE_ETH,
-    wrappedNativeToken: ROBINHOOD_TOKENS.WETH.address,
-    routerContract: ROBINHOOD_SWITCH_CONTRACTS.router,
-    limitOrderContract: ROBINHOOD_SWITCH_CONTRACTS.limitOrder,
-    nativeFlowContract: ROBINHOOD_SWITCH_CONTRACTS.nativeEthFlow,
-  },
-} as const;
-
-/** Return the static deployment defaults for a supported limit-order network. */
-export function getLimitOrderNetworkConfig(
-  network: LimitOrderNetwork = "pulsechain",
-): LimitOrderNetworkConfig {
-  return LIMIT_ORDER_NETWORK_CONFIGS[network];
-}
-
-/** Build the correct EIP-712 signing domain for a supported network. */
-export function getNetworkEIP712SigningParams(
-  network: LimitOrderNetwork,
-  limitOrderContract?: string,
-) {
-  const config = getLimitOrderNetworkConfig(network);
-  return getEIP712SigningParams(
-    limitOrderContract ?? config.limitOrderContract,
-    config.chainId,
-  );
-}
-
-/** Resolve the maker's ERC-20 approval target for the selected fee mode. */
-export function getLimitOrderApprovalTarget(
-  network: LimitOrderNetwork,
-  feeOnOutput: boolean,
-  overrides: { limitOrderContract?: string; routerContract?: string } = {},
-): string {
-  const config = getLimitOrderNetworkConfig(network);
-  return feeOnOutput
-    ? getRouterApprovalTarget(overrides.routerContract ?? config.routerContract)
-    : getApprovalTarget(overrides.limitOrderContract ?? config.limitOrderContract);
-}
-
-export interface LimitOrderNetworkOptions {
-  network?: LimitOrderNetwork;
-}
-
-function endpointForNetwork(endpoint: string, network?: string): string {
-  if (!network) return endpoint;
-  const url = new URL(endpoint);
-  url.searchParams.set("network", network);
-  return url.toString();
-}
+export function getPLSFlowAddress(nativeFlowContract?: string): string {
+  return nativeFlowContract || SWITCH_PLS_FLOW;
+}
+
+/** Networks supported by the shared Switch limit-order API. */
+export type LimitOrderNetwork = "pulsechain" | "robinhood";
+
+/** Complete deployment metadata needed to create or fill limit orders. */
+export interface LimitOrderNetworkConfig {
+  network: LimitOrderNetwork;
+  chainId: number;
+  chainName: string;
+  nativeSymbol: "PLS" | "ETH";
+  nativeSentinel: string;
+  wrappedNativeToken: string;
+  routerContract: string;
+  limitOrderContract: string;
+  nativeFlowContract: string;
+}
+
+/** Static defaults. Prefer {@link fetchLimitOrderConfig} at application startup. */
+export const LIMIT_ORDER_NETWORK_CONFIGS: Readonly<
+  Record<LimitOrderNetwork, LimitOrderNetworkConfig>
+> = {
+  pulsechain: {
+    network: "pulsechain",
+    chainId: 369,
+    chainName: "PulseChain",
+    nativeSymbol: "PLS",
+    nativeSentinel: NATIVE_PLS,
+    wrappedNativeToken: WPLS,
+    routerContract: SWITCH_ROUTER,
+    limitOrderContract: SWITCH_LIMIT_ORDER,
+    nativeFlowContract: SWITCH_PLS_FLOW,
+  },
+  robinhood: {
+    network: "robinhood",
+    chainId: ROBINHOOD_CHAIN.id,
+    chainName: ROBINHOOD_CHAIN.name,
+    nativeSymbol: "ETH",
+    nativeSentinel: ROBINHOOD_NATIVE_ETH,
+    wrappedNativeToken: ROBINHOOD_TOKENS.WETH.address,
+    routerContract: ROBINHOOD_SWITCH_CONTRACTS.router,
+    limitOrderContract: ROBINHOOD_SWITCH_CONTRACTS.limitOrder,
+    nativeFlowContract: ROBINHOOD_SWITCH_CONTRACTS.nativeEthFlow,
+  },
+} as const;
+
+/** Return the static deployment defaults for a supported limit-order network. */
+export function getLimitOrderNetworkConfig(
+  network: LimitOrderNetwork = "pulsechain",
+): LimitOrderNetworkConfig {
+  return LIMIT_ORDER_NETWORK_CONFIGS[network];
+}
+
+/** Build the correct EIP-712 signing domain for a supported network. */
+export function getNetworkEIP712SigningParams(
+  network: LimitOrderNetwork,
+  limitOrderContract?: string,
+) {
+  const config = getLimitOrderNetworkConfig(network);
+  return getEIP712SigningParams(
+    limitOrderContract ?? config.limitOrderContract,
+    config.chainId,
+  );
+}
+
+/** Resolve the maker's ERC-20 approval target for the selected fee mode. */
+export function getLimitOrderApprovalTarget(
+  network: LimitOrderNetwork,
+  feeOnOutput: boolean,
+  overrides: { limitOrderContract?: string; routerContract?: string } = {},
+): string {
+  const config = getLimitOrderNetworkConfig(network);
+  return feeOnOutput
+    ? getRouterApprovalTarget(overrides.routerContract ?? config.routerContract)
+    : getApprovalTarget(overrides.limitOrderContract ?? config.limitOrderContract);
+}
+
+export interface LimitOrderNetworkOptions {
+  network?: LimitOrderNetwork;
+}
+
+function endpointForNetwork(endpoint: string, network?: string): string {
+  if (!network) return endpoint;
+  const url = new URL(endpoint);
+  url.searchParams.set("network", network);
+  return url.toString();
+}
 
 /**
  * Check if the input token is native PLS (should use PLSFlow instead of EIP-712).
@@ -367,27 +376,27 @@ function endpointForNetwork(endpoint: string, network?: string): string {
  * @param tokenIn - The input token address
  * @returns `true` if tokenIn is the native PLS sentinel address
  */
-export function isNativePLS(tokenIn: string): boolean {
+export function isNativePLS(tokenIn: string): boolean {
   const NATIVE_SENTINEL = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
   return tokenIn.toLowerCase() === NATIVE_SENTINEL.toLowerCase();
-}
-
-/** Network-neutral native-currency sentinel check (PLS or ETH). */
-export function isNativeCurrency(tokenIn: string): boolean {
-  const normalized = tokenIn.toLowerCase();
-  return (
-    normalized === NATIVE_PLS.toLowerCase() ||
-    normalized === ROBINHOOD_NATIVE_ETH.toLowerCase()
-  );
-}
-
-/** Return the native-order flow contract for PulseChain or Robinhood Chain. */
-export function getNativeFlowAddress(
-  network: LimitOrderNetwork,
-  nativeFlowContract?: string,
-): string {
-  return nativeFlowContract ?? getLimitOrderNetworkConfig(network).nativeFlowContract;
-}
+}
+
+/** Network-neutral native-currency sentinel check (PLS or ETH). */
+export function isNativeCurrency(tokenIn: string): boolean {
+  const normalized = tokenIn.toLowerCase();
+  return (
+    normalized === NATIVE_PLS.toLowerCase() ||
+    normalized === ROBINHOOD_NATIVE_ETH.toLowerCase()
+  );
+}
+
+/** Return the native-order flow contract for PulseChain or Robinhood Chain. */
+export function getNativeFlowAddress(
+  network: LimitOrderNetwork,
+  nativeFlowContract?: string,
+): string {
+  return nativeFlowContract ?? getLimitOrderNetworkConfig(network).nativeFlowContract;
+}
 
 // ═══════════════════════════════════════════════════════════════════════════════
 // API Helpers
@@ -407,12 +416,14 @@ export function getNativeFlowAddress(
  * 1. Call `submitLimitOrder()` **immediately** after the user signs.
  * 2. **Await** the response and verify `success: true` before showing
  *    the order as "created" in your UI.
- * 3. If the POST fails, **retry** automatically (the backend is
- *    idempotent on `maker + nonce`, so retries are safe).
+ * 3. If the POST fails, first query the same maker + nonce and verify its
+ *    contract and every signed field. The backend rejects duplicate nonces;
+ *    it does not return an idempotent success. Retry only the identical payload,
+ *    preserving its nonce and signature while the order is still live.
  * 4. Do **not** navigate away or close the signing flow until the
  *    backend confirms the order.
  *
- * Native PLS/ETH flow orders are an exception — they are recorded
+ * Native PLS/ETH flow orders are an exception — they are recorded
  * on-chain first, so the backend can discover them via event indexing
  * even if the POST never arrives.
  *
@@ -432,11 +443,11 @@ export function getNativeFlowAddress(
  * }
  * ```
  */
-export async function submitLimitOrder(
-  signedOrder: SignedLimitOrder,
-  options: LimitOrderNetworkOptions = {},
-): Promise<CreateLimitOrderResponse | ErrorResponse> {
-  const res = await fetch(endpointForNetwork(LIMIT_ORDERS_ENDPOINT, options.network), {
+export async function submitLimitOrder(
+  signedOrder: SignedLimitOrder,
+  options: LimitOrderNetworkOptions = {},
+): Promise<CreateLimitOrderResponse | ErrorResponse> {
+  const res = await fetch(endpointForNetwork(LIMIT_ORDERS_ENDPOINT, options.network), {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify(signedOrder),
@@ -446,24 +457,24 @@ export async function submitLimitOrder(
 }
 
 /**
- * Legacy helper for backend deployments that implemented REST cancellation.
- *
- * The current hosted Switch API intentionally has no DELETE endpoint.
- * Cancellation must be performed on-chain with `invalidateNonce(nonce)` on
- * the contract stored in the order's `limitOrderContract` field. The indexer
- * then updates the order status from the emitted event.
+ * Legacy helper for backend deployments that implemented REST cancellation.
+ *
+ * The current hosted Switch API intentionally has no DELETE endpoint.
+ * Cancellation must be performed on-chain with `invalidateNonce(nonce)` on
+ * the contract stored in the order's `limitOrderContract` field. The indexer
+ * then updates the order status from the emitted event.
  *
  * @param maker - Maker address
  * @param nonce - Nonce of the order to cancel
- * @returns Success confirmation or error on compatible legacy backends
- * @deprecated Do not use with the hosted Switch API; cancel on-chain instead.
+ * @returns Success confirmation or error on compatible legacy backends
+ * @deprecated Do not use with the hosted Switch API; cancel on-chain instead.
  */
-export async function cancelLimitOrder(
-  maker: string,
-  nonce: number,
-  options: LimitOrderNetworkOptions = {},
-): Promise<CancelLimitOrderResponse | ErrorResponse> {
-  const res = await fetch(endpointForNetwork(LIMIT_ORDERS_ENDPOINT, options.network), {
+export async function cancelLimitOrder(
+  maker: string,
+  nonce: number,
+  options: LimitOrderNetworkOptions = {},
+): Promise<CancelLimitOrderResponse | ErrorResponse> {
+  const res = await fetch(endpointForNetwork(LIMIT_ORDERS_ENDPOINT, options.network), {
     method: "DELETE",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ maker, nonce }),
@@ -473,9 +484,9 @@ export async function cancelLimitOrder(
 }
 
 /** Filter options for listing limit orders */
-export interface ListLimitOrdersOptions {
-  /** Backend network process to query. */
-  network?: LimitOrderNetwork;
+export interface ListLimitOrdersOptions {
+  /** Backend network process to query. */
+  network?: LimitOrderNetwork;
   /** Filter by order status. Default: `"ACTIVE"` */
   status?: LimitOrderStatus;
   /** Filter by maker address */
@@ -540,8 +551,8 @@ export async function fetchLimitOrders(
   if (options.tokenOut) params.set("tokenOut", options.tokenOut);
   if (options.pair)     params.set("pair", options.pair);
   if (options.limit != null)  params.set("limit", String(options.limit));
-  if (options.offset != null) params.set("offset", String(options.offset));
-  if (options.network) params.set("network", options.network);
+  if (options.offset != null) params.set("offset", String(options.offset));
+  if (options.network) params.set("network", options.network);
 
   const url = params.toString()
     ? `${LIMIT_ORDERS_ENDPOINT}?${params}`
@@ -558,14 +569,14 @@ export async function fetchLimitOrders(
  * @param nonce - Order nonce
  * @returns The order record, or an error if not found
  */
-export async function fetchLimitOrder(
-  maker: string,
-  nonce: number,
-  options: LimitOrderNetworkOptions = {},
-): Promise<LimitOrderRecord | ErrorResponse> {
-  const res = await fetch(
-    endpointForNetwork(`${LIMIT_ORDERS_ENDPOINT}/${maker}/${nonce}`, options.network),
-  );
+export async function fetchLimitOrder(
+  maker: string,
+  nonce: number,
+  options: LimitOrderNetworkOptions = {},
+): Promise<LimitOrderRecord | ErrorResponse> {
+  const res = await fetch(
+    endpointForNetwork(`${LIMIT_ORDERS_ENDPOINT}/${maker}/${nonce}`, options.network),
+  );
   return res.json() as Promise<LimitOrderRecord | ErrorResponse>;
 }
 
@@ -574,34 +585,34 @@ export async function fetchLimitOrder(
  *
  * Useful for displaying which token pairs have open limit orders.
  */
-export async function fetchLimitOrderPairs(
-  options: LimitOrderNetworkOptions = {},
-): Promise<LimitOrderPair[]> {
-  const res = await fetch(endpointForNetwork(LIMIT_ORDER_PAIRS_ENDPOINT, options.network));
+export async function fetchLimitOrderPairs(
+  options: LimitOrderNetworkOptions = {},
+): Promise<LimitOrderPair[]> {
+  const res = await fetch(endpointForNetwork(LIMIT_ORDER_PAIRS_ENDPOINT, options.network));
   return res.json() as Promise<LimitOrderPair[]>;
-}
-
-/** Fetch the active deployment and EIP-712 domain for a network. */
-export async function fetchLimitOrderConfig(
-  options: LimitOrderNetworkOptions = {},
-): Promise<LimitOrderConfigResponse> {
-  const res = await fetch(
-    endpointForNetwork(`${LIMIT_ORDERS_ENDPOINT}/config`, options.network),
-  );
-  if (!res.ok) {
-    throw new Error(`Failed to fetch limit-order config (${res.status})`);
-  }
-  return res.json() as Promise<LimitOrderConfigResponse>;
-}
+}
+
+/** Fetch the active deployment and EIP-712 domain for a network. */
+export async function fetchLimitOrderConfig(
+  options: LimitOrderNetworkOptions = {},
+): Promise<LimitOrderConfigResponse> {
+  const res = await fetch(
+    endpointForNetwork(`${LIMIT_ORDERS_ENDPOINT}/config`, options.network),
+  );
+  if (!res.ok) {
+    throw new Error(`Failed to fetch limit-order config (${res.status})`);
+  }
+  return res.json() as Promise<LimitOrderConfigResponse>;
+}
 
 /**
  * Fetch summary statistics for all limit orders.
  *
  * Returns counts of active, filled, cancelled, and expired orders.
  */
-export async function fetchLimitOrderStats(
-  options: LimitOrderNetworkOptions = {},
-): Promise<LimitOrderStats> {
-  const res = await fetch(endpointForNetwork(LIMIT_ORDER_STATS_ENDPOINT, options.network));
+export async function fetchLimitOrderStats(
+  options: LimitOrderNetworkOptions = {},
+): Promise<LimitOrderStats> {
+  const res = await fetch(endpointForNetwork(LIMIT_ORDER_STATS_ENDPOINT, options.network));
   return res.json() as Promise<LimitOrderStats>;
 }