@aspan/sdk 0.3.0 → 0.3.1

package/README.md

@@ -16,7 +16,7 @@ pnpm add @aspan/sdk
 | Contract | Address |
 |----------|---------|
 | **Diamond (Main Entry)** | `0x10d25Ae0690533e0BA9E64EC7ae77dbD4fE8A46f` |
-| **Router** | `0xf63f34f7e9608ae7d3a6f5b06ce423d9f9043648` |
+| **Router** | `0x159B2990966B0E4f07cD58c9Def513EA1fF81c0C` |
 | **wclisBNB** | `0x439faaC2229559121C4Ad4fd8B3FE13Dff038046` |
 | **ApUSD** | `0x1977097E2E5697A6DD91b6732F368a14F50f6B3d` |
 | **XBNB** | `0xB78eB4d5928bAb158Eb23c3154544084cD2661d5` |
@@ -98,7 +98,7 @@ import { createRouterClient, AspanRouterClient } from "@aspan/sdk";
 import { privateKeyToAccount } from "viem/accounts";
 import { zeroAddress } from "viem";
 
-const ROUTER = "0xf63f34f7e9608ae7d3a6f5b06ce423d9f9043648";
+const ROUTER = "0x159B2990966B0E4f07cD58c9Def513EA1fF81c0C";
 
 // Node.js
 const account = privateKeyToAccount("0x...");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aspan/sdk",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "TypeScript SDK for Aspan Protocol - LST-backed stablecoin on BNB Chain",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -22,6 +22,8 @@
     "lint": "eslint src --ext .ts",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
+    "test:fork": "ANVIL_RPC=http://127.0.0.1:8545 vitest run fork.test.ts",
+    "test:e2e": "vitest run router.test.ts",
     "test:watch": "vitest",
     "clean": "rm -rf dist",
     "prepublishOnly": "npm run build",

package/src/__tests__/fork.test.ts

@@ -0,0 +1,206 @@
+/**
+ * AspanRouter SDK Fork Tests
+ * 
+ * Uses Anvil fork for time manipulation and state control.
+ * Run with: npm run test:fork
+ * 
+ * These tests require a local Anvil fork:
+ *   anvil --fork-url https://bsc-dataseed.binance.org/ --fork-block-number <recent>
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { privateKeyToAccount } from "viem/accounts";
+import { createPublicClient, createTestClient, createWalletClient, http, parseEther, type Address } from "viem";
+import { bsc } from "viem/chains";
+import {
+  AspanRouterClient,
+  AspanRouterReadClient,
+  formatAmount,
+} from "../index";
+
+// ============ Configuration ============
+
+const ROUTER = "0x159B2990966B0E4f07cD58c9Def513EA1fF81c0C" as Address;
+const ANVIL_RPC = process.env.ANVIL_RPC || "http://127.0.0.1:8545";
+
+const TOKENS = {
+  WBNB: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c" as Address,
+  USDT: "0x55d398326f99059fF775485246999027B3197955" as Address,
+  slisBNB: "0xB0b84D294e0C75A6abe60171b70edEb2EFd14A1B" as Address,
+  apUSD: "0x1977097E2E5697A6DD91b6732F368a14F50f6B3d" as Address,
+  xBNB: "0xB78eB4d5928bAb158Eb23c3154544084cD2661d5" as Address,
+};
+
+const ERC20_ABI = [
+  { name: "balanceOf", type: "function", inputs: [{ type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { name: "approve", type: "function", inputs: [{ type: "address" }, { type: "uint256" }], outputs: [{ type: "bool" }], stateMutability: "nonpayable" },
+] as const;
+
+// Use Anvil's default test account
+const TEST_PRIVATE_KEY = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";
+
+// Check if Anvil is available
+const isAnvilAvailable = async (): Promise<boolean> => {
+  try {
+    const client = createPublicClient({ transport: http(ANVIL_RPC) });
+    await client.getChainId();
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+// ============ Tests ============
+
+describe.skipIf(!(await isAnvilAvailable()))("Fork Tests (Anvil)", () => {
+  let readClient: AspanRouterReadClient;
+  let writeClient: AspanRouterClient;
+  let publicClient: ReturnType<typeof createPublicClient>;
+  let testClient: ReturnType<typeof createTestClient>;
+  let account: ReturnType<typeof privateKeyToAccount>;
+
+  const getBalance = async (token: Address): Promise<bigint> => {
+    return publicClient.readContract({
+      address: token,
+      abi: ERC20_ABI,
+      functionName: "balanceOf",
+      args: [account.address],
+    }) as Promise<bigint>;
+  };
+
+  const approve = async (token: Address, amount: bigint) => {
+    const hash = await writeClient.walletClient.writeContract({
+      address: token,
+      abi: ERC20_ABI,
+      functionName: "approve",
+      args: [ROUTER, amount],
+    });
+    await publicClient.waitForTransactionReceipt({ hash });
+  };
+
+  beforeAll(async () => {
+    account = privateKeyToAccount(TEST_PRIVATE_KEY);
+
+    publicClient = createPublicClient({
+      chain: bsc,
+      transport: http(ANVIL_RPC),
+    });
+
+    testClient = createTestClient({
+      chain: bsc,
+      transport: http(ANVIL_RPC),
+      mode: "anvil",
+    });
+
+    readClient = new AspanRouterReadClient({
+      routerAddress: ROUTER,
+      chain: bsc,
+      rpcUrl: ANVIL_RPC,
+    });
+
+    writeClient = new AspanRouterClient({
+      routerAddress: ROUTER,
+      account,
+      chain: bsc,
+      rpcUrl: ANVIL_RPC,
+    });
+
+    // Fund test account with BNB
+    await testClient.setBalance({
+      address: account.address,
+      value: parseEther("10"),
+    });
+
+    console.log(`📍 Fork Test Wallet: ${account.address}`);
+  });
+
+  describe("claimUnstake (with time manipulation)", () => {
+    it("should claim unstake after waiting period", async () => {
+      console.log(`\n[Fork 1] claimUnstake after time manipulation`);
+
+      // Step 1: Create some apUSD via stake
+      console.log(`  Staking BNB → apUSD...`);
+      const mintHash = await writeClient.stakeAndMintApUSD(0n, parseEther("0.01"));
+      await publicClient.waitForTransactionReceipt({ hash: mintHash });
+      
+      const apUSDBalance = await getBalance(TOKENS.apUSD);
+      console.log(`  Minted: ${formatAmount(apUSDBalance)} apUSD`);
+      expect(apUSDBalance).toBeGreaterThan(0n);
+
+      // Step 2: Request unstake
+      console.log(`  Requesting Lista unstake...`);
+      await approve(TOKENS.apUSD, apUSDBalance);
+      
+      const indicesBefore = await readClient.getUserWithdrawalIndices(account.address);
+      const unstakeHash = await writeClient.redeemApUSDAndRequestUnstake(apUSDBalance);
+      await publicClient.waitForTransactionReceipt({ hash: unstakeHash });
+      
+      const indicesAfter = await readClient.getUserWithdrawalIndices(account.address);
+      expect(indicesAfter.length).toBeGreaterThan(indicesBefore.length);
+      
+      const newIndex = indicesAfter[indicesAfter.length - 1];
+      console.log(`  Unstake requested, index: ${newIndex}`);
+
+      // Step 3: Check withdrawal status (should not be claimable yet)
+      const statusBefore = await readClient.getWithdrawalStatus(newIndex);
+      console.log(`  Status before: claimable=${statusBefore.isClaimable}`);
+      expect(statusBefore.isClaimable).toBe(false);
+
+      // Step 4: Fast forward time by 8 days (Lista unbonding period is ~7 days)
+      console.log(`  Fast forwarding 8 days...`);
+      const EIGHT_DAYS = 8 * 24 * 60 * 60;
+      await testClient.increaseTime({ seconds: EIGHT_DAYS });
+      await testClient.mine({ blocks: 1 });
+
+      // Step 5: Check withdrawal status (should be claimable now)
+      const statusAfter = await readClient.getWithdrawalStatus(newIndex);
+      console.log(`  Status after: claimable=${statusAfter.isClaimable}`);
+      
+      if (!statusAfter.isClaimable) {
+        console.log(`  ⚠️ Still not claimable, Lista might have longer unbonding. Skipping claim.`);
+        return;
+      }
+
+      // Step 6: Claim unstake
+      console.log(`  Claiming unstake...`);
+      const bnbBefore = await publicClient.getBalance({ address: account.address });
+      
+      const claimHash = await writeClient.claimUnstake(newIndex);
+      await publicClient.waitForTransactionReceipt({ hash: claimHash });
+      
+      const bnbAfter = await publicClient.getBalance({ address: account.address });
+      const bnbReceived = bnbAfter - bnbBefore;
+      console.log(`  Received: ${formatAmount(bnbReceived)} BNB ✓`);
+      
+      // Note: bnbReceived might be negative due to gas, but the claim should succeed
+      expect(statusAfter.isClaimable).toBe(true);
+    }, 300000);
+  });
+
+  describe("Edge Cases", () => {
+    it("should handle minimum amounts", async () => {
+      console.log(`\n[Fork 2] Minimum amount handling`);
+      
+      // Try very small stake
+      const minAmount = parseEther("0.0001");
+      console.log(`  Staking ${formatAmount(minAmount)} BNB...`);
+      
+      try {
+        const mintHash = await writeClient.stakeAndMintApUSD(0n, minAmount);
+        await publicClient.waitForTransactionReceipt({ hash: mintHash });
+        console.log(`  Success ✓`);
+      } catch (e: any) {
+        console.log(`  Failed (expected for very small amounts): ${e.message?.slice(0, 50)}`);
+      }
+    }, 60000);
+
+    it("should revert on zero amounts", async () => {
+      console.log(`\n[Fork 3] Zero amount revert`);
+      
+      await expect(
+        writeClient.stakeAndMintApUSD(0n, 0n)
+      ).rejects.toThrow();
+      console.log(`  Reverted as expected ✓`);
+    }, 30000);
+  });
+});

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,
@@ -22,7 +22,7 @@ import {
 
 // ============ Configuration ============
 
-const ROUTER = "0xf63f34f7e9608ae7d3a6f5b06ce423d9f9043648" as Address;
+const ROUTER = "0x159B2990966B0E4f07cD58c9Def513EA1fF81c0C" as Address;
 
 const TOKENS = {
   WBNB: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c" as Address,
@@ -390,5 +390,378 @@ describe("AspanRouter SDK", () => {
       console.log(`  Received: ${formatAmount(slisBNBAfter - slisBNBBefore)} slisBNB ✓`);
       expect(slisBNBAfter).toBeGreaterThan(slisBNBBefore);
     }, 180000);
+
+    // Test 5: swapAndMintApUSDDefault (USDT → apUSD with default LST)
+    it.skipIf(!HAS_PRIVATE_KEY)("swapAndMintApUSDDefault: USDT → apUSD", async () => {
+      console.log(`\n[E2E 5] swapAndMintApUSDDefault: 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.swapAndMintApUSDDefault({
+        inputToken: TOKENS.USDT,
+        inputAmount: USDT_AMOUNT,
+        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: swapAndMintXBNBDefault (USDT → xBNB with default LST)
+    it.skipIf(!HAS_PRIVATE_KEY)("swapAndMintXBNBDefault: USDT → xBNB", async () => {
+      console.log(`\n[E2E 6] swapAndMintXBNBDefault: 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.swapAndMintXBNBDefault({
+        inputToken: TOKENS.USDT,
+        inputAmount: USDT_AMOUNT,
+        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: redeemXBNBAndSwap (xBNB → USDT via V3)
+    it.skipIf(!HAS_PRIVATE_KEY)("redeemXBNBAndSwap: xBNB → USDT", async () => {
+      console.log(`\n[E2E 7] redeemXBNBAndSwap: 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.redeemXBNBAndSwap({
+        lst: TOKENS.slisBNB,
+        amount: redeemAmount,
+        path,
+        minOut: 0n,
+        deadline: BigInt(Math.floor(Date.now() / 1000) + 3600),
+      });
+      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: redeemXBNBAndRequestUnstake (xBNB → Lista unstake)
+    it.skipIf(!HAS_PRIVATE_KEY)("redeemXBNBAndRequestUnstake: xBNB → Lista unstake", async () => {
+      console.log(`\n[E2E 8] redeemXBNBAndRequestUnstake: xBNB → Lista unstake`);
+      
+      const xBNBBalance = await getBalance(TOKENS.xBNB);
+      if (xBNBBalance === 0n) {
+        console.log(`  ⚠️ No xBNB balance, skipping`);
+        return;
+      }
+
+      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.redeemXBNBAndRequestUnstake(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);
+
+    // Note: claimUnstake requires 7+ days waiting period, cannot be tested in e2e
+    // Would need a fork test with time manipulation
+
+    // Test 9: stakeAndMintXBNB (BNB → slisBNB → xBNB, simplified)
+    it.skipIf(!HAS_PRIVATE_KEY)("stakeAndMintXBNB: BNB → xBNB", async () => {
+      console.log(`\n[E2E 9] stakeAndMintXBNB: BNB → xBNB`);
+      
+      const amount = parseEther("0.001");
+      console.log(`  Staking ${formatEther(amount)} BNB → xBNB...`);
+      
+      const xBNBBefore = await getBalance(TOKENS.xBNB);
+      
+      const hash = await writeClient.stakeAndMintXBNB(0n, 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: mintXBNB (direct LST → xBNB)
+    it.skipIf(!HAS_PRIVATE_KEY)("mintXBNB: slisBNB → xBNB", async () => {
+      console.log(`\n[E2E 10] mintXBNB: 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.mintXBNB({
+        lst: TOKENS.slisBNB,
+        lstAmount: amount,
+        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: redeemXBNB (direct xBNB → slisBNB)
+    it.skipIf(!HAS_PRIVATE_KEY)("redeemXBNB: xBNB → slisBNB", async () => {
+      console.log(`\n[E2E 11] redeemXBNB: 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.redeemXBNB({
+        lst: TOKENS.slisBNB,
+        xBNBAmount: 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: stakeAndMintApUSD (BNB → slisBNB → apUSD, simplified)
+    // Note: May fail if apUSD minting is disabled on mainnet
+    it.skipIf(!HAS_PRIVATE_KEY)("stakeAndMintApUSD: BNB → apUSD (may skip if disabled)", async () => {
+      console.log(`\n[E2E 12] stakeAndMintApUSD: 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.stakeAndMintApUSD(0n, 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: mintApUSD (direct LST → apUSD)
+    // Note: May fail if apUSD minting is disabled on mainnet
+    it.skipIf(!HAS_PRIVATE_KEY)("mintApUSD: slisBNB → apUSD (may skip if disabled)", async () => {
+      console.log(`\n[E2E 13] mintApUSD: 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.mintApUSD({
+          lst: TOKENS.slisBNB,
+          lstAmount: amount,
+          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: redeemApUSD (direct apUSD → slisBNB)
+    it.skipIf(!HAS_PRIVATE_KEY)("redeemApUSD: apUSD → slisBNB", async () => {
+      console.log(`\n[E2E 14] redeemApUSD: 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.redeemApUSD({
+        lst: TOKENS.slisBNB,
+        apUSDAmount: 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: redeemApUSDAndSwap (apUSD → slisBNB → USDT)
+    it.skipIf(!HAS_PRIVATE_KEY)("redeemApUSDAndSwap: apUSD → USDT", async () => {
+      console.log(`\n[E2E 15] redeemApUSDAndSwap: apUSD → USDT`);
+      
+      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 → 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.redeemApUSDAndSwap({
+        lst: TOKENS.slisBNB,
+        amount,
+        path,
+        minOut: 0n,
+        deadline: BigInt(Math.floor(Date.now() / 1000) + 3600),
+      });
+      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: redeemApUSDAndRequestUnstake (apUSD → Lista unstake)
+    it.skipIf(!HAS_PRIVATE_KEY)("redeemApUSDAndRequestUnstake: apUSD → Lista unstake", async () => {
+      console.log(`\n[E2E 16] redeemApUSDAndRequestUnstake: apUSD → Lista unstake`);
+      
+      const apUSDBalance = await getBalance(TOKENS.apUSD);
+      if (apUSDBalance === 0n) {
+        console.log(`  ⚠️ No apUSD balance, skipping`);
+        return;
+      }
+
+      // Use remaining apUSD balance
+      console.log(`  Requesting unstake for ${formatEther(apUSDBalance)} apUSD...`);
+      await approve(TOKENS.apUSD, apUSDBalance);
+      
+      const indicesBefore = await readClient.getUserWithdrawalIndices(account.address);
+      
+      const hash = await writeClient.redeemApUSDAndRequestUnstake(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);
   });
 });