@aspan/sdk 0.1.8 → 0.2.1

package/dist/index.mjs

@@ -1411,6 +1411,1165 @@ function createAspanTestnetClient(diamondAddress, account, rpcUrl) {
   });
 }
 
+// src/router.ts
+import {
+  createPublicClient as createPublicClient2,
+  createWalletClient as createWalletClient2,
+  http as http2,
+  zeroAddress
+} from "viem";
+import { bsc as bsc2, bscTestnet as bscTestnet2 } from "viem/chains";
+
+// src/abi/router.ts
+var RouterABI = [
+  // ============ Core Functions ============
+  // swapAndMintApUSD
+  {
+    type: "function",
+    name: "swapAndMintApUSD",
+    inputs: [
+      {
+        name: "swapParams",
+        type: "tuple",
+        components: [
+          { name: "inputToken", type: "address" },
+          { name: "inputAmount", type: "uint256" },
+          { name: "targetLST", type: "address" },
+          { name: "minLSTOut", type: "uint256" },
+          { name: "poolFee", type: "uint24" },
+          { name: "useV2", type: "bool" }
+        ]
+      },
+      {
+        name: "mintParams",
+        type: "tuple",
+        components: [
+          { name: "mintXBNB", type: "bool" },
+          { name: "minMintOut", type: "uint256" },
+          { name: "recipient", type: "address" },
+          { name: "deadline", type: "uint256" }
+        ]
+      }
+    ],
+    outputs: [
+      { name: "lstAmount", type: "uint256" },
+      { name: "apUSDAmount", type: "uint256" }
+    ],
+    stateMutability: "payable"
+  },
+  // swapAndMintXBNB
+  {
+    type: "function",
+    name: "swapAndMintXBNB",
+    inputs: [
+      {
+        name: "swapParams",
+        type: "tuple",
+        components: [
+          { name: "inputToken", type: "address" },
+          { name: "inputAmount", type: "uint256" },
+          { name: "targetLST", type: "address" },
+          { name: "minLSTOut", type: "uint256" },
+          { name: "poolFee", type: "uint24" },
+          { name: "useV2", type: "bool" }
+        ]
+      },
+      {
+        name: "mintParams",
+        type: "tuple",
+        components: [
+          { name: "mintXBNB", type: "bool" },
+          { name: "minMintOut", type: "uint256" },
+          { name: "recipient", type: "address" },
+          { name: "deadline", type: "uint256" }
+        ]
+      }
+    ],
+    outputs: [
+      { name: "lstAmount", type: "uint256" },
+      { name: "xBNBAmount", type: "uint256" }
+    ],
+    stateMutability: "payable"
+  },
+  // stakeAndMint
+  {
+    type: "function",
+    name: "stakeAndMint",
+    inputs: [
+      { name: "targetLST", type: "address" },
+      { name: "isXBNB", type: "bool" },
+      { name: "minMintOut", type: "uint256" },
+      { name: "deadline", type: "uint256" }
+    ],
+    outputs: [
+      { name: "lstAmount", type: "uint256" },
+      { name: "mintedAmount", type: "uint256" }
+    ],
+    stateMutability: "payable"
+  },
+  // ============ Simplified Functions ============
+  // swapAndMintApUSDDefault
+  {
+    type: "function",
+    name: "swapAndMintApUSDDefault",
+    inputs: [
+      { name: "inputToken", type: "address" },
+      { name: "inputAmount", type: "uint256" },
+      { name: "minMintOut", type: "uint256" },
+      { name: "deadline", type: "uint256" }
+    ],
+    outputs: [{ name: "apUSDAmount", type: "uint256" }],
+    stateMutability: "payable"
+  },
+  // swapAndMintXBNBDefault
+  {
+    type: "function",
+    name: "swapAndMintXBNBDefault",
+    inputs: [
+      { name: "inputToken", type: "address" },
+      { name: "inputAmount", type: "uint256" },
+      { name: "minMintOut", type: "uint256" },
+      { name: "deadline", type: "uint256" }
+    ],
+    outputs: [{ name: "xBNBAmount", type: "uint256" }],
+    stateMutability: "payable"
+  },
+  // stakeAndMintApUSD
+  {
+    type: "function",
+    name: "stakeAndMintApUSD",
+    inputs: [{ name: "minMintOut", type: "uint256" }],
+    outputs: [{ name: "apUSDAmount", type: "uint256" }],
+    stateMutability: "payable"
+  },
+  // stakeAndMintXBNB
+  {
+    type: "function",
+    name: "stakeAndMintXBNB",
+    inputs: [{ name: "minMintOut", type: "uint256" }],
+    outputs: [{ name: "xBNBAmount", type: "uint256" }],
+    stateMutability: "payable"
+  },
+  // ============ Direct Mint/Redeem Functions ============
+  // mintApUSD
+  {
+    type: "function",
+    name: "mintApUSD",
+    inputs: [
+      { name: "lst", type: "address" },
+      { name: "lstAmount", type: "uint256" },
+      { name: "minOut", type: "uint256" }
+    ],
+    outputs: [{ name: "apUSDAmount", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  // mintXBNB
+  {
+    type: "function",
+    name: "mintXBNB",
+    inputs: [
+      { name: "lst", type: "address" },
+      { name: "lstAmount", type: "uint256" },
+      { name: "minOut", type: "uint256" }
+    ],
+    outputs: [{ name: "xBNBAmount", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  // redeemApUSD
+  {
+    type: "function",
+    name: "redeemApUSD",
+    inputs: [
+      { name: "lst", type: "address" },
+      { name: "apUSDAmount", type: "uint256" },
+      { name: "minOut", type: "uint256" }
+    ],
+    outputs: [{ name: "lstAmount", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  // redeemXBNB
+  {
+    type: "function",
+    name: "redeemXBNB",
+    inputs: [
+      { name: "lst", type: "address" },
+      { name: "xBNBAmount", type: "uint256" },
+      { name: "minOut", type: "uint256" }
+    ],
+    outputs: [{ name: "lstAmount", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  // ============ Redeem and Swap Functions ============
+  // redeemApUSDAndSwap
+  {
+    type: "function",
+    name: "redeemApUSDAndSwap",
+    inputs: [
+      { name: "lst", type: "address" },
+      { name: "apUSDAmount", type: "uint256" },
+      { name: "outputToken", type: "address" },
+      { name: "minOut", type: "uint256" },
+      { name: "deadline", type: "uint256" },
+      { name: "useV2", type: "bool" },
+      { name: "poolFee", type: "uint24" }
+    ],
+    outputs: [{ name: "outputAmount", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  // redeemXBNBAndSwap
+  {
+    type: "function",
+    name: "redeemXBNBAndSwap",
+    inputs: [
+      { name: "lst", type: "address" },
+      { name: "xBNBAmount", type: "uint256" },
+      { name: "outputToken", type: "address" },
+      { name: "minOut", type: "uint256" },
+      { name: "deadline", type: "uint256" },
+      { name: "useV2", type: "bool" },
+      { name: "poolFee", type: "uint24" }
+    ],
+    outputs: [{ name: "outputAmount", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  // redeemApUSDAndUnstake
+  {
+    type: "function",
+    name: "redeemApUSDAndUnstake",
+    inputs: [
+      { name: "lst", type: "address" },
+      { name: "apUSDAmount", type: "uint256" },
+      { name: "minBNBOut", type: "uint256" },
+      { name: "deadline", type: "uint256" }
+    ],
+    outputs: [{ name: "bnbAmount", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  // redeemXBNBAndUnstake
+  {
+    type: "function",
+    name: "redeemXBNBAndUnstake",
+    inputs: [
+      { name: "lst", type: "address" },
+      { name: "xBNBAmount", type: "uint256" },
+      { name: "minBNBOut", type: "uint256" },
+      { name: "deadline", type: "uint256" }
+    ],
+    outputs: [{ name: "bnbAmount", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  // ============ Native Unstake Functions ============
+  // redeemApUSDAndRequestUnstake
+  {
+    type: "function",
+    name: "redeemApUSDAndRequestUnstake",
+    inputs: [{ name: "apUSDAmount", type: "uint256" }],
+    outputs: [
+      { name: "requestIndex", type: "uint256" },
+      { name: "slisBNBAmount", type: "uint256" }
+    ],
+    stateMutability: "nonpayable"
+  },
+  // redeemXBNBAndRequestUnstake
+  {
+    type: "function",
+    name: "redeemXBNBAndRequestUnstake",
+    inputs: [{ name: "xBNBAmount", type: "uint256" }],
+    outputs: [
+      { name: "requestIndex", type: "uint256" },
+      { name: "slisBNBAmount", type: "uint256" }
+    ],
+    stateMutability: "nonpayable"
+  },
+  // claimUnstake
+  {
+    type: "function",
+    name: "claimUnstake",
+    inputs: [{ name: "requestIndex", type: "uint256" }],
+    outputs: [{ name: "bnbAmount", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  // ============ View Functions ============
+  // defaultLST
+  {
+    type: "function",
+    name: "defaultLST",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  // supportedInputTokens
+  {
+    type: "function",
+    name: "supportedInputTokens",
+    inputs: [{ name: "token", type: "address" }],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view"
+  },
+  // supportedLSTs
+  {
+    type: "function",
+    name: "supportedLSTs",
+    inputs: [{ name: "lst", type: "address" }],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "view"
+  },
+  // diamond
+  {
+    type: "function",
+    name: "diamond",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  // getExpectedMintOutput
+  {
+    type: "function",
+    name: "getExpectedMintOutput",
+    inputs: [
+      { name: "inputToken", type: "address" },
+      { name: "inputAmount", type: "uint256" },
+      { name: "targetLST", type: "address" },
+      { name: "isXBNB", type: "bool" }
+    ],
+    outputs: [
+      { name: "expectedLST", type: "uint256" },
+      { name: "expectedMint", type: "uint256" }
+    ],
+    stateMutability: "view"
+  },
+  // getExpectedRedeemOutput
+  {
+    type: "function",
+    name: "getExpectedRedeemOutput",
+    inputs: [
+      { name: "isXBNB", type: "bool" },
+      { name: "redeemAmount", type: "uint256" },
+      { name: "lst", type: "address" },
+      { name: "outputToken", type: "address" }
+    ],
+    outputs: [
+      { name: "expectedLST", type: "uint256" },
+      { name: "expectedOutput", type: "uint256" }
+    ],
+    stateMutability: "view"
+  },
+  // previewMintApUSD
+  {
+    type: "function",
+    name: "previewMintApUSD",
+    inputs: [
+      { name: "lst", type: "address" },
+      { name: "lstAmount", type: "uint256" }
+    ],
+    outputs: [{ name: "apUSDAmount", type: "uint256" }],
+    stateMutability: "view"
+  },
+  // previewMintXBNB
+  {
+    type: "function",
+    name: "previewMintXBNB",
+    inputs: [
+      { name: "lst", type: "address" },
+      { name: "lstAmount", type: "uint256" }
+    ],
+    outputs: [{ name: "xBNBAmount", type: "uint256" }],
+    stateMutability: "view"
+  },
+  // previewRedeemApUSD
+  {
+    type: "function",
+    name: "previewRedeemApUSD",
+    inputs: [
+      { name: "lst", type: "address" },
+      { name: "apUSDAmount", type: "uint256" }
+    ],
+    outputs: [{ name: "lstAmount", type: "uint256" }],
+    stateMutability: "view"
+  },
+  // previewRedeemXBNB
+  {
+    type: "function",
+    name: "previewRedeemXBNB",
+    inputs: [
+      { name: "lst", type: "address" },
+      { name: "xBNBAmount", type: "uint256" }
+    ],
+    outputs: [{ name: "lstAmount", type: "uint256" }],
+    stateMutability: "view"
+  },
+  // getUserWithdrawalIndices
+  {
+    type: "function",
+    name: "getUserWithdrawalIndices",
+    inputs: [{ name: "user", type: "address" }],
+    outputs: [{ name: "", type: "uint256[]" }],
+    stateMutability: "view"
+  },
+  // getWithdrawalStatus
+  {
+    type: "function",
+    name: "getWithdrawalStatus",
+    inputs: [{ name: "requestIndex", type: "uint256" }],
+    outputs: [
+      { name: "isClaimable", type: "bool" },
+      { name: "bnbAmount", type: "uint256" }
+    ],
+    stateMutability: "view"
+  },
+  // Immutable addresses
+  {
+    type: "function",
+    name: "wbnb",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "usdt",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "usdc",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "slisBNB",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "asBNB",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "wclisBNB",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "apUSD",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "xBNB",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  // ============ Events ============
+  // SwapAndMint
+  {
+    type: "event",
+    name: "SwapAndMint",
+    inputs: [
+      { name: "user", type: "address", indexed: true },
+      { name: "inputToken", type: "address", indexed: true },
+      { name: "inputAmount", type: "uint256", indexed: false },
+      { name: "targetLST", type: "address", indexed: true },
+      { name: "lstAmount", type: "uint256", indexed: false },
+      { name: "mintedToken", type: "address", indexed: false },
+      { name: "mintedAmount", type: "uint256", indexed: false }
+    ]
+  },
+  // StakeAndMint
+  {
+    type: "event",
+    name: "StakeAndMint",
+    inputs: [
+      { name: "user", type: "address", indexed: true },
+      { name: "bnbAmount", type: "uint256", indexed: false },
+      { name: "targetLST", type: "address", indexed: true },
+      { name: "lstAmount", type: "uint256", indexed: false },
+      { name: "mintedToken", type: "address", indexed: true },
+      { name: "mintedAmount", type: "uint256", indexed: false }
+    ]
+  },
+  // Mint
+  {
+    type: "event",
+    name: "Mint",
+    inputs: [
+      { name: "user", type: "address", indexed: true },
+      { name: "lst", type: "address", indexed: true },
+      { name: "lstAmount", type: "uint256", indexed: false },
+      { name: "mintedToken", type: "address", indexed: true },
+      { name: "mintedAmount", type: "uint256", indexed: false }
+    ]
+  },
+  // Redeem
+  {
+    type: "event",
+    name: "Redeem",
+    inputs: [
+      { name: "user", type: "address", indexed: true },
+      { name: "redeemedToken", type: "address", indexed: true },
+      { name: "redeemedAmount", type: "uint256", indexed: false },
+      { name: "lst", type: "address", indexed: true },
+      { name: "lstAmount", type: "uint256", indexed: false }
+    ]
+  },
+  // RedeemAndSwap
+  {
+    type: "event",
+    name: "RedeemAndSwap",
+    inputs: [
+      { name: "user", type: "address", indexed: true },
+      { name: "redeemedToken", type: "address", indexed: false },
+      { name: "redeemedAmount", type: "uint256", indexed: false },
+      { name: "lst", type: "address", indexed: false },
+      { name: "lstAmount", type: "uint256", indexed: false },
+      { name: "outputToken", type: "address", indexed: true },
+      { name: "outputAmount", type: "uint256", indexed: false }
+    ]
+  },
+  // UnstakeRequested
+  {
+    type: "event",
+    name: "UnstakeRequested",
+    inputs: [
+      { name: "user", type: "address", indexed: true },
+      { name: "requestIndex", type: "uint256", indexed: true },
+      { name: "redeemedToken", type: "address", indexed: false },
+      { name: "redeemedAmount", type: "uint256", indexed: false },
+      { name: "slisBNBAmount", type: "uint256", indexed: false }
+    ]
+  },
+  // UnstakeClaimed
+  {
+    type: "event",
+    name: "UnstakeClaimed",
+    inputs: [
+      { name: "user", type: "address", indexed: true },
+      { name: "requestIndex", type: "uint256", indexed: true },
+      { name: "bnbAmount", type: "uint256", indexed: false }
+    ]
+  },
+  // DefaultLSTUpdated
+  {
+    type: "event",
+    name: "DefaultLSTUpdated",
+    inputs: [
+      { name: "oldLST", type: "address", indexed: true },
+      { name: "newLST", type: "address", indexed: true }
+    ]
+  },
+  // ============ Errors ============
+  { type: "error", name: "UnsupportedInputToken", inputs: [] },
+  { type: "error", name: "UnsupportedLST", inputs: [] },
+  { type: "error", name: "DeadlineExpired", inputs: [] },
+  { type: "error", name: "InsufficientOutput", inputs: [] },
+  { type: "error", name: "ZeroAmount", inputs: [] },
+  { type: "error", name: "InvalidRecipient", inputs: [] },
+  { type: "error", name: "SwapFailed", inputs: [] },
+  { type: "error", name: "MintFailed", inputs: [] },
+  { type: "error", name: "NativeTransferFailed", inputs: [] },
+  { type: "error", name: "InvalidPoolFee", inputs: [] },
+  { type: "error", name: "DefaultLSTNotSet", inputs: [] },
+  { type: "error", name: "InvalidWithdrawalRequest", inputs: [] },
+  { type: "error", name: "WithdrawalNotClaimable", inputs: [] },
+  { type: "error", name: "WithdrawalAlreadyClaimed", inputs: [] },
+  { type: "error", name: "OnlySlisBNBSupported", inputs: [] }
+];
+
+// src/router.ts
+var AspanRouterReadClient = class {
+  publicClient;
+  routerAddress;
+  chain;
+  constructor(config) {
+    this.routerAddress = config.routerAddress;
+    this.chain = config.chain ?? bsc2;
+    this.publicClient = createPublicClient2({
+      chain: this.chain,
+      transport: http2(config.rpcUrl)
+    });
+  }
+  // ============ View Functions ============
+  /**
+   * Get the default LST address
+   */
+  async getDefaultLST() {
+    return this.publicClient.readContract({
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "defaultLST"
+    });
+  }
+  /**
+   * Check if an input token is supported
+   */
+  async isSupportedInputToken(token) {
+    return this.publicClient.readContract({
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "supportedInputTokens",
+      args: [token]
+    });
+  }
+  /**
+   * Check if an LST is supported
+   */
+  async isSupportedLST(lst) {
+    return this.publicClient.readContract({
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "supportedLSTs",
+      args: [lst]
+    });
+  }
+  /**
+   * Get the Diamond contract address
+   */
+  async getDiamond() {
+    return this.publicClient.readContract({
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "diamond"
+    });
+  }
+  /**
+   * Get expected output from a swap and mint operation
+   */
+  async getExpectedMintOutput(inputToken, inputAmount, targetLST, isXBNB) {
+    const result = await this.publicClient.readContract({
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "getExpectedMintOutput",
+      args: [inputToken, inputAmount, targetLST, isXBNB]
+    });
+    return {
+      expectedLST: result[0],
+      expectedMint: result[1]
+    };
+  }
+  /**
+   * Get expected output from a redeem and swap operation
+   */
+  async getExpectedRedeemOutput(isXBNB, redeemAmount, lst, outputToken) {
+    const result = await this.publicClient.readContract({
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "getExpectedRedeemOutput",
+      args: [isXBNB, redeemAmount, lst, outputToken]
+    });
+    return {
+      expectedLST: result[0],
+      expectedMint: result[1]
+    };
+  }
+  /**
+   * Preview apUSD mint output for a given LST amount
+   */
+  async previewMintApUSD(lst, lstAmount) {
+    return this.publicClient.readContract({
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "previewMintApUSD",
+      args: [lst, lstAmount]
+    });
+  }
+  /**
+   * Preview xBNB mint output for a given LST amount
+   */
+  async previewMintXBNB(lst, lstAmount) {
+    return this.publicClient.readContract({
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "previewMintXBNB",
+      args: [lst, lstAmount]
+    });
+  }
+  /**
+   * Preview LST output for redeeming apUSD
+   */
+  async previewRedeemApUSD(lst, apUSDAmount) {
+    return this.publicClient.readContract({
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "previewRedeemApUSD",
+      args: [lst, apUSDAmount]
+    });
+  }
+  /**
+   * Preview LST output for redeeming xBNB
+   */
+  async previewRedeemXBNB(lst, xBNBAmount) {
+    return this.publicClient.readContract({
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "previewRedeemXBNB",
+      args: [lst, xBNBAmount]
+    });
+  }
+  /**
+   * Get user's withdrawal request indices
+   */
+  async getUserWithdrawalIndices(user) {
+    const result = await this.publicClient.readContract({
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "getUserWithdrawalIndices",
+      args: [user]
+    });
+    return [...result];
+  }
+  /**
+   * Get withdrawal request status
+   */
+  async getWithdrawalStatus(requestIndex) {
+    const result = await this.publicClient.readContract({
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "getWithdrawalStatus",
+      args: [requestIndex]
+    });
+    return {
+      isClaimable: result[0],
+      bnbAmount: result[1]
+    };
+  }
+  // ============ Token Address Getters ============
+  async getWBNB() {
+    return this.publicClient.readContract({
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "wbnb"
+    });
+  }
+  async getUSDT() {
+    return this.publicClient.readContract({
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "usdt"
+    });
+  }
+  async getUSDC() {
+    return this.publicClient.readContract({
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "usdc"
+    });
+  }
+  async getSlisBNB() {
+    return this.publicClient.readContract({
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "slisBNB"
+    });
+  }
+  async getAsBNB() {
+    return this.publicClient.readContract({
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "asBNB"
+    });
+  }
+  async getWclisBNB() {
+    return this.publicClient.readContract({
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "wclisBNB"
+    });
+  }
+  async getApUSD() {
+    return this.publicClient.readContract({
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "apUSD"
+    });
+  }
+  async getXBNB() {
+    return this.publicClient.readContract({
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "xBNB"
+    });
+  }
+};
+var AspanRouterClient = class extends AspanRouterReadClient {
+  walletClient;
+  constructor(config) {
+    super(config);
+    if (config.walletClient) {
+      this.walletClient = config.walletClient;
+    } else if (config.account) {
+      this.walletClient = createWalletClient2({
+        account: config.account,
+        chain: this.chain,
+        transport: http2(config.rpcUrl)
+      });
+    } else {
+      throw new Error("Either walletClient or account must be provided");
+    }
+  }
+  // ============ Core Functions ============
+  /**
+   * Swap input token to LST and mint apUSD
+   */
+  async swapAndMintApUSD(params) {
+    const value = params.swapParams.inputToken === zeroAddress ? params.swapParams.inputAmount : 0n;
+    return this.walletClient.writeContract({
+      chain: this.chain,
+      account: this.walletClient.account,
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "swapAndMintApUSD",
+      args: [
+        {
+          inputToken: params.swapParams.inputToken,
+          inputAmount: params.swapParams.inputAmount,
+          targetLST: params.swapParams.targetLST,
+          minLSTOut: params.swapParams.minLSTOut,
+          poolFee: params.swapParams.poolFee,
+          useV2: params.swapParams.useV2
+        },
+        {
+          mintXBNB: params.mintParams.mintXBNB,
+          minMintOut: params.mintParams.minMintOut,
+          recipient: params.mintParams.recipient,
+          deadline: params.mintParams.deadline
+        }
+      ],
+      value
+    });
+  }
+  /**
+   * Swap input token to LST and mint xBNB
+   */
+  async swapAndMintXBNB(params) {
+    const value = params.swapParams.inputToken === zeroAddress ? params.swapParams.inputAmount : 0n;
+    return this.walletClient.writeContract({
+      chain: this.chain,
+      account: this.walletClient.account,
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "swapAndMintXBNB",
+      args: [
+        {
+          inputToken: params.swapParams.inputToken,
+          inputAmount: params.swapParams.inputAmount,
+          targetLST: params.swapParams.targetLST,
+          minLSTOut: params.swapParams.minLSTOut,
+          poolFee: params.swapParams.poolFee,
+          useV2: params.swapParams.useV2
+        },
+        {
+          mintXBNB: params.mintParams.mintXBNB,
+          minMintOut: params.mintParams.minMintOut,
+          recipient: params.mintParams.recipient,
+          deadline: params.mintParams.deadline
+        }
+      ],
+      value
+    });
+  }
+  /**
+   * Stake native BNB directly to LST and mint
+   */
+  async stakeAndMint(params) {
+    return this.walletClient.writeContract({
+      chain: this.chain,
+      account: this.walletClient.account,
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "stakeAndMint",
+      args: [
+        params.targetLST,
+        params.isXBNB,
+        params.minMintOut,
+        params.deadline
+      ],
+      value: params.value
+    });
+  }
+  // ============ Simplified Functions ============
+  /**
+   * Swap input token and mint apUSD using default LST
+   */
+  async swapAndMintApUSDDefault(params) {
+    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) {
+    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, value) {
+    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, value) {
+    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) {
+    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)
+   */
+  async mintXBNB(params) {
+    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]
+    });
+  }
+  /**
+   * Redeem apUSD for LST (no swap)
+   */
+  async redeemApUSD(params) {
+    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) {
+    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]
+    });
+  }
+  // ============ Redeem and Swap Functions ============
+  /**
+   * Redeem apUSD and swap LST to output token
+   */
+  async redeemApUSDAndSwap(params) {
+    return this.walletClient.writeContract({
+      chain: this.chain,
+      account: this.walletClient.account,
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "redeemApUSDAndSwap",
+      args: [
+        params.lst,
+        params.amount,
+        params.outputToken,
+        params.minOut,
+        params.deadline,
+        params.useV2,
+        params.poolFee
+      ]
+    });
+  }
+  /**
+   * Redeem xBNB and swap LST to output token
+   */
+  async redeemXBNBAndSwap(params) {
+    return this.walletClient.writeContract({
+      chain: this.chain,
+      account: this.walletClient.account,
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "redeemXBNBAndSwap",
+      args: [
+        params.lst,
+        params.amount,
+        params.outputToken,
+        params.minOut,
+        params.deadline,
+        params.useV2,
+        params.poolFee
+      ]
+    });
+  }
+  /**
+   * Redeem apUSD and instantly unstake LST to native BNB via DEX
+   */
+  async redeemApUSDAndUnstake(params) {
+    return this.walletClient.writeContract({
+      chain: this.chain,
+      account: this.walletClient.account,
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "redeemApUSDAndUnstake",
+      args: [params.lst, params.amount, params.minBNBOut, params.deadline]
+    });
+  }
+  /**
+   * Redeem xBNB and instantly unstake LST to native BNB via DEX
+   */
+  async redeemXBNBAndUnstake(params) {
+    return this.walletClient.writeContract({
+      chain: this.chain,
+      account: this.walletClient.account,
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "redeemXBNBAndUnstake",
+      args: [params.lst, params.amount, params.minBNBOut, params.deadline]
+    });
+  }
+  // ============ Native Unstake Functions ============
+  /**
+   * Redeem apUSD and request native unstake from Lista (starts unbonding period)
+   */
+  async redeemApUSDAndRequestUnstake(apUSDAmount) {
+    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)
+   */
+  async redeemXBNBAndRequestUnstake(xBNBAmount) {
+    return this.walletClient.writeContract({
+      chain: this.chain,
+      account: this.walletClient.account,
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "redeemXBNBAndRequestUnstake",
+      args: [xBNBAmount]
+    });
+  }
+  /**
+   * Claim BNB after unbonding period completes
+   */
+  async claimUnstake(requestIndex) {
+    return this.walletClient.writeContract({
+      chain: this.chain,
+      account: this.walletClient.account,
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "claimUnstake",
+      args: [requestIndex]
+    });
+  }
+  // ============ Transaction Helpers ============
+  /**
+   * Wait for transaction confirmation
+   */
+  async waitForTransaction(hash) {
+    return this.publicClient.waitForTransactionReceipt({ hash });
+  }
+};
+function createRouterReadClient(routerAddress, rpcUrl) {
+  return new AspanRouterReadClient({
+    routerAddress,
+    chain: bsc2,
+    rpcUrl
+  });
+}
+function createRouterClient(routerAddress, account, rpcUrl) {
+  return new AspanRouterClient({
+    routerAddress,
+    account,
+    chain: bsc2,
+    rpcUrl
+  });
+}
+function createRouterTestnetReadClient(routerAddress, rpcUrl) {
+  return new AspanRouterReadClient({
+    routerAddress,
+    chain: bscTestnet2,
+    rpcUrl
+  });
+}
+function createRouterTestnetClient(routerAddress, account, rpcUrl) {
+  return new AspanRouterClient({
+    routerAddress,
+    account,
+    chain: bscTestnet2,
+    rpcUrl
+  });
+}
+
 // src/index.ts
 var PRECISION = 10n ** 18n;
 var BPS_PRECISION = 10000n;
@@ -1449,15 +2608,22 @@ function calculateAPY(previousRate, currentRate, periodDays) {
 export {
   AspanClient,
   AspanReadClient,
+  AspanRouterClient,
+  AspanRouterReadClient,
   BPS_PRECISION,
   DiamondABI,
   PRECISION,
   PRICE_PRECISION,
+  RouterABI,
   calculateAPY,
   createAspanClient,
   createAspanReadClient,
   createAspanTestnetClient,
   createAspanTestnetReadClient,
+  createRouterClient,
+  createRouterReadClient,
+  createRouterTestnetClient,
+  createRouterTestnetReadClient,
   formatAmount,
   formatCR,
   formatFeeBPS,