@switch-win/sdk 1.2.1 → 1.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@switch-win/sdk",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "Official integration kit for the Switch DEX Aggregator on PulseChain and Robinhood Chain",
   "author": "BuildTheTech",
   "license": "MIT",
@@ -37,7 +37,8 @@
     "src/",
     "abi/",
     "README.md",
-    "ROBINHOOD.md"
+    "ROBINHOOD.md",
+    "LIMIT-ORDERS.md"
   ],
   "devDependencies": {
     "typescript": "^5.9.3"

package/src/index.ts

@@ -45,8 +45,9 @@ export type {
   CancelLimitOrderResponse,
   ListLimitOrdersResponse,
   LimitOrderPair,
-  LimitOrderStats,
-  LimitOrderMutationResponse,
+  LimitOrderStats,
+  LimitOrderConfigResponse,
+  LimitOrderMutationResponse,
 } from "./types.js";
 
 export { isErrorResponse } from "./types.js";
@@ -95,43 +96,54 @@ export {
 // Limit Order helpers
 export {
   buildLimitOrder,
-  getEIP712SigningParams,
+  getEIP712SigningParams,
+  getNetworkEIP712SigningParams,
+  getLimitOrderNetworkConfig,
+  getLimitOrderApprovalTarget,
   getApprovalTarget,
   getRouterApprovalTarget,
   shouldUnwrapOutput,
-  getPLSFlowAddress,
-  isNativePLS,
+  getPLSFlowAddress,
+  getNativeFlowAddress,
+  isNativePLS,
+  isNativeCurrency,
   submitLimitOrder,
   cancelLimitOrder,
   fetchLimitOrders,
   fetchLimitOrder,
-  fetchLimitOrderPairs,
-  fetchLimitOrderStats,
-} from "./limit-orders.js";
+  fetchLimitOrderPairs,
+  fetchLimitOrderConfig,
+  fetchLimitOrderStats,
+  LIMIT_ORDER_NETWORK_CONFIGS,
+} from "./limit-orders.js";
 
-export type {
+export type {
   BuildLimitOrderOptions,
   ListLimitOrdersOptions,
+  LimitOrderNetwork,
+  LimitOrderNetworkConfig,
+  LimitOrderNetworkOptions,
 } from "./limit-orders.js";
-
-// Network-specific swap configuration
-export {
-  ROBINHOOD_NETWORK,
-  ROBINHOOD_CHAIN,
+
+// Network-specific swap configuration
+export {
+  ROBINHOOD_NETWORK,
+  ROBINHOOD_CHAIN,
   ROBINHOOD_NATIVE_ETH,
+  ROBINHOOD_LIMIT_ORDER_EIP712_DOMAIN,
   ROBINHOOD_SWITCH_CONTRACTS,
-  ROBINHOOD_UNISWAP_CONTRACTS,
-  ROBINHOOD_TOKENS,
-  ROBINHOOD_FRONTEND_TOKEN_LIST,
-  ROBINHOOD_FRONTEND_DEFAULT_TOKENS,
-  ROBINHOOD_TRUSTED_INTERMEDIATES,
-  ROBINHOOD_FEE_TOKEN_PRIORITY,
-  selectRobinhoodFeeOnOutput,
-  buildRobinhoodQuoteUrl,
-} from "./networks/robinhood.js";
-
-export type {
-  RobinhoodToken,
-  RobinhoodQuoteParams,
-  RobinhoodTaxInfo,
-} from "./networks/robinhood.js";
+  ROBINHOOD_UNISWAP_CONTRACTS,
+  ROBINHOOD_TOKENS,
+  ROBINHOOD_FRONTEND_TOKEN_LIST,
+  ROBINHOOD_FRONTEND_DEFAULT_TOKENS,
+  ROBINHOOD_TRUSTED_INTERMEDIATES,
+  ROBINHOOD_FEE_TOKEN_PRIORITY,
+  selectRobinhoodFeeOnOutput,
+  buildRobinhoodQuoteUrl,
+} from "./networks/robinhood.js";
+
+export type {
+  RobinhoodToken,
+  RobinhoodQuoteParams,
+  RobinhoodTaxInfo,
+} from "./networks/robinhood.js";

package/src/limit-orders.ts

@@ -2,7 +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 cancelling EIP-712 signed limit orders on PulseChain and Robinhood
+ * Chain.
  *
  * ## How it works
  *
@@ -10,7 +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()` + notify backend with `cancelLimitOrder()`
+ * 5. **Cancel** an order on-chain via `invalidateNonce()`; the backend indexer
+ *    observes the cancellation event
  *
  * @example
  * ```ts
@@ -26,7 +28,8 @@ import type {
   ListLimitOrdersResponse,
   LimitOrderRecord,
   LimitOrderPair,
-  LimitOrderStats,
+  LimitOrderStats,
+  LimitOrderConfigResponse,
   LimitOrderStatus,
   ErrorResponse,
 } from "./types.js";
@@ -40,8 +43,15 @@ import {
   SWITCH_LIMIT_ORDER,
   SWITCH_ROUTER,
   SWITCH_PLS_FLOW,
-  WPLS,
-} from "./constants.js";
+  WPLS,
+  NATIVE_PLS,
+} from "./constants.js";
+import {
+  ROBINHOOD_CHAIN,
+  ROBINHOOD_NATIVE_ETH,
+  ROBINHOOD_SWITCH_CONTRACTS,
+  ROBINHOOD_TOKENS,
+} from "./networks/robinhood.js";
 
 // ── Re-export EIP-712 constants for convenience ─────────────────────────────
 
@@ -107,7 +117,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** → not supported (frontend blocks this)
+   * - **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
@@ -181,13 +192,16 @@ export function buildLimitOrder(options: BuildLimitOrderOptions): LimitOrderPara
  * const signature = await signer._signTypedData(domain, types, order);
  * ```
  */
-export function getEIP712SigningParams(limitOrderContract?: string) {
+export function getEIP712SigningParams(
+  limitOrderContract?: string,
+  chainId: number = 369,
+) {
   if (limitOrderContract) {
     return {
       domain: {
         name: "SwitchLimitOrder" as const,
         version: "2" as const,
-        chainId: 369 as const,
+        chainId,
         verifyingContract: limitOrderContract,
       },
       types: LIMIT_ORDER_EIP712_TYPES,
@@ -225,8 +239,8 @@ export function getApprovalTarget(limitOrderContract?: string): string {
  *
  * @returns The SwitchRouter contract address
  */
-export function getRouterApprovalTarget(): string {
-  return SWITCH_ROUTER;
+export function getRouterApprovalTarget(routerContract?: string): string {
+  return routerContract || SWITCH_ROUTER;
 }
 
 /**
@@ -235,12 +249,15 @@ export function getRouterApprovalTarget(): string {
  * Returns `true` only if `tokenOut` is WPLS (the output will be unwrapped
  * to native PLS by the contract).
  */
-export function shouldUnwrapOutput(tokenOut: string): boolean {
-  return tokenOut.toLowerCase() === WPLS.toLowerCase();
+export function shouldUnwrapOutput(
+  tokenOut: string,
+  wrappedNativeToken: string = WPLS,
+): boolean {
+  return tokenOut.toLowerCase() === wrappedNativeToken.toLowerCase();
 }
 
 // ═══════════════════════════════════════════════════════════════════════════════
-// PLSFlow (Native PLS Limit Orders)
+// Native-currency flow (SwitchPLSFlow ABI: PLS on PulseChain, ETH on Robinhood)
 // ═══════════════════════════════════════════════════════════════════════════════
 
 /**
@@ -251,9 +268,95 @@ export function shouldUnwrapOutput(tokenOut: string): boolean {
  *
  * @returns The SwitchPLSFlow contract address
  */
-export function getPLSFlowAddress(): string {
-  return SWITCH_PLS_FLOW;
-}
+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).
@@ -264,10 +367,27 @@ export function getPLSFlowAddress(): 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;
+}
 
 // ═══════════════════════════════════════════════════════════════════════════════
 // API Helpers
@@ -292,7 +412,7 @@ export function isNativePLS(tokenIn: string): boolean {
  * 4. Do **not** navigate away or close the signing flow until the
  *    backend confirms the order.
  *
- * PLSFlow (native PLS) 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.
  *
@@ -312,10 +432,11 @@ export function isNativePLS(tokenIn: string): boolean {
  * }
  * ```
  */
-export async function submitLimitOrder(
-  signedOrder: SignedLimitOrder,
-): Promise<CreateLimitOrderResponse | ErrorResponse> {
-  const res = await fetch(LIMIT_ORDERS_ENDPOINT, {
+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),
@@ -325,22 +446,24 @@ export async function submitLimitOrder(
 }
 
 /**
- * Cancel a limit order on the Switch backend (marks it CANCELLED in the DB).
- *
- * **Important:** This only removes the order from the backend orderbook. To
- * prevent the order from being filled on-chain, you MUST also call
- * `invalidateNonce(nonce)` on the SwitchLimitOrder contract. See the
- * cancellation guide in the README.
+ * 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
+ * @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,
-): Promise<CancelLimitOrderResponse | ErrorResponse> {
-  const res = await fetch(LIMIT_ORDERS_ENDPOINT, {
+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 }),
@@ -350,7 +473,9 @@ export async function cancelLimitOrder(
 }
 
 /** Filter options for listing limit orders */
-export interface ListLimitOrdersOptions {
+export interface ListLimitOrdersOptions {
+  /** Backend network process to query. */
+  network?: LimitOrderNetwork;
   /** Filter by order status. Default: `"ACTIVE"` */
   status?: LimitOrderStatus;
   /** Filter by maker address */
@@ -415,7 +540,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.offset != null) params.set("offset", String(options.offset));
+  if (options.network) params.set("network", options.network);
 
   const url = params.toString()
     ? `${LIMIT_ORDERS_ENDPOINT}?${params}`
@@ -432,11 +558,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,
-): Promise<LimitOrderRecord | ErrorResponse> {
-  const res = await fetch(`${LIMIT_ORDERS_ENDPOINT}/${maker}/${nonce}`);
+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>;
 }
 
@@ -445,17 +574,34 @@ export async function fetchLimitOrder(
  *
  * Useful for displaying which token pairs have open limit orders.
  */
-export async function fetchLimitOrderPairs(): Promise<LimitOrderPair[]> {
-  const res = await fetch(LIMIT_ORDER_PAIRS_ENDPOINT);
+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 summary statistics for all limit orders.
  *
  * Returns counts of active, filled, cancelled, and expired orders.
  */
-export async function fetchLimitOrderStats(): Promise<LimitOrderStats> {
-  const res = await fetch(LIMIT_ORDER_STATS_ENDPOINT);
+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>;
 }

package/src/networks/index.ts

@@ -1,20 +1,21 @@
-export {
-  ROBINHOOD_NETWORK,
-  ROBINHOOD_CHAIN,
+export {
+  ROBINHOOD_NETWORK,
+  ROBINHOOD_CHAIN,
   ROBINHOOD_NATIVE_ETH,
+  ROBINHOOD_LIMIT_ORDER_EIP712_DOMAIN,
   ROBINHOOD_SWITCH_CONTRACTS,
-  ROBINHOOD_UNISWAP_CONTRACTS,
-  ROBINHOOD_TOKENS,
-  ROBINHOOD_FRONTEND_TOKEN_LIST,
-  ROBINHOOD_FRONTEND_DEFAULT_TOKENS,
-  ROBINHOOD_TRUSTED_INTERMEDIATES,
-  ROBINHOOD_FEE_TOKEN_PRIORITY,
-  selectRobinhoodFeeOnOutput,
-  buildRobinhoodQuoteUrl,
-} from "./robinhood.js";
-
-export type {
-  RobinhoodToken,
-  RobinhoodQuoteParams,
-  RobinhoodTaxInfo,
-} from "./robinhood.js";
+  ROBINHOOD_UNISWAP_CONTRACTS,
+  ROBINHOOD_TOKENS,
+  ROBINHOOD_FRONTEND_TOKEN_LIST,
+  ROBINHOOD_FRONTEND_DEFAULT_TOKENS,
+  ROBINHOOD_TRUSTED_INTERMEDIATES,
+  ROBINHOOD_FEE_TOKEN_PRIORITY,
+  selectRobinhoodFeeOnOutput,
+  buildRobinhoodQuoteUrl,
+} from "./robinhood.js";
+
+export type {
+  RobinhoodToken,
+  RobinhoodQuoteParams,
+  RobinhoodTaxInfo,
+} from "./robinhood.js";