@aspan/sdk 0.3.1 → 0.4.1

package/src/router.ts

@@ -1,6 +1,7 @@
 /**
  * Aspan Router Client
  * TypeScript client for interacting with the AspanRouter periphery contract
+ * Updated: 2026-02-04 (v2.0.0 - consolidated API)
  */
 
 import {
@@ -22,11 +23,10 @@ import type {
   SwapAndMintParams,
   StakeAndMintParams,
   SwapAndMintDefaultParams,
-  RouterMintApUSDParams,
-  RouterMintXBNBParams,
-  RouterRedeemApUSDParams,
-  RouterRedeemXBNBParams,
+  RouterMintParams2,
+  RouterRedeemParams,
   RouterRedeemAndSwapParams,
+  RouterRedeemAndUnstakeParams,
   WithdrawalRequestInfo,
 } from "./types";
 
@@ -117,50 +117,32 @@ export class AspanRouterReadClient {
   }
 
   /**
-   * Preview apUSD mint output for a given LST amount
+   * Preview mint output for a given LST amount
+   * @param lst LST token address
+   * @param lstAmount Amount of LST
+   * @param mintXBNB true = preview xBNB mint, false = preview apUSD mint
    */
-  async previewMintApUSD(lst: Address, lstAmount: bigint): Promise<bigint> {
+  async previewMint(lst: Address, lstAmount: bigint, mintXBNB: boolean): Promise<bigint> {
     return this.publicClient.readContract({
       address: this.routerAddress,
       abi: RouterABI,
-      functionName: "previewMintApUSD",
-      args: [lst, lstAmount],
+      functionName: "previewMint",
+      args: [lst, lstAmount, mintXBNB],
     });
   }
 
   /**
-   * Preview xBNB mint output for a given LST amount
+   * Preview redeem output
+   * @param lst LST token to receive
+   * @param redeemXBNB true = redeem xBNB, false = redeem apUSD
+   * @param amount Amount of apUSD/xBNB to redeem
    */
-  async previewMintXBNB(lst: Address, lstAmount: bigint): Promise<bigint> {
+  async previewRedeem(lst: Address, redeemXBNB: boolean, amount: bigint): Promise<bigint> {
     return this.publicClient.readContract({
       address: this.routerAddress,
       abi: RouterABI,
-      functionName: "previewMintXBNB",
-      args: [lst, lstAmount],
-    });
-  }
-
-  /**
-   * Preview LST output for redeeming apUSD
-   */
-  async previewRedeemApUSD(lst: Address, apUSDAmount: bigint): Promise<bigint> {
-    return this.publicClient.readContract({
-      address: this.routerAddress,
-      abi: RouterABI,
-      functionName: "previewRedeemApUSD",
-      args: [lst, apUSDAmount],
-    });
-  }
-
-  /**
-   * Preview LST output for redeeming xBNB
-   */
-  async previewRedeemXBNB(lst: Address, xBNBAmount: bigint): Promise<bigint> {
-    return this.publicClient.readContract({
-      address: this.routerAddress,
-      abi: RouterABI,
-      functionName: "previewRedeemXBNB",
-      args: [lst, xBNBAmount],
+      functionName: "previewRedeem",
+      args: [lst, redeemXBNB, amount],
     });
   }
 
@@ -290,9 +272,11 @@ export class AspanRouterClient extends AspanRouterReadClient {
   // ============ Core Functions ============
 
   /**
-   * Swap input token to LST and mint apUSD
+   * Swap input token to LST and mint apUSD or xBNB
+   * @param params.swapParams Swap configuration
+   * @param params.mintParams Mint configuration (mintXBNB determines output token)
    */
-  async swapAndMintApUSD(params: SwapAndMintParams): Promise<Hash> {
+  async swapAndMint(params: SwapAndMintParams): Promise<Hash> {
     const value =
       params.swapParams.inputToken === zeroAddress
         ? params.swapParams.inputAmount
@@ -303,7 +287,7 @@ export class AspanRouterClient extends AspanRouterReadClient {
       account: this.walletClient.account!,
       address: this.routerAddress,
       abi: RouterABI,
-      functionName: "swapAndMintApUSD",
+      functionName: "swapAndMint",
       args: [
         {
           inputToken: params.swapParams.inputToken,
@@ -313,7 +297,7 @@ export class AspanRouterClient extends AspanRouterReadClient {
           poolFee: params.swapParams.poolFee,
         },
         {
-          mintXBNB: false, // swapAndMintApUSD always mints apUSD
+          mintXBNB: params.mintParams.mintXBNB,
           minMintOut: params.mintParams.minMintOut,
           recipient: params.mintParams.recipient,
           deadline: params.mintParams.deadline,
@@ -324,34 +308,25 @@ export class AspanRouterClient extends AspanRouterReadClient {
   }
 
   /**
-   * Swap input token to LST and mint xBNB
+   * Swap input token and mint using default LST (simplified)
+   * @param params.mintXBNB true = mint xBNB, false = mint apUSD
    */
-  async swapAndMintXBNB(params: SwapAndMintParams): Promise<Hash> {
+  async swapAndMintDefault(params: SwapAndMintDefaultParams): Promise<Hash> {
     const value =
-      params.swapParams.inputToken === zeroAddress
-        ? params.swapParams.inputAmount
-        : 0n;
+      params.inputToken === zeroAddress ? params.value ?? params.inputAmount : 0n;
 
     return this.walletClient.writeContract({
       chain: this.chain,
       account: this.walletClient.account!,
       address: this.routerAddress,
       abi: RouterABI,
-      functionName: "swapAndMintXBNB",
+      functionName: "swapAndMintDefault",
       args: [
-        {
-          inputToken: params.swapParams.inputToken,
-          inputAmount: params.swapParams.inputAmount,
-          targetLST: params.swapParams.targetLST,
-          minLSTOut: params.swapParams.minLSTOut,
-          poolFee: params.swapParams.poolFee,
-        },
-        {
-          mintXBNB: true, // swapAndMintXBNB always mints xBNB
-          minMintOut: params.mintParams.minMintOut,
-          recipient: params.mintParams.recipient,
-          deadline: params.mintParams.deadline,
-        },
+        params.inputToken,
+        params.inputAmount,
+        params.mintXBNB,
+        params.minMintOut,
+        params.deadline,
       ],
       value,
     });
@@ -359,6 +334,7 @@ export class AspanRouterClient extends AspanRouterReadClient {
 
   /**
    * Stake native BNB directly to LST and mint
+   * @param params.isXBNB true = mint xBNB, false = mint apUSD
    */
   async stakeAndMint(params: StakeAndMintParams): Promise<Hash> {
     return this.walletClient.writeContract({
@@ -377,182 +353,61 @@ export class AspanRouterClient extends AspanRouterReadClient {
     });
   }
 
-  // ============ Simplified Functions ============
-
-  /**
-   * Swap input token and mint apUSD using default LST
-   */
-  async swapAndMintApUSDDefault(params: SwapAndMintDefaultParams): Promise<Hash> {
-    const value =
-      params.inputToken === zeroAddress ? params.value ?? params.inputAmount : 0n;
-
-    return this.walletClient.writeContract({
-      chain: this.chain,
-      account: this.walletClient.account!,
-      address: this.routerAddress,
-      abi: RouterABI,
-      functionName: "swapAndMintApUSDDefault",
-      args: [
-        params.inputToken,
-        params.inputAmount,
-        params.minMintOut,
-        params.deadline,
-      ],
-      value,
-    });
-  }
-
-  /**
-   * Swap input token and mint xBNB using default LST
-   */
-  async swapAndMintXBNBDefault(params: SwapAndMintDefaultParams): Promise<Hash> {
-    const value =
-      params.inputToken === zeroAddress ? params.value ?? params.inputAmount : 0n;
-
-    return this.walletClient.writeContract({
-      chain: this.chain,
-      account: this.walletClient.account!,
-      address: this.routerAddress,
-      abi: RouterABI,
-      functionName: "swapAndMintXBNBDefault",
-      args: [
-        params.inputToken,
-        params.inputAmount,
-        params.minMintOut,
-        params.deadline,
-      ],
-      value,
-    });
-  }
-
-  /**
-   * Stake native BNB and mint apUSD using default LST
-   */
-  async stakeAndMintApUSD(minMintOut: bigint, value: bigint): Promise<Hash> {
-    return this.walletClient.writeContract({
-      chain: this.chain,
-      account: this.walletClient.account!,
-      address: this.routerAddress,
-      abi: RouterABI,
-      functionName: "stakeAndMintApUSD",
-      args: [minMintOut],
-      value,
-    });
-  }
-
-  /**
-   * Stake native BNB and mint xBNB using default LST
-   */
-  async stakeAndMintXBNB(minMintOut: bigint, value: bigint): Promise<Hash> {
-    return this.walletClient.writeContract({
-      chain: this.chain,
-      account: this.walletClient.account!,
-      address: this.routerAddress,
-      abi: RouterABI,
-      functionName: "stakeAndMintXBNB",
-      args: [minMintOut],
-      value,
-    });
-  }
-
   // ============ Direct Mint/Redeem Functions ============
 
   /**
-   * Mint apUSD by providing LST directly (no swap)
-   */
-  async mintApUSD(params: RouterMintApUSDParams): Promise<Hash> {
-    return this.walletClient.writeContract({
-      chain: this.chain,
-      account: this.walletClient.account!,
-      address: this.routerAddress,
-      abi: RouterABI,
-      functionName: "mintApUSD",
-      args: [params.lst, params.lstAmount, params.minOut ?? 0n],
-    });
-  }
-
-  /**
-   * Mint xBNB by providing LST directly (no swap)
+   * Mint apUSD or xBNB by providing LST directly (no swap)
+   * @param params.mintXBNB true = mint xBNB, false = mint apUSD
    */
-  async mintXBNB(params: RouterMintXBNBParams): Promise<Hash> {
+  async mint(params: RouterMintParams2): Promise<Hash> {
     return this.walletClient.writeContract({
       chain: this.chain,
       account: this.walletClient.account!,
       address: this.routerAddress,
       abi: RouterABI,
-      functionName: "mintXBNB",
-      args: [params.lst, params.lstAmount, params.minOut ?? 0n],
+      functionName: "mint",
+      args: [params.lst, params.lstAmount, params.mintXBNB, params.minOut ?? 0n],
     });
   }
 
   /**
-   * Redeem apUSD for LST (no swap)
+   * Redeem apUSD or xBNB for LST (no swap)
+   * @param params.redeemXBNB true = redeem xBNB, false = redeem apUSD
    */
-  async redeemApUSD(params: RouterRedeemApUSDParams): Promise<Hash> {
+  async redeem(params: RouterRedeemParams): Promise<Hash> {
     return this.walletClient.writeContract({
       chain: this.chain,
       account: this.walletClient.account!,
       address: this.routerAddress,
       abi: RouterABI,
-      functionName: "redeemApUSD",
-      args: [params.lst, params.apUSDAmount, params.minOut ?? 0n],
-    });
-  }
-
-  /**
-   * Redeem xBNB for LST (no swap)
-   */
-  async redeemXBNB(params: RouterRedeemXBNBParams): Promise<Hash> {
-    return this.walletClient.writeContract({
-      chain: this.chain,
-      account: this.walletClient.account!,
-      address: this.routerAddress,
-      abi: RouterABI,
-      functionName: "redeemXBNB",
-      args: [params.lst, params.xBNBAmount, params.minOut ?? 0n],
+      functionName: "redeem",
+      args: [params.lst, params.redeemXBNB, params.amount, params.minOut ?? 0n],
     });
   }
 
   // ============ Redeem and Swap Functions ============
 
   /**
-   * Redeem apUSD and swap LST to output token via V3 path
-   * @param params.path - PancakeSwap V3 encoded path (use encodeV3Path helper)
-   */
-  async redeemApUSDAndSwap(params: RouterRedeemAndSwapParams): Promise<Hash> {
-    return this.walletClient.writeContract({
-      chain: this.chain,
-      account: this.walletClient.account!,
-      address: this.routerAddress,
-      abi: RouterABI,
-      functionName: "redeemApUSDAndSwap",
-      args: [
-        params.lst,
-        params.amount,
-        params.path,
-        params.minOut,
-        params.deadline,
-      ],
-    });
-  }
-
-  /**
-   * Redeem xBNB and swap LST to output token via V3 path
-   * @param params.path - PancakeSwap V3 encoded path (use encodeV3Path helper)
+   * Redeem apUSD/xBNB and swap LST to output token via V3 path
+   * @param params.redeemXBNB true = redeem xBNB, false = redeem apUSD
+   * @param params.path PancakeSwap V3 encoded path (use encodeV3Path helper)
+   * @param params.unwrapBNB If true and output is WBNB, unwrap to native BNB
    */
-  async redeemXBNBAndSwap(params: RouterRedeemAndSwapParams): Promise<Hash> {
+  async redeemAndSwap(params: RouterRedeemAndSwapParams): Promise<Hash> {
     return this.walletClient.writeContract({
       chain: this.chain,
       account: this.walletClient.account!,
       address: this.routerAddress,
       abi: RouterABI,
-      functionName: "redeemXBNBAndSwap",
+      functionName: "redeemAndSwap",
       args: [
         params.lst,
+        params.redeemXBNB,
         params.amount,
         params.path,
         params.minOut,
         params.deadline,
+        params.unwrapBNB,
       ],
     });
   }
@@ -560,30 +415,17 @@ export class AspanRouterClient extends AspanRouterReadClient {
   // ============ Native Unstake Functions ============
 
   /**
-   * Redeem apUSD and request native unstake from Lista (starts unbonding period)
-   */
-  async redeemApUSDAndRequestUnstake(apUSDAmount: bigint): Promise<Hash> {
-    return this.walletClient.writeContract({
-      chain: this.chain,
-      account: this.walletClient.account!,
-      address: this.routerAddress,
-      abi: RouterABI,
-      functionName: "redeemApUSDAndRequestUnstake",
-      args: [apUSDAmount],
-    });
-  }
-
-  /**
-   * Redeem xBNB and request native unstake from Lista (starts unbonding period)
+   * Redeem apUSD/xBNB and request native unstake from Lista (starts unbonding period)
+   * @param params.redeemXBNB true = redeem xBNB, false = redeem apUSD
    */
-  async redeemXBNBAndRequestUnstake(xBNBAmount: bigint): Promise<Hash> {
+  async redeemAndRequestUnstake(params: RouterRedeemAndUnstakeParams): Promise<Hash> {
     return this.walletClient.writeContract({
       chain: this.chain,
       account: this.walletClient.account!,
       address: this.routerAddress,
       abi: RouterABI,
-      functionName: "redeemXBNBAndRequestUnstake",
-      args: [xBNBAmount],
+      functionName: "redeemAndRequestUnstake",
+      args: [params.redeemXBNB, params.amount],
     });
   }
 

package/src/types.ts

@@ -272,7 +272,7 @@ export interface RouterMintParams {
   deadline: bigint;
 }
 
-/** Parameters for swapAndMint functions */
+/** Parameters for swapAndMint function */
 export interface SwapAndMintParams {
   swapParams: RouterSwapParams;
   mintParams: RouterMintParams;
@@ -292,12 +292,14 @@ export interface StakeAndMintParams {
   value: bigint;
 }
 
-/** Parameters for simplified swap and mint functions */
+/** Parameters for swapAndMintDefault function */
 export interface SwapAndMintDefaultParams {
   /** Input token address (address(0) for native BNB) */
   inputToken: Address;
   /** Amount of input token */
   inputAmount: bigint;
+  /** true = mint xBNB, false = mint apUSD */
+  mintXBNB: boolean;
   /** Minimum output to receive */
   minMintOut: bigint;
   /** Transaction deadline timestamp */
@@ -306,55 +308,41 @@ export interface SwapAndMintDefaultParams {
   value?: bigint;
 }
 
-/** Parameters for router direct mint functions */
-export interface RouterMintApUSDParams {
-  /** LST token address */
-  lst: Address;
-  /** Amount of LST to deposit */
-  lstAmount: bigint;
-  /** Minimum apUSD to receive */
-  minOut?: bigint;
-}
-
-/** Parameters for router direct mint xBNB functions */
-export interface RouterMintXBNBParams {
+/** Parameters for router mint function (unified) */
+export interface RouterMintParams2 {
   /** LST token address */
   lst: Address;
   /** Amount of LST to deposit */
   lstAmount: bigint;
-  /** Minimum xBNB to receive */
-  minOut?: bigint;
-}
-
-/** Parameters for router redeem apUSD functions */
-export interface RouterRedeemApUSDParams {
-  /** LST token to receive */
-  lst: Address;
-  /** Amount of apUSD to redeem */
-  apUSDAmount: bigint;
-  /** Minimum LST to receive */
+  /** true = mint xBNB, false = mint apUSD */
+  mintXBNB: boolean;
+  /** Minimum output to receive */
   minOut?: bigint;
 }
 
-/** Parameters for router redeem xBNB functions */
-export interface RouterRedeemXBNBParams {
+/** Parameters for router redeem function (unified) */
+export interface RouterRedeemParams {
   /** LST token to receive */
   lst: Address;
-  /** Amount of xBNB to redeem */
-  xBNBAmount: bigint;
+  /** true = redeem xBNB, false = redeem apUSD */
+  redeemXBNB: boolean;
+  /** Amount of apUSD/xBNB to redeem */
+  amount: bigint;
   /** Minimum LST to receive */
   minOut?: bigint;
 }
 
-/** Parameters for redeemAndSwap functions (uses PancakeSwap V3 path) */
+/** Parameters for redeemAndSwap function (unified with unwrapBNB) */
 export interface RouterRedeemAndSwapParams {
   /** LST to redeem */
   lst: Address;
+  /** true = redeem xBNB, false = redeem apUSD */
+  redeemXBNB: boolean;
   /** Amount to redeem (apUSD or xBNB) */
   amount: bigint;
   /**
    * PancakeSwap V3 encoded swap path (LST → ... → outputToken)
-   * Use encodeV3Path() helper or get from PancakeSwap Quoter
+   * Use encodeV3Path() helper
    * Example: slisBNB → WBNB → USDT
    */
   path: `0x${string}`;
@@ -362,6 +350,16 @@ export interface RouterRedeemAndSwapParams {
   minOut: bigint;
   /** Transaction deadline timestamp */
   deadline: bigint;
+  /** If true and output is WBNB, unwrap to native BNB */
+  unwrapBNB: boolean;
+}
+
+/** Parameters for redeemAndRequestUnstake function (unified) */
+export interface RouterRedeemAndUnstakeParams {
+  /** true = redeem xBNB, false = redeem apUSD */
+  redeemXBNB: boolean;
+  /** Amount to redeem (apUSD or xBNB) */
+  amount: bigint;
 }
 
 /**
@@ -384,18 +382,6 @@ export function encodeV3Path(tokens: Address[], fees: number[]): `0x${string}` {
   return `0x${path}`;
 }
 
-/** Parameters for redeemAndUnstake functions */
-export interface RouterRedeemAndUnstakeParams {
-  /** LST to redeem */
-  lst: Address;
-  /** Amount to redeem (apUSD or xBNB) */
-  amount: bigint;
-  /** Minimum BNB to receive */
-  minBNBOut: bigint;
-  /** Transaction deadline timestamp */
-  deadline: bigint;
-}
-
 /** Withdrawal request status */
 export interface WithdrawalRequestInfo {
   /** Whether the request can be claimed */
@@ -479,3 +465,34 @@ export interface UnstakeClaimedEvent {
   requestIndex: bigint;
   bnbAmount: bigint;
 }
+
+// ============ Legacy Types (deprecated) ============
+// These are kept for backwards compatibility but should not be used in new code
+
+/** @deprecated Use RouterMintParams2 instead */
+export interface RouterMintApUSDParams {
+  lst: Address;
+  lstAmount: bigint;
+  minOut?: bigint;
+}
+
+/** @deprecated Use RouterMintParams2 instead */
+export interface RouterMintXBNBParams {
+  lst: Address;
+  lstAmount: bigint;
+  minOut?: bigint;
+}
+
+/** @deprecated Use RouterRedeemParams instead */
+export interface RouterRedeemApUSDParams {
+  lst: Address;
+  apUSDAmount: bigint;
+  minOut?: bigint;
+}
+
+/** @deprecated Use RouterRedeemParams instead */
+export interface RouterRedeemXBNBParams {
+  lst: Address;
+  xBNBAmount: bigint;
+  minOut?: bigint;
+}