@switch-win/sdk 1.2.9 → 1.3.1

package/dist/limit-orders.d.ts

@@ -0,0 +1,440 @@
+/**
+ * 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.
+ *
+ * ## How it works
+ *
+ * 1. **Build** order parameters with `buildLimitOrder()`
+ * 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
+ *
+ * @example
+ * ```ts
+ * import { buildLimitOrder, submitLimitOrder, fetchLimitOrders } from "@switch-win/sdk/limit-orders";
+ * ```
+ */
+import type { LimitOrderParams, SignedLimitOrder, CreateLimitOrderResponse, CancelLimitOrderResponse, ListLimitOrdersResponse, LimitOrderRecord, LimitOrderPair, LimitOrderStats, LimitOrderConfigResponse, LimitOrderStatus, ErrorResponse } from "./types.js";
+export { LIMIT_ORDER_EIP712_DOMAIN, LIMIT_ORDER_EIP712_TYPES } from "./constants.js";
+/** Options for building a limit order */
+export interface BuildLimitOrderOptions {
+    /** Maker (signer) address */
+    maker: string;
+    /** Input token address (token being sold) */
+    tokenIn: string;
+    /** Output token address (token being bought) */
+    tokenOut: string;
+    /** Amount of tokenIn to sell (wei string) */
+    amountIn: string;
+    /** Minimum amount of tokenOut to accept (wei string) */
+    minAmountOut: string;
+    /**
+     * Order expiry as a Unix timestamp. Defaults to `0` (no expiry).
+     * Tip: use `Math.floor(Date.now() / 1000) + 86400` for 24-hour expiry.
+     */
+    deadline?: number;
+    /**
+     * Unique nonce. Defaults to `Date.now()` (milliseconds) which is
+     * practically unique for a single maker. You can also use a random integer.
+     */
+    nonce?: number;
+    /**
+     * Fee mode — `true` to take fee from output, `false` from input. Default `false`.
+     *
+     * This choice is **permanent once signed** and has two major effects:
+     *
+     * ### 1. Determines the approval target
+     *
+     * | `feeOnOutput` | Maker must approve | Helper |
+     * |---|---|---|
+     * | `false` (default) | **SwitchLimitOrder** | `getApprovalTarget()` |
+     * | `true` | **SwitchRouter** | `getRouterApprovalTarget()` |
+     *
+     * ### 2. Constrains how operators (fillers) can take profit
+     *
+     * When `feeOnOutput=false`, the LO contract holds all input tokens
+     * after pulling them from the maker. Operators can freely choose to
+     * take their profit from either the input side or the output side.
+     *
+     * When `feeOnOutput=true`, the Router pulls tokens directly from the
+     * maker. If an operator also wants to take excess *input* tokens,
+     * the LO contract would need a **second** approval (from the maker
+     * to the LO contract) — which the maker typically hasn't granted.
+     * This means operators are effectively limited to taking profit
+     * from the output side only. The order is still fully fillable,
+     * but operators have less flexibility. In low-liquidity or
+     * tight-margin situations, this could reduce the chance of a fill.
+     *
+     * ### 3. Tax (fee-on-transfer) token guidelines
+     *
+     * - **Tax input token** → set `feeOnOutput: true`
+     *   (Router sends tokens directly from maker to pool — one transfer,
+     *   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.
+     *
+     * **Bottom line:** Use `feeOnOutput: false` (default) unless the input
+     * token is a tax token. This gives operators maximum flexibility and
+     * the best chance of your order being filled.
+     */
+    feeOnOutput?: boolean;
+    /**
+     * Recipient address for the output tokens. Defaults to the maker address.
+     * Set to a different address to send output to another wallet.
+     */
+    recipient?: string;
+    /**
+     * If `true` and tokenOut is WPLS, the contract unwraps to native PLS
+     * before sending to the recipient. Default `false`.
+     */
+    unwrapOutput?: boolean;
+    /**
+     * Partner address to receive 50% of protocol fees.
+     * Defaults to the zero address (no partner).
+     */
+    partnerAddress?: string;
+}
+/**
+ * Build a `LimitOrderParams` object ready for EIP-712 signing.
+ *
+ * @param options - Order parameters
+ * @returns A fully-populated `LimitOrderParams` object
+ *
+ * @example
+ * ```ts
+ * const order = buildLimitOrder({
+ *   maker: "0xYourAddress",
+ *   tokenIn: WPLS,
+ *   tokenOut: "0xPLSXAddress",
+ *   amountIn: ethers.parseUnits("1000", 18).toString(),
+ *   minAmountOut: ethers.parseUnits("500000", 18).toString(),
+ * });
+ * ```
+ */
+export declare function buildLimitOrder(options: BuildLimitOrderOptions): LimitOrderParams;
+/**
+ * Get the EIP-712 domain and types needed for signing a limit order.
+ *
+ * Pass the returned values directly to your wallet's `signTypedData` method.
+ *
+ * @example
+ * ```ts
+ * // ethers.js v6
+ * const { domain, types } = getEIP712SigningParams();
+ * const signature = await signer.signTypedData(domain, types, order);
+ *
+ * // ethers.js v5
+ * const signature = await signer._signTypedData(domain, types, order);
+ * ```
+ */
+export declare function getEIP712SigningParams(limitOrderContract?: string, chainId?: number): {
+    readonly domain: {
+        readonly name: "SwitchLimitOrder";
+        readonly version: "2";
+        readonly chainId: number;
+        readonly verifyingContract: string;
+    };
+    readonly types: {
+        readonly LimitOrder: readonly [{
+            readonly name: "maker";
+            readonly type: "address";
+        }, {
+            readonly name: "tokenIn";
+            readonly type: "address";
+        }, {
+            readonly name: "tokenOut";
+            readonly type: "address";
+        }, {
+            readonly name: "amountIn";
+            readonly type: "uint256";
+        }, {
+            readonly name: "minAmountOut";
+            readonly type: "uint256";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly name: "feeOnOutput";
+            readonly type: "bool";
+        }, {
+            readonly name: "recipient";
+            readonly type: "address";
+        }, {
+            readonly name: "unwrapOutput";
+            readonly type: "bool";
+        }, {
+            readonly name: "partnerAddress";
+            readonly type: "address";
+        }];
+    };
+};
+/**
+ * Get the approval target for `feeOnOutput: false` orders (the default).
+ *
+ * When `feeOnOutput` is `false`, the **SwitchLimitOrder** contract pulls
+ * tokens from the maker via `safeTransferFrom`, then forwards them to the
+ * router internally. The maker must `approve(SWITCH_LIMIT_ORDER, amountIn)`.
+ *
+ * For `feeOnOutput: true` orders, use {@link getRouterApprovalTarget} instead.
+ *
+ * @returns The SwitchLimitOrder contract address
+ */
+export declare function getApprovalTarget(limitOrderContract?: string): string;
+/**
+ * Get the approval target for `feeOnOutput: true` orders.
+ *
+ * When `feeOnOutput` is `true`, the **SwitchRouter** pulls tokens directly
+ * from the maker via `goSwitchFrom` (one transfer, one tax — ideal for tax
+ * input tokens). The maker must `approve(SWITCH_ROUTER, amountIn)`.
+ *
+ * For `feeOnOutput: false` orders (default), use {@link getApprovalTarget} instead.
+ *
+ * @returns The SwitchRouter contract address
+ */
+export declare function getRouterApprovalTarget(routerContract?: string): string;
+/**
+ * Determine whether `unwrapOutput` should be set for a given output token.
+ *
+ * Returns `true` only if `tokenOut` is WPLS (the output will be unwrapped
+ * to native PLS by the contract).
+ */
+export declare function shouldUnwrapOutput(tokenOut: string, wrappedNativeToken?: string): boolean;
+/**
+ * Get the SwitchPLSFlow contract address.
+ *
+ * Use this contract to create native PLS limit orders (sell PLS for any token)
+ * in a single transaction — no EIP-712 signing required.
+ *
+ * @returns The SwitchPLSFlow contract address
+ */
+export declare function getPLSFlowAddress(nativeFlowContract?: string): string;
+/** 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 declare const LIMIT_ORDER_NETWORK_CONFIGS: Readonly<Record<LimitOrderNetwork, LimitOrderNetworkConfig>>;
+/** Return the static deployment defaults for a supported limit-order network. */
+export declare function getLimitOrderNetworkConfig(network?: LimitOrderNetwork): LimitOrderNetworkConfig;
+/** Build the correct EIP-712 signing domain for a supported network. */
+export declare function getNetworkEIP712SigningParams(network: LimitOrderNetwork, limitOrderContract?: string): {
+    readonly domain: {
+        readonly name: "SwitchLimitOrder";
+        readonly version: "2";
+        readonly chainId: number;
+        readonly verifyingContract: string;
+    };
+    readonly types: {
+        readonly LimitOrder: readonly [{
+            readonly name: "maker";
+            readonly type: "address";
+        }, {
+            readonly name: "tokenIn";
+            readonly type: "address";
+        }, {
+            readonly name: "tokenOut";
+            readonly type: "address";
+        }, {
+            readonly name: "amountIn";
+            readonly type: "uint256";
+        }, {
+            readonly name: "minAmountOut";
+            readonly type: "uint256";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly name: "feeOnOutput";
+            readonly type: "bool";
+        }, {
+            readonly name: "recipient";
+            readonly type: "address";
+        }, {
+            readonly name: "unwrapOutput";
+            readonly type: "bool";
+        }, {
+            readonly name: "partnerAddress";
+            readonly type: "address";
+        }];
+    };
+};
+/** Resolve the maker's ERC-20 approval target for the selected fee mode. */
+export declare function getLimitOrderApprovalTarget(network: LimitOrderNetwork, feeOnOutput: boolean, overrides?: {
+    limitOrderContract?: string;
+    routerContract?: string;
+}): string;
+export interface LimitOrderNetworkOptions {
+    network?: LimitOrderNetwork;
+}
+/**
+ * Check if the input token is native PLS (should use PLSFlow instead of EIP-712).
+ *
+ * When the user wants to sell native PLS (not WPLS), they should use the
+ * PLSFlow contract instead of the standard EIP-712 signing flow.
+ *
+ * @param tokenIn - The input token address
+ * @returns `true` if tokenIn is the native PLS sentinel address
+ */
+export declare function isNativePLS(tokenIn: string): boolean;
+/** Network-neutral native-currency sentinel check (PLS or ETH). */
+export declare function isNativeCurrency(tokenIn: string): boolean;
+/** Return the native-order flow contract for PulseChain or Robinhood Chain. */
+export declare function getNativeFlowAddress(network: LimitOrderNetwork, nativeFlowContract?: string): string;
+/**
+ * Submit a signed limit order to the Switch backend.
+ *
+ * The backend verifies the EIP-712 signature and stores the order. No gas
+ * is required — this is an off-chain operation.
+ *
+ * **⚠️ CRITICAL:** For standard ERC-20 orders, the EIP-712 signature is
+ * purely off-chain — nothing is recorded on-chain until the bot fills it.
+ * If this POST fails or never fires (e.g. user closes their browser after
+ * signing), the **order is permanently lost**. Your integration should:
+ *
+ * 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, 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
+ * on-chain first, so the backend can discover them via event indexing
+ * even if the POST never arrives.
+ *
+ * @param signedOrder - Order parameters + EIP-712 signature
+ * @returns The created order record, or an error
+ *
+ * @example
+ * ```ts
+ * const order = buildLimitOrder({ ... });
+ * const signature = await signer.signTypedData(domain, types, order);
+ * const result = await submitLimitOrder({ ...order, signature });
+ *
+ * if ("error" in result) {
+ *   console.error(result.error);
+ * } else {
+ *   console.log("Order created:", result.order.id);
+ * }
+ * ```
+ */
+export declare function submitLimitOrder(signedOrder: SignedLimitOrder, options?: LimitOrderNetworkOptions): Promise<CreateLimitOrderResponse | ErrorResponse>;
+/**
+ * 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.
+ */
+export declare function cancelLimitOrder(maker: string, nonce: number, options?: LimitOrderNetworkOptions): Promise<CancelLimitOrderResponse | ErrorResponse>;
+/** Filter options for listing limit orders */
+export interface ListLimitOrdersOptions {
+    /** Backend network process to query. */
+    network?: LimitOrderNetwork;
+    /** Filter by order status. Default: `"ACTIVE"` */
+    status?: LimitOrderStatus;
+    /** Filter by maker address */
+    maker?: string;
+    /**
+     * Filter by owner address. Matches orders where the address is either
+     * the `maker` or `recipient` field. Useful for native-PLS (PLSFlow) orders
+     * where the maker is the PLSFlow contract but the user is the recipient.
+     */
+    owner?: string;
+    /** Filter by partner address */
+    partnerAddress?: string;
+    /** Filter by input token address */
+    tokenIn?: string;
+    /** Filter by output token address */
+    tokenOut?: string;
+    /** Filter by pair key (`tokenIn:tokenOut`, lowercased) */
+    pair?: string;
+    /** Page size (1–500). Default: `100` */
+    limit?: number;
+    /** Page offset. Default: `0` */
+    offset?: number;
+}
+/**
+ * Fetch limit orders from the Switch backend with optional filters.
+ *
+ * @param options - Query filters (all optional)
+ * @returns Paginated list of orders
+ *
+ * @example
+ * ```ts
+ * // All active orders for a specific maker
+ * const { orders, total } = await fetchLimitOrders({
+ *   maker: "0xYourAddress",
+ *   status: "ACTIVE",
+ * });
+ *
+ * // All filled orders for a token pair
+ * const filled = await fetchLimitOrders({
+ *   tokenIn: WPLS,
+ *   tokenOut: "0xPLSXAddress",
+ *   status: "FILLED",
+ * });
+ *
+ * // Orders attributed to a specific partner
+ * const partnerOrders = await fetchLimitOrders({
+ *   partnerAddress: "0xPartnerAddress",
+ *   status: "ACTIVE",
+ * });
+ * ```
+ */
+export declare function fetchLimitOrders(options?: ListLimitOrdersOptions): Promise<ListLimitOrdersResponse>;
+/**
+ * Fetch a single limit order by maker address and nonce.
+ *
+ * @param maker - Maker address
+ * @param nonce - Order nonce
+ * @returns The order record, or an error if not found
+ */
+export declare function fetchLimitOrder(maker: string, nonce: number, options?: LimitOrderNetworkOptions): Promise<LimitOrderRecord | ErrorResponse>;
+/**
+ * Fetch active trading pairs with order counts.
+ *
+ * Useful for displaying which token pairs have open limit orders.
+ */
+export declare function fetchLimitOrderPairs(options?: LimitOrderNetworkOptions): Promise<LimitOrderPair[]>;
+/** Fetch the active deployment and EIP-712 domain for a network. */
+export declare function fetchLimitOrderConfig(options?: LimitOrderNetworkOptions): Promise<LimitOrderConfigResponse>;
+/**
+ * Fetch summary statistics for all limit orders.
+ *
+ * Returns counts of active, filled, cancelled, and expired orders.
+ */
+export declare function fetchLimitOrderStats(options?: LimitOrderNetworkOptions): Promise<LimitOrderStats>;
+//# sourceMappingURL=limit-orders.d.ts.map

package/dist/limit-orders.d.ts.map

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