@aspan/sdk 0.3.1 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aspan/sdk",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "description": "TypeScript SDK for Aspan Protocol - LST-backed stablecoin on BNB Chain",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/__tests__/fork.test.ts

@@ -27,8 +27,8 @@ const TOKENS = {
   WBNB: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c" as Address,
   USDT: "0x55d398326f99059fF775485246999027B3197955" as Address,
   slisBNB: "0xB0b84D294e0C75A6abe60171b70edEb2EFd14A1B" as Address,
-  apUSD: "0x1977097E2E5697A6DD91b6732F368a14F50f6B3d" as Address,
-  xBNB: "0xB78eB4d5928bAb158Eb23c3154544084cD2661d5" as Address,
+  apUSD: "0x4570047eeB5aDb4081c5d470494EB5134e34A287" as Address,
+  xBNB: "0x0A0c9CD826e747D99F90D63e780B3727Da4D0d43" as Address,
 };
 
 const ERC20_ABI = [

package/src/__tests__/router.test.ts

@@ -18,23 +18,24 @@ import {
   encodeV3Path,
   parseAmount,
   formatAmount,
+  BSC_ADDRESSES,
 } from "../index";
 
 // ============ Configuration ============
 
-const ROUTER = "0x159B2990966B0E4f07cD58c9Def513EA1fF81c0C" 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 });
@@ -391,9 +418,9 @@ describe("AspanRouter SDK", () => {
       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`);
+    // 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) {
@@ -407,9 +434,10 @@ describe("AspanRouter SDK", () => {
       const apUSDBefore = await getBalance(TOKENS.apUSD);
       
       const deadline = BigInt(Math.floor(Date.now() / 1000) + 600);
-      const mintHash = await writeClient.swapAndMintApUSDDefault({
+      const mintHash = await writeClient.swapAndMintDefault({
         inputToken: TOKENS.USDT,
         inputAmount: USDT_AMOUNT,
+        mintXBNB: false,
         minMintOut: 0n,
         deadline,
       });
@@ -423,9 +451,9 @@ describe("AspanRouter SDK", () => {
       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`);
+    // 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) {
@@ -439,9 +467,10 @@ describe("AspanRouter SDK", () => {
       const xBNBBefore = await getBalance(TOKENS.xBNB);
       
       const deadline = BigInt(Math.floor(Date.now() / 1000) + 600);
-      const mintHash = await writeClient.swapAndMintXBNBDefault({
+      const mintHash = await writeClient.swapAndMintDefault({
         inputToken: TOKENS.USDT,
         inputAmount: USDT_AMOUNT,
+        mintXBNB: true,
         minMintOut: 0n,
         deadline,
       });
@@ -455,9 +484,9 @@ describe("AspanRouter SDK", () => {
       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`);
+    // 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) {
@@ -472,12 +501,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.redeemXBNBAndSwap({
+      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);
@@ -488,22 +519,32 @@ describe("AspanRouter SDK", () => {
       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`);
+    // 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);
-      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 unstakeHash = await writeClient.redeemAndRequestUnstake({
+        redeemXBNB: true,
+        amount: xBNBBalance,
+      });
       const unstakeReceipt = await publicClient.waitForTransactionReceipt({ hash: unstakeHash });
       await sleep(2000);
       expect(unstakeReceipt.status).toBe("success");
@@ -513,19 +554,22 @@ describe("AspanRouter SDK", () => {
       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`);
+    // 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.stakeAndMintXBNB(0n, amount);
+      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");
@@ -536,9 +580,9 @@ describe("AspanRouter SDK", () => {
       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`);
+    // 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) {
@@ -552,9 +596,10 @@ describe("AspanRouter SDK", () => {
       
       const xBNBBefore = await getBalance(TOKENS.xBNB);
       
-      const hash = await writeClient.mintXBNB({
+      const hash = await writeClient.mint({
         lst: TOKENS.slisBNB,
         lstAmount: amount,
+        mintXBNB: true,
         minOut: 0n,
       });
       const receipt = await publicClient.waitForTransactionReceipt({ hash });
@@ -567,9 +612,9 @@ describe("AspanRouter SDK", () => {
       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`);
+    // 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) {
@@ -583,9 +628,10 @@ describe("AspanRouter SDK", () => {
       
       const slisBNBBefore = await getBalance(TOKENS.slisBNB);
       
-      const hash = await writeClient.redeemXBNB({
+      const hash = await writeClient.redeem({
         lst: TOKENS.slisBNB,
-        xBNBAmount: amount,
+        redeemXBNB: true,
+        amount,
         minOut: 0n,
       });
       const receipt = await publicClient.waitForTransactionReceipt({ hash });
@@ -598,10 +644,9 @@ describe("AspanRouter SDK", () => {
       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`);
+    // 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...`);
@@ -609,7 +654,13 @@ describe("AspanRouter SDK", () => {
       const apUSDBefore = await getBalance(TOKENS.apUSD);
       
       try {
-        const hash = await writeClient.stakeAndMintApUSD(0n, amount);
+        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);
         
@@ -630,10 +681,9 @@ describe("AspanRouter SDK", () => {
       }
     }, 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`);
+    // 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) {
@@ -648,9 +698,10 @@ describe("AspanRouter SDK", () => {
       const apUSDBefore = await getBalance(TOKENS.apUSD);
       
       try {
-        const hash = await writeClient.mintApUSD({
+        const hash = await writeClient.mint({
           lst: TOKENS.slisBNB,
           lstAmount: amount,
+          mintXBNB: false,
           minOut: 0n,
         });
         const receipt = await publicClient.waitForTransactionReceipt({ hash });
@@ -673,9 +724,9 @@ describe("AspanRouter SDK", () => {
       }
     }, 180000);
 
-    // Test 14: redeemApUSD (direct apUSD → slisBNB)
-    it.skipIf(!HAS_PRIVATE_KEY)("redeemApUSD: apUSD → slisBNB", async () => {
-      console.log(`\n[E2E 14] redeemApUSD: apUSD → slisBNB`);
+    // 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) {
@@ -689,9 +740,10 @@ describe("AspanRouter SDK", () => {
       
       const slisBNBBefore = await getBalance(TOKENS.slisBNB);
       
-      const hash = await writeClient.redeemApUSD({
+      const hash = await writeClient.redeem({
         lst: TOKENS.slisBNB,
-        apUSDAmount: amount,
+        redeemXBNB: false,
+        amount,
         minOut: 0n,
       });
       const receipt = await publicClient.waitForTransactionReceipt({ hash });
@@ -704,9 +756,9 @@ describe("AspanRouter SDK", () => {
       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`);
+    // 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) {
@@ -714,19 +766,21 @@ describe("AspanRouter SDK", () => {
         return;
       }
 
-      const amount = apUSDBalance > parseEther("0.1") ? parseEther("0.1") : apUSDBalance;
+      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.redeemApUSDAndSwap({
+      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);
@@ -738,9 +792,9 @@ describe("AspanRouter SDK", () => {
       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`);
+    // 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) {
@@ -748,13 +802,15 @@ describe("AspanRouter SDK", () => {
         return;
       }
 
-      // Use remaining apUSD balance
-      console.log(`  Requesting unstake for ${formatEther(apUSDBalance)} apUSD...`);
+      console.log(`  Requesting unstake for ${formatAmount(apUSDBalance)} apUSD...`);
       await approve(TOKENS.apUSD, apUSDBalance);
       
       const indicesBefore = await readClient.getUserWithdrawalIndices(account.address);
       
-      const hash = await writeClient.redeemApUSDAndRequestUnstake(apUSDBalance);
+      const hash = await writeClient.redeemAndRequestUnstake({
+        redeemXBNB: false,
+        amount: apUSDBalance,
+      });
       const receipt = await publicClient.waitForTransactionReceipt({ hash });
       await sleep(2000);
       expect(receipt.status).toBe("success");

package/src/abi/diamond.ts

@@ -477,6 +477,30 @@ export const DiamondABI = [
     outputs: [{ name: "", type: "bool", internalType: "bool" }],
     stateMutability: "view"
   },
+  {
+    type: "function",
+    name: "bootstrap",
+    inputs: [
+      { name: "_lstToken", type: "address", internalType: "address" },
+      { name: "_lstAmount", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [{ name: "xBNBAmount", type: "uint256", internalType: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "isBootstrapped",
+    inputs: [],
+    outputs: [{ name: "", type: "bool", internalType: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getBootstrapXBNBAmount",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256", internalType: "uint256" }],
+    stateMutability: "view"
+  },
 
   // ============ StabilityModeFacet ============
   {
@@ -510,6 +534,13 @@ export const DiamondABI = [
     ],
     stateMutability: "nonpayable"
   },
+  {
+    type: "function",
+    name: "cleanXbnb",
+    inputs: [{ name: "_xBNBAmount", type: "uint256", internalType: "uint256" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
 
   // ============ StabilityModeFacet Events ============
   {
@@ -531,5 +562,48 @@ export const DiamondABI = [
     inputs: [],
     outputs: [{ name: "", type: "address", internalType: "address" }],
     stateMutability: "view"
+  },
+
+  // ============ Fee Manager ============
+  {
+    type: "function",
+    name: "setFeeManager",
+    inputs: [{ name: "_feeManager", type: "address", internalType: "address" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getFeeManager",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "setFeeTiers",
+    inputs: [{
+      name: "_tiers",
+      type: "tuple[]",
+      internalType: "struct LibAppStorage.FeeTier[]",
+      components: [
+        { name: "minCR", type: "uint256", internalType: "uint256" },
+        { name: "apUSDMintFee", type: "uint16", internalType: "uint16" },
+        { name: "apUSDRedeemFee", type: "uint16", internalType: "uint16" },
+        { name: "xBNBMintFee", type: "uint16", internalType: "uint16" },
+        { name: "xBNBRedeemFee", type: "uint16", internalType: "uint16" },
+        { name: "apUSDMintDisabled", type: "bool", internalType: "bool" }
+      ]
+    }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "event",
+    name: "FeeManagerSet",
+    inputs: [
+      { name: "feeManager", type: "address", indexed: true, internalType: "address" }
+    ],
+    anonymous: false
   }
 ] as const;