@aspan/sdk 0.3.0 → 0.4.0

package/src/__tests__/router.test.ts

@@ -10,7 +10,7 @@
 
 import { describe, it, expect, beforeAll } from "vitest";
 import { privateKeyToAccount } from "viem/accounts";
-import { createPublicClient, http, parseEther, zeroAddress, type Address } from "viem";
+import { createPublicClient, http, parseEther, formatEther, zeroAddress, type Address } from "viem";
 import { bsc } from "viem/chains";
 import {
   AspanRouterClient,
@@ -18,23 +18,24 @@ import {
   encodeV3Path,
   parseAmount,
   formatAmount,
+  BSC_ADDRESSES,
 } from "../index";
 
 // ============ Configuration ============
 
-const ROUTER = "0xf63f34f7e9608ae7d3a6f5b06ce423d9f9043648" as Address;
+const ROUTER = BSC_ADDRESSES.router;
 
 const TOKENS = {
-  WBNB: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c" as Address,
-  USDT: "0x55d398326f99059fF775485246999027B3197955" as Address,
-  slisBNB: "0xB0b84D294e0C75A6abe60171b70edEb2EFd14A1B" as Address,
-  apUSD: "0x1977097E2E5697A6DD91b6732F368a14F50f6B3d" as Address,
-  xBNB: "0xB78eB4d5928bAb158Eb23c3154544084cD2661d5" as Address,
+  WBNB: BSC_ADDRESSES.WBNB,
+  USDT: BSC_ADDRESSES.USDT,
+  slisBNB: BSC_ADDRESSES.slisBNB,
+  apUSD: BSC_ADDRESSES.apUSD,
+  xBNB: BSC_ADDRESSES.xBNB,
 };
 
-// Minimal amounts
-const BNB_AMOUNT = parseEther("0.0005");  // ~$0.30
-const USDT_AMOUNT = parseAmount("0.5");  // $0.50
+// Test amounts - must be above Lista minimum unstake (~0.001 BNB worth)
+const BNB_AMOUNT = parseEther("0.002");  // ~$1.20
+const USDT_AMOUNT = parseAmount("2");    // $2.00
 
 const ERC20_ABI = [
   { name: "balanceOf", type: "function", inputs: [{ type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
@@ -121,10 +122,12 @@ describe("AspanRouter SDK", () => {
 
     it("should preview mint/redeem", async () => {
       const lstAmount = parseAmount("1");
-      const apUSDOut = await readClient.previewMintApUSD(TOKENS.slisBNB, lstAmount);
+      // Use new unified previewMint(lst, amount, mintXBNB)
+      const apUSDOut = await readClient.previewMint(TOKENS.slisBNB, lstAmount, false);
       expect(apUSDOut).toBeGreaterThan(parseAmount("400"));
       
-      const lstBack = await readClient.previewRedeemApUSD(TOKENS.slisBNB, apUSDOut);
+      // Use new unified previewRedeem(lst, redeemXBNB, amount)
+      const lstBack = await readClient.previewRedeem(TOKENS.slisBNB, false, apUSDOut);
       const ratio = Number(lstBack) / Number(lstAmount);
       expect(ratio).toBeGreaterThan(0.95);
       console.log(`Preview: 1 slisBNB → ${formatAmount(apUSDOut)} apUSD (${(ratio * 100).toFixed(1)}% round-trip)`);
@@ -149,11 +152,17 @@ describe("AspanRouter SDK", () => {
       console.log(`  Staking ${formatAmount(BNB_AMOUNT)} BNB...`);
       const apUSDBefore = await getBalance(TOKENS.apUSD);
       
-      const mintHash = await writeClient.stakeAndMintApUSD(0n, BNB_AMOUNT);
+      const mintHash = await writeClient.stakeAndMint({
+        targetLST: TOKENS.slisBNB,
+        isXBNB: false,
+        minMintOut: 0n,
+        deadline: BigInt(Math.floor(Date.now() / 1000) + 3600),
+        value: BNB_AMOUNT,
+      });
       const mintReceipt = await publicClient.waitForTransactionReceipt({ hash: mintHash });
       await sleep(2000);
       expect(mintReceipt.status).toBe("success");
-      await sleep(2000); // Wait for RPC state sync
+      await sleep(2000);
       
       const apUSDAfter = await getBalance(TOKENS.apUSD);
       const apUSDMinted = apUSDAfter - apUSDBefore;
@@ -166,9 +175,10 @@ describe("AspanRouter SDK", () => {
       
       const slisBNBBefore = await getBalance(TOKENS.slisBNB);
       
-      const redeemHash = await writeClient.redeemApUSD({
+      const redeemHash = await writeClient.redeem({
         lst: TOKENS.slisBNB,
-        apUSDAmount: apUSDMinted,
+        redeemXBNB: false,
+        amount: apUSDMinted,
         minOut: 0n,
       });
       const redeemReceipt = await publicClient.waitForTransactionReceipt({ hash: redeemHash });
@@ -185,9 +195,10 @@ describe("AspanRouter SDK", () => {
       await approve(TOKENS.slisBNB, slisBNBReceived);
       
       const apUSDBefore2 = await getBalance(TOKENS.apUSD);
-      const directMintHash = await writeClient.mintApUSD({
+      const directMintHash = await writeClient.mint({
         lst: TOKENS.slisBNB,
         lstAmount: slisBNBReceived,
+        mintXBNB: false,
         minOut: 0n,
       });
       await publicClient.waitForTransactionReceipt({ hash: directMintHash });
@@ -203,7 +214,10 @@ describe("AspanRouter SDK", () => {
       await approve(TOKENS.apUSD, directMinted);
       
       const indicesBefore = await readClient.getUserWithdrawalIndices(account.address);
-      const unstakeHash = await writeClient.redeemApUSDAndRequestUnstake(directMinted);
+      const unstakeHash = await writeClient.redeemAndRequestUnstake({
+        redeemXBNB: false,
+        amount: directMinted,
+      });
       await publicClient.waitForTransactionReceipt({ hash: unstakeHash });
       await sleep(2000);
       
@@ -220,7 +234,13 @@ describe("AspanRouter SDK", () => {
       console.log(`  Staking ${formatAmount(BNB_AMOUNT)} BNB...`);
       const xBNBBefore = await getBalance(TOKENS.xBNB);
       
-      const mintHash = await writeClient.stakeAndMintXBNB(0n, BNB_AMOUNT);
+      const mintHash = await writeClient.stakeAndMint({
+        targetLST: TOKENS.slisBNB,
+        isXBNB: true,
+        minMintOut: 0n,
+        deadline: BigInt(Math.floor(Date.now() / 1000) + 3600),
+        value: BNB_AMOUNT,
+      });
       const mintReceipt = await publicClient.waitForTransactionReceipt({ hash: mintHash });
       await sleep(2000);
       expect(mintReceipt.status).toBe("success");
@@ -236,9 +256,10 @@ describe("AspanRouter SDK", () => {
       
       const slisBNBBefore = await getBalance(TOKENS.slisBNB);
       
-      const redeemHash = await writeClient.redeemXBNB({
+      const redeemHash = await writeClient.redeem({
         lst: TOKENS.slisBNB,
-        xBNBAmount: xBNBMinted,
+        redeemXBNB: true,
+        amount: xBNBMinted,
         minOut: 0n,
       });
       const redeemReceipt = await publicClient.waitForTransactionReceipt({ hash: redeemHash });
@@ -255,9 +276,10 @@ describe("AspanRouter SDK", () => {
       await approve(TOKENS.slisBNB, slisBNBReceived2);
       
       const xBNBBefore2 = await getBalance(TOKENS.xBNB);
-      const directMintHash = await writeClient.mintXBNB({
+      const directMintHash = await writeClient.mint({
         lst: TOKENS.slisBNB,
         lstAmount: slisBNBReceived2,
+        mintXBNB: true,
         minOut: 0n,
       });
       await publicClient.waitForTransactionReceipt({ hash: directMintHash });
@@ -285,7 +307,7 @@ describe("AspanRouter SDK", () => {
       
       const apUSDBefore = await getBalance(TOKENS.apUSD);
       
-      const mintHash = await writeClient.swapAndMintApUSD({
+      const mintHash = await writeClient.swapAndMint({
         swapParams: {
           inputToken: TOKENS.USDT,
           inputAmount: USDT_AMOUNT,
@@ -294,6 +316,7 @@ describe("AspanRouter SDK", () => {
           poolFee: 2500,
         },
         mintParams: {
+          mintXBNB: false,
           minMintOut: 0n,
           recipient: zeroAddress,
           deadline: BigInt(Math.floor(Date.now() / 1000) + 3600),
@@ -315,12 +338,14 @@ describe("AspanRouter SDK", () => {
       const usdtBefore = await getBalance(TOKENS.USDT);
       const path = encodeV3Path([TOKENS.slisBNB, TOKENS.WBNB, TOKENS.USDT], [500, 500]);
       
-      const redeemHash = await writeClient.redeemApUSDAndSwap({
+      const redeemHash = await writeClient.redeemAndSwap({
         lst: TOKENS.slisBNB,
+        redeemXBNB: false,
         amount: apUSDMinted,
         path,
         minOut: 0n,
         deadline: BigInt(Math.floor(Date.now() / 1000) + 3600),
+        unwrapBNB: false,
       });
       const redeemReceipt = await publicClient.waitForTransactionReceipt({ hash: redeemHash });
       await sleep(2000);
@@ -348,7 +373,7 @@ describe("AspanRouter SDK", () => {
       
       const xBNBBefore = await getBalance(TOKENS.xBNB);
       
-      const mintHash = await writeClient.swapAndMintXBNB({
+      const mintHash = await writeClient.swapAndMint({
         swapParams: {
           inputToken: TOKENS.USDT,
           inputAmount: USDT_AMOUNT,
@@ -357,6 +382,7 @@ describe("AspanRouter SDK", () => {
           poolFee: 2500,
         },
         mintParams: {
+          mintXBNB: true,
           minMintOut: 0n,
           recipient: zeroAddress,
           deadline: BigInt(Math.floor(Date.now() / 1000) + 3600),
@@ -377,9 +403,10 @@ describe("AspanRouter SDK", () => {
       
       const slisBNBBefore = await getBalance(TOKENS.slisBNB);
       
-      const redeemHash = await writeClient.redeemXBNB({
+      const redeemHash = await writeClient.redeem({
         lst: TOKENS.slisBNB,
-        xBNBAmount: xBNBMinted,
+        redeemXBNB: true,
+        amount: xBNBMinted,
         minOut: 0n,
       });
       const redeemReceipt = await publicClient.waitForTransactionReceipt({ hash: redeemHash });
@@ -390,5 +417,407 @@ describe("AspanRouter SDK", () => {
       console.log(`  Received: ${formatAmount(slisBNBAfter - slisBNBBefore)} slisBNB ✓`);
       expect(slisBNBAfter).toBeGreaterThan(slisBNBBefore);
     }, 180000);
+
+    // Test 5: swapAndMintDefault apUSD (USDT → apUSD with default LST)
+    it.skipIf(!HAS_PRIVATE_KEY)("swapAndMintDefault: USDT → apUSD", async () => {
+      console.log(`\n[E2E 5] swapAndMintDefault: USDT → apUSD`);
+      
+      const usdtBalance = await getBalance(TOKENS.USDT);
+      if (usdtBalance < USDT_AMOUNT) {
+        console.log(`  ⚠️ Insufficient USDT (${formatAmount(usdtBalance)}), skipping`);
+        return;
+      }
+
+      console.log(`  Swapping ${formatAmount(USDT_AMOUNT)} USDT → apUSD (default LST)...`);
+      await approve(TOKENS.USDT, USDT_AMOUNT);
+      
+      const apUSDBefore = await getBalance(TOKENS.apUSD);
+      
+      const deadline = BigInt(Math.floor(Date.now() / 1000) + 600);
+      const mintHash = await writeClient.swapAndMintDefault({
+        inputToken: TOKENS.USDT,
+        inputAmount: USDT_AMOUNT,
+        mintXBNB: false,
+        minMintOut: 0n,
+        deadline,
+      });
+      const mintReceipt = await publicClient.waitForTransactionReceipt({ hash: mintHash });
+      await sleep(2000);
+      expect(mintReceipt.status).toBe("success");
+      
+      const apUSDAfter = await getBalance(TOKENS.apUSD);
+      const apUSDMinted = apUSDAfter - apUSDBefore;
+      console.log(`  Minted: ${formatAmount(apUSDMinted)} apUSD ✓`);
+      expect(apUSDMinted).toBeGreaterThan(0n);
+    }, 180000);
+
+    // Test 6: swapAndMintDefault xBNB (USDT → xBNB with default LST)
+    it.skipIf(!HAS_PRIVATE_KEY)("swapAndMintDefault: USDT → xBNB", async () => {
+      console.log(`\n[E2E 6] swapAndMintDefault: USDT → xBNB`);
+      
+      const usdtBalance = await getBalance(TOKENS.USDT);
+      if (usdtBalance < USDT_AMOUNT) {
+        console.log(`  ⚠️ Insufficient USDT (${formatAmount(usdtBalance)}), skipping`);
+        return;
+      }
+
+      console.log(`  Swapping ${formatAmount(USDT_AMOUNT)} USDT → xBNB (default LST)...`);
+      await approve(TOKENS.USDT, USDT_AMOUNT);
+      
+      const xBNBBefore = await getBalance(TOKENS.xBNB);
+      
+      const deadline = BigInt(Math.floor(Date.now() / 1000) + 600);
+      const mintHash = await writeClient.swapAndMintDefault({
+        inputToken: TOKENS.USDT,
+        inputAmount: USDT_AMOUNT,
+        mintXBNB: true,
+        minMintOut: 0n,
+        deadline,
+      });
+      const mintReceipt = await publicClient.waitForTransactionReceipt({ hash: mintHash });
+      await sleep(2000);
+      expect(mintReceipt.status).toBe("success");
+      
+      const xBNBAfter = await getBalance(TOKENS.xBNB);
+      const xBNBMinted = xBNBAfter - xBNBBefore;
+      console.log(`  Minted: ${formatAmount(xBNBMinted, 8)} xBNB ✓`);
+      expect(xBNBMinted).toBeGreaterThan(0n);
+    }, 180000);
+
+    // Test 7: redeemAndSwap xBNB → USDT via V3
+    it.skipIf(!HAS_PRIVATE_KEY)("redeemAndSwap: xBNB → USDT", async () => {
+      console.log(`\n[E2E 7] redeemAndSwap: xBNB → USDT`);
+      
+      const xBNBBalance = await getBalance(TOKENS.xBNB);
+      if (xBNBBalance === 0n) {
+        console.log(`  ⚠️ No xBNB balance, skipping`);
+        return;
+      }
+
+      const redeemAmount = xBNBBalance > parseEther("0.0001") ? parseEther("0.0001") : xBNBBalance;
+      console.log(`  Redeeming ${formatAmount(redeemAmount, 8)} xBNB → USDT...`);
+      await approve(TOKENS.xBNB, redeemAmount);
+      
+      const usdtBefore = await getBalance(TOKENS.USDT);
+      const path = encodeV3Path([TOKENS.slisBNB, TOKENS.WBNB, TOKENS.USDT], [500, 500]);
+      
+      const redeemHash = await writeClient.redeemAndSwap({
+        lst: TOKENS.slisBNB,
+        redeemXBNB: true,
+        amount: redeemAmount,
+        path,
+        minOut: 0n,
+        deadline: BigInt(Math.floor(Date.now() / 1000) + 3600),
+        unwrapBNB: false,
+      });
+      const redeemReceipt = await publicClient.waitForTransactionReceipt({ hash: redeemHash });
+      await sleep(2000);
+      expect(redeemReceipt.status).toBe("success");
+      
+      const usdtAfter = await getBalance(TOKENS.USDT);
+      console.log(`  Received: ${formatAmount(usdtAfter - usdtBefore)} USDT ✓`);
+      expect(usdtAfter).toBeGreaterThan(usdtBefore);
+    }, 180000);
+
+    // Test 8: redeemAndRequestUnstake xBNB → Lista unstake
+    it.skipIf(!HAS_PRIVATE_KEY)("redeemAndRequestUnstake: xBNB → Lista unstake", async () => {
+      console.log(`\n[E2E 8] redeemAndRequestUnstake: xBNB → Lista unstake`);
+      
+      // First stake fresh BNB → xBNB to ensure enough for Lista minimum
+      console.log(`  Staking 0.002 BNB → xBNB first...`);
+      const stakeHash = await writeClient.stakeAndMint({
+        targetLST: TOKENS.slisBNB,
+        isXBNB: true,
+        minMintOut: 0n,
+        deadline: BigInt(Math.floor(Date.now() / 1000) + 3600),
+        value: parseEther("0.002"),
+      });
+      await publicClient.waitForTransactionReceipt({ hash: stakeHash });
+      await sleep(2000);
+      
+      const xBNBBalance = await getBalance(TOKENS.xBNB);
+      console.log(`  Requesting unstake for ${formatAmount(xBNBBalance, 8)} xBNB...`);
+      await approve(TOKENS.xBNB, xBNBBalance);
+      
+      const indicesBefore = await readClient.getUserWithdrawalIndices(account.address);
+      
+      const unstakeHash = await writeClient.redeemAndRequestUnstake({
+        redeemXBNB: true,
+        amount: xBNBBalance,
+      });
+      const unstakeReceipt = await publicClient.waitForTransactionReceipt({ hash: unstakeHash });
+      await sleep(2000);
+      expect(unstakeReceipt.status).toBe("success");
+      
+      const indicesAfter = await readClient.getUserWithdrawalIndices(account.address);
+      expect(indicesAfter.length).toBeGreaterThan(indicesBefore.length);
+      console.log(`  Unstake requested ✓ (new indices: ${indicesAfter.length - indicesBefore.length})`);
+    }, 180000);
+
+    // Test 9: stakeAndMint xBNB
+    it.skipIf(!HAS_PRIVATE_KEY)("stakeAndMint: BNB → xBNB", async () => {
+      console.log(`\n[E2E 9] stakeAndMint: BNB → xBNB`);
+      
+      const amount = parseEther("0.001");
+      console.log(`  Staking ${formatEther(amount)} BNB → xBNB...`);
+      
+      const xBNBBefore = await getBalance(TOKENS.xBNB);
+      
+      const hash = await writeClient.stakeAndMint({
+        targetLST: TOKENS.slisBNB,
+        isXBNB: true,
+        minMintOut: 0n,
+        deadline: BigInt(Math.floor(Date.now() / 1000) + 3600),
+        value: amount,
+      });
+      const receipt = await publicClient.waitForTransactionReceipt({ hash });
+      await sleep(2000);
+      expect(receipt.status).toBe("success");
+      
+      const xBNBAfter = await getBalance(TOKENS.xBNB);
+      const minted = xBNBAfter - xBNBBefore;
+      console.log(`  Minted: ${formatAmount(minted, 8)} xBNB ✓`);
+      expect(minted).toBeGreaterThan(0n);
+    }, 180000);
+
+    // Test 10: mint xBNB (direct LST → xBNB)
+    it.skipIf(!HAS_PRIVATE_KEY)("mint: slisBNB → xBNB", async () => {
+      console.log(`\n[E2E 10] mint: slisBNB → xBNB`);
+      
+      const slisBNBBalance = await getBalance(TOKENS.slisBNB);
+      if (slisBNBBalance === 0n) {
+        console.log(`  ⚠️ No slisBNB balance, skipping`);
+        return;
+      }
+
+      const amount = slisBNBBalance > parseEther("0.001") ? parseEther("0.001") : slisBNBBalance;
+      console.log(`  Minting xBNB from ${formatEther(amount)} slisBNB...`);
+      await approve(TOKENS.slisBNB, amount);
+      
+      const xBNBBefore = await getBalance(TOKENS.xBNB);
+      
+      const hash = await writeClient.mint({
+        lst: TOKENS.slisBNB,
+        lstAmount: amount,
+        mintXBNB: true,
+        minOut: 0n,
+      });
+      const receipt = await publicClient.waitForTransactionReceipt({ hash });
+      await sleep(2000);
+      expect(receipt.status).toBe("success");
+      
+      const xBNBAfter = await getBalance(TOKENS.xBNB);
+      const minted = xBNBAfter - xBNBBefore;
+      console.log(`  Minted: ${formatAmount(minted, 8)} xBNB ✓`);
+      expect(minted).toBeGreaterThan(0n);
+    }, 180000);
+
+    // Test 11: redeem xBNB → slisBNB
+    it.skipIf(!HAS_PRIVATE_KEY)("redeem: xBNB → slisBNB", async () => {
+      console.log(`\n[E2E 11] redeem: xBNB → slisBNB`);
+      
+      const xBNBBalance = await getBalance(TOKENS.xBNB);
+      if (xBNBBalance === 0n) {
+        console.log(`  ⚠️ No xBNB balance, skipping`);
+        return;
+      }
+
+      const amount = xBNBBalance > parseEther("0.0001") ? parseEther("0.0001") : xBNBBalance;
+      console.log(`  Redeeming ${formatAmount(amount, 8)} xBNB → slisBNB...`);
+      await approve(TOKENS.xBNB, amount);
+      
+      const slisBNBBefore = await getBalance(TOKENS.slisBNB);
+      
+      const hash = await writeClient.redeem({
+        lst: TOKENS.slisBNB,
+        redeemXBNB: true,
+        amount,
+        minOut: 0n,
+      });
+      const receipt = await publicClient.waitForTransactionReceipt({ hash });
+      await sleep(2000);
+      expect(receipt.status).toBe("success");
+      
+      const slisBNBAfter = await getBalance(TOKENS.slisBNB);
+      const received = slisBNBAfter - slisBNBBefore;
+      console.log(`  Received: ${formatEther(received)} slisBNB ✓`);
+      expect(received).toBeGreaterThan(0n);
+    }, 180000);
+
+    // Test 12: stakeAndMint apUSD
+    it.skipIf(!HAS_PRIVATE_KEY)("stakeAndMint: BNB → apUSD (may skip if disabled)", async () => {
+      console.log(`\n[E2E 12] stakeAndMint: BNB → apUSD`);
+      
+      const amount = parseEther("0.001");
+      console.log(`  Staking ${formatEther(amount)} BNB → apUSD...`);
+      
+      const apUSDBefore = await getBalance(TOKENS.apUSD);
+      
+      try {
+        const hash = await writeClient.stakeAndMint({
+          targetLST: TOKENS.slisBNB,
+          isXBNB: false,
+          minMintOut: 0n,
+          deadline: BigInt(Math.floor(Date.now() / 1000) + 3600),
+          value: amount,
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash });
+        await sleep(2000);
+        
+        if (receipt.status === "success") {
+          const apUSDAfter = await getBalance(TOKENS.apUSD);
+          const minted = apUSDAfter - apUSDBefore;
+          console.log(`  Minted: ${formatEther(minted)} apUSD ✓`);
+          expect(minted).toBeGreaterThan(0n);
+        } else {
+          console.log(`  ⚠️ Transaction reverted (apUSD minting may be disabled)`);
+        }
+      } catch (e: any) {
+        if (e.message?.includes("MintingDisabled") || e.message?.includes("revert")) {
+          console.log(`  ⚠️ apUSD minting is disabled, skipping`);
+        } else {
+          throw e;
+        }
+      }
+    }, 180000);
+
+    // Test 13: mint apUSD (direct LST → apUSD)
+    it.skipIf(!HAS_PRIVATE_KEY)("mint: slisBNB → apUSD (may skip if disabled)", async () => {
+      console.log(`\n[E2E 13] mint: slisBNB → apUSD`);
+      
+      const slisBNBBalance = await getBalance(TOKENS.slisBNB);
+      if (slisBNBBalance === 0n) {
+        console.log(`  ⚠️ No slisBNB balance, skipping`);
+        return;
+      }
+
+      const amount = slisBNBBalance > parseEther("0.001") ? parseEther("0.001") : slisBNBBalance;
+      console.log(`  Minting apUSD from ${formatEther(amount)} slisBNB...`);
+      await approve(TOKENS.slisBNB, amount);
+      
+      const apUSDBefore = await getBalance(TOKENS.apUSD);
+      
+      try {
+        const hash = await writeClient.mint({
+          lst: TOKENS.slisBNB,
+          lstAmount: amount,
+          mintXBNB: false,
+          minOut: 0n,
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash });
+        await sleep(2000);
+        
+        if (receipt.status === "success") {
+          const apUSDAfter = await getBalance(TOKENS.apUSD);
+          const minted = apUSDAfter - apUSDBefore;
+          console.log(`  Minted: ${formatEther(minted)} apUSD ✓`);
+          expect(minted).toBeGreaterThan(0n);
+        } else {
+          console.log(`  ⚠️ Transaction reverted (apUSD minting may be disabled)`);
+        }
+      } catch (e: any) {
+        if (e.message?.includes("MintingDisabled") || e.message?.includes("revert")) {
+          console.log(`  ⚠️ apUSD minting is disabled, skipping`);
+        } else {
+          throw e;
+        }
+      }
+    }, 180000);
+
+    // Test 14: redeem apUSD → slisBNB
+    it.skipIf(!HAS_PRIVATE_KEY)("redeem: apUSD → slisBNB", async () => {
+      console.log(`\n[E2E 14] redeem: apUSD → slisBNB`);
+      
+      const apUSDBalance = await getBalance(TOKENS.apUSD);
+      if (apUSDBalance === 0n) {
+        console.log(`  ⚠️ No apUSD balance, skipping`);
+        return;
+      }
+
+      const amount = apUSDBalance > parseEther("0.1") ? parseEther("0.1") : apUSDBalance;
+      console.log(`  Redeeming ${formatEther(amount)} apUSD → slisBNB...`);
+      await approve(TOKENS.apUSD, amount);
+      
+      const slisBNBBefore = await getBalance(TOKENS.slisBNB);
+      
+      const hash = await writeClient.redeem({
+        lst: TOKENS.slisBNB,
+        redeemXBNB: false,
+        amount,
+        minOut: 0n,
+      });
+      const receipt = await publicClient.waitForTransactionReceipt({ hash });
+      await sleep(2000);
+      expect(receipt.status).toBe("success");
+      
+      const slisBNBAfter = await getBalance(TOKENS.slisBNB);
+      const received = slisBNBAfter - slisBNBBefore;
+      console.log(`  Received: ${formatEther(received)} slisBNB ✓`);
+      expect(received).toBeGreaterThan(0n);
+    }, 180000);
+
+    // Test 15: redeemAndSwap apUSD → USDT
+    it.skipIf(!HAS_PRIVATE_KEY)("redeemAndSwap: apUSD → USDT", async () => {
+      console.log(`\n[E2E 15] redeemAndSwap: apUSD → USDT`);
+      
+      const apUSDBalance = await getBalance(TOKENS.apUSD);
+      if (apUSDBalance === 0n) {
+        console.log(`  ⚠️ No apUSD balance, skipping`);
+        return;
+      }
+
+      const amount = apUSDBalance > parseAmount("1") ? parseAmount("1") : apUSDBalance;
+      console.log(`  Redeeming ${formatEther(amount)} apUSD → USDT...`);
+      await approve(TOKENS.apUSD, amount);
+      
+      const usdtBefore = await getBalance(TOKENS.USDT);
+      const path = encodeV3Path([TOKENS.slisBNB, TOKENS.WBNB, TOKENS.USDT], [500, 500]);
+      
+      const hash = await writeClient.redeemAndSwap({
+        lst: TOKENS.slisBNB,
+        redeemXBNB: false,
+        amount,
+        path,
+        minOut: 0n,
+        deadline: BigInt(Math.floor(Date.now() / 1000) + 3600),
+        unwrapBNB: false,
+      });
+      const receipt = await publicClient.waitForTransactionReceipt({ hash });
+      await sleep(2000);
+      expect(receipt.status).toBe("success");
+      
+      const usdtAfter = await getBalance(TOKENS.USDT);
+      const received = usdtAfter - usdtBefore;
+      console.log(`  Received: ${formatAmount(received)} USDT ✓`);
+      expect(received).toBeGreaterThan(0n);
+    }, 180000);
+
+    // Test 16: redeemAndRequestUnstake apUSD → Lista unstake
+    it.skipIf(!HAS_PRIVATE_KEY)("redeemAndRequestUnstake: apUSD → Lista unstake", async () => {
+      console.log(`\n[E2E 16] redeemAndRequestUnstake: apUSD → Lista unstake`);
+      
+      const apUSDBalance = await getBalance(TOKENS.apUSD);
+      if (apUSDBalance === 0n) {
+        console.log(`  ⚠️ No apUSD balance, skipping`);
+        return;
+      }
+
+      console.log(`  Requesting unstake for ${formatAmount(apUSDBalance)} apUSD...`);
+      await approve(TOKENS.apUSD, apUSDBalance);
+      
+      const indicesBefore = await readClient.getUserWithdrawalIndices(account.address);
+      
+      const hash = await writeClient.redeemAndRequestUnstake({
+        redeemXBNB: false,
+        amount: apUSDBalance,
+      });
+      const receipt = await publicClient.waitForTransactionReceipt({ hash });
+      await sleep(2000);
+      expect(receipt.status).toBe("success");
+      
+      const indicesAfter = await readClient.getUserWithdrawalIndices(account.address);
+      expect(indicesAfter.length).toBeGreaterThan(indicesBefore.length);
+      console.log(`  Unstake requested ✓ (new indices: ${indicesAfter.length - indicesBefore.length})`);
+    }, 180000);
   });
 });