@aspan/sdk 0.2.0 → 0.2.2

package/package.json

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

package/src/__tests__/router.test.ts

@@ -0,0 +1,378 @@
+/**
+ * AspanRouter SDK Tests - E2E Flows
+ * 
+ * Run with: npm test
+ * Requires: PRIVATE_KEY and BSC_RPC_URL environment variables
+ * 
+ * Token requirements: BNB + USDT only
+ * Tests run sequentially to avoid race conditions
+ */
+
+import { describe, it, expect, beforeAll } from "vitest";
+import { privateKeyToAccount } from "viem/accounts";
+import { createPublicClient, http, parseEther, zeroAddress, type Address } from "viem";
+import { bsc } from "viem/chains";
+import {
+  AspanRouterClient,
+  AspanRouterReadClient,
+  encodeV3Path,
+  parseAmount,
+  formatAmount,
+} from "../index";
+
+// ============ Configuration ============
+
+const ROUTER = "0xf63f34f7e9608ae7d3a6f5b06ce423d9f9043648" as Address;
+
+const TOKENS = {
+  WBNB: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c" as Address,
+  USDT: "0x55d398326f99059fF775485246999027B3197955" as Address,
+  slisBNB: "0xB0b84D294e0C75A6abe60171b70edEb2EFd14A1B" as Address,
+  apUSD: "0x1977097E2E5697A6DD91b6732F368a14F50f6B3d" as Address,
+  xBNB: "0xB78eB4d5928bAb158Eb23c3154544084cD2661d5" as Address,
+};
+
+// Minimal amounts
+const BNB_AMOUNT = parseEther("0.002");  // ~$1.20
+const USDT_AMOUNT = parseAmount("0.5");  // $0.50
+
+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;
+
+// Check env at module level
+const HAS_PRIVATE_KEY = !!process.env.PRIVATE_KEY;
+
+// ============ Tests ============
+
+describe("AspanRouter SDK", () => {
+  let readClient: AspanRouterReadClient;
+  let writeClient: AspanRouterClient;
+  let publicClient: ReturnType<typeof createPublicClient>;
+  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(() => {
+    const privateKey = process.env.PRIVATE_KEY;
+    const rpcUrl = process.env.BSC_RPC_URL || "https://bsc-dataseed.binance.org/";
+
+    readClient = new AspanRouterReadClient({
+      routerAddress: ROUTER,
+      chain: bsc,
+      rpcUrl,
+    });
+
+    publicClient = createPublicClient({
+      chain: bsc,
+      transport: http(rpcUrl),
+    });
+
+    if (privateKey) {
+      const key = privateKey.startsWith("0x") ? privateKey : `0x${privateKey}`;
+      account = privateKeyToAccount(key as `0x${string}`);
+      
+      writeClient = new AspanRouterClient({
+        routerAddress: ROUTER,
+        account,
+        chain: bsc,
+        rpcUrl,
+      });
+
+      console.log(`📍 Wallet: ${account.address}`);
+    }
+  });
+
+  // ============ Read Tests ============
+
+  describe("Read Functions", () => {
+    it("should get token addresses", async () => {
+      const [apUSD, xBNB, slisBNB] = await Promise.all([
+        readClient.getApUSD(),
+        readClient.getXBNB(),
+        readClient.getSlisBNB(),
+      ]);
+      expect(apUSD.toLowerCase()).toBe(TOKENS.apUSD.toLowerCase());
+      expect(xBNB.toLowerCase()).toBe(TOKENS.xBNB.toLowerCase());
+      expect(slisBNB.toLowerCase()).toBe(TOKENS.slisBNB.toLowerCase());
+    });
+
+    it("should preview mint/redeem", async () => {
+      const lstAmount = parseAmount("1");
+      const apUSDOut = await readClient.previewMintApUSD(TOKENS.slisBNB, lstAmount);
+      expect(apUSDOut).toBeGreaterThan(parseAmount("400"));
+      
+      const lstBack = await readClient.previewRedeemApUSD(TOKENS.slisBNB, 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)`);
+    });
+  });
+
+  describe("encodeV3Path", () => {
+    it("should encode paths correctly", () => {
+      const path = encodeV3Path([TOKENS.slisBNB, TOKENS.WBNB, TOKENS.USDT], [500, 500]);
+      expect(path.length).toBe(134);
+    });
+  });
+
+  // ============ E2E Tests (Sequential) ============
+
+  describe("E2E Flows", () => {
+    // Test 1: BNB → apUSD → slisBNB
+    it.skipIf(!HAS_PRIVATE_KEY)("BNB → apUSD → slisBNB", async () => {
+      console.log(`\n[E2E 1] BNB → apUSD → slisBNB`);
+      
+      // Step 1: Stake BNB → apUSD
+      console.log(`  Staking ${formatAmount(BNB_AMOUNT)} BNB...`);
+      const apUSDBefore = await getBalance(TOKENS.apUSD);
+      
+      const mintHash = await writeClient.stakeAndMintApUSD(0n, BNB_AMOUNT);
+      const mintReceipt = await publicClient.waitForTransactionReceipt({ hash: mintHash });
+      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);
+
+      // Step 2: Redeem apUSD → slisBNB
+      console.log(`  Redeeming ${formatAmount(apUSDMinted)} apUSD...`);
+      await approve(TOKENS.apUSD, apUSDMinted);
+      
+      const slisBNBBefore = await getBalance(TOKENS.slisBNB);
+      
+      const redeemHash = await writeClient.redeemApUSD({
+        lst: TOKENS.slisBNB,
+        apUSDAmount: apUSDMinted,
+        minOut: 0n,
+      });
+      const redeemReceipt = await publicClient.waitForTransactionReceipt({ hash: redeemHash });
+      expect(redeemReceipt.status).toBe("success");
+      
+      const slisBNBAfter = await getBalance(TOKENS.slisBNB);
+      const slisBNBReceived = slisBNBAfter - slisBNBBefore;
+      console.log(`  Received: ${formatAmount(slisBNBReceived)} slisBNB`);
+      expect(slisBNBReceived).toBeGreaterThan(0n);
+
+      // Step 3: Direct mint apUSD with slisBNB
+      console.log(`  Direct minting apUSD with slisBNB...`);
+      await approve(TOKENS.slisBNB, slisBNBReceived);
+      
+      const apUSDBefore2 = await getBalance(TOKENS.apUSD);
+      const directMintHash = await writeClient.mintApUSD({
+        lst: TOKENS.slisBNB,
+        lstAmount: slisBNBReceived,
+        minOut: 0n,
+      });
+      await publicClient.waitForTransactionReceipt({ hash: directMintHash });
+      
+      const apUSDAfter2 = await getBalance(TOKENS.apUSD);
+      const directMinted = apUSDAfter2 - apUSDBefore2;
+      console.log(`  Minted: ${formatAmount(directMinted)} apUSD`);
+      expect(directMinted).toBeGreaterThan(0n);
+
+      // Step 4: Lista unstake request
+      console.log(`  Requesting Lista unstake...`);
+      await approve(TOKENS.apUSD, directMinted);
+      
+      const indicesBefore = await readClient.getUserWithdrawalIndices(account.address);
+      const unstakeHash = await writeClient.redeemApUSDAndRequestUnstake(directMinted);
+      await publicClient.waitForTransactionReceipt({ hash: unstakeHash });
+      
+      const indicesAfter = await readClient.getUserWithdrawalIndices(account.address);
+      expect(indicesAfter.length).toBeGreaterThan(indicesBefore.length);
+      console.log(`  Unstake requested ✓`);
+    }, 300000);
+
+    // Test 2: BNB → xBNB → slisBNB → mintXBNB
+    it.skipIf(!HAS_PRIVATE_KEY)("BNB → xBNB → slisBNB → mintXBNB", async () => {
+      console.log(`\n[E2E 2] BNB → xBNB → slisBNB → mintXBNB`);
+      
+      // Step 1: Stake BNB → xBNB
+      console.log(`  Staking ${formatAmount(BNB_AMOUNT)} BNB...`);
+      const xBNBBefore = await getBalance(TOKENS.xBNB);
+      
+      const mintHash = await writeClient.stakeAndMintXBNB(0n, BNB_AMOUNT);
+      const mintReceipt = await publicClient.waitForTransactionReceipt({ hash: mintHash });
+      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);
+
+      // Step 2: Redeem xBNB → slisBNB
+      console.log(`  Redeeming ${formatAmount(xBNBMinted, 8)} xBNB...`);
+      await approve(TOKENS.xBNB, xBNBMinted);
+      
+      const slisBNBBefore = await getBalance(TOKENS.slisBNB);
+      
+      const redeemHash = await writeClient.redeemXBNB({
+        lst: TOKENS.slisBNB,
+        xBNBAmount: xBNBMinted,
+        minOut: 0n,
+      });
+      const redeemReceipt = await publicClient.waitForTransactionReceipt({ hash: redeemHash });
+      expect(redeemReceipt.status).toBe("success");
+      
+      const slisBNBAfter = await getBalance(TOKENS.slisBNB);
+      const slisBNBReceived2 = slisBNBAfter - slisBNBBefore;
+      console.log(`  Received: ${formatAmount(slisBNBReceived2)} slisBNB`);
+      expect(slisBNBReceived2).toBeGreaterThan(0n);
+
+      // Step 3: Direct mint xBNB with slisBNB
+      console.log(`  Direct minting xBNB with slisBNB...`);
+      await approve(TOKENS.slisBNB, slisBNBReceived2);
+      
+      const xBNBBefore2 = await getBalance(TOKENS.xBNB);
+      const directMintHash = await writeClient.mintXBNB({
+        lst: TOKENS.slisBNB,
+        lstAmount: slisBNBReceived2,
+        minOut: 0n,
+      });
+      await publicClient.waitForTransactionReceipt({ hash: directMintHash });
+      
+      const xBNBAfter2 = await getBalance(TOKENS.xBNB);
+      console.log(`  Minted: ${formatAmount(xBNBAfter2 - xBNBBefore2, 8)} xBNB ✓`);
+      expect(xBNBAfter2).toBeGreaterThan(xBNBBefore2);
+    }, 300000);
+
+    // Test 3: USDT → apUSD → USDT
+    it.skipIf(!HAS_PRIVATE_KEY)("USDT → apUSD → USDT", async () => {
+      console.log(`\n[E2E 3] USDT → apUSD → USDT`);
+      
+      // Check USDT balance
+      const usdtBalance = await getBalance(TOKENS.USDT);
+      if (usdtBalance < USDT_AMOUNT) {
+        console.log(`  ⚠️ Insufficient USDT (${formatAmount(usdtBalance)}), skipping`);
+        return;
+      }
+
+      // Step 1: Approve + Swap USDT → apUSD
+      console.log(`  Swapping ${formatAmount(USDT_AMOUNT)} USDT...`);
+      await approve(TOKENS.USDT, USDT_AMOUNT);
+      
+      const apUSDBefore = await getBalance(TOKENS.apUSD);
+      
+      const mintHash = await writeClient.swapAndMintApUSD({
+        swapParams: {
+          inputToken: TOKENS.USDT,
+          inputAmount: USDT_AMOUNT,
+          targetLST: zeroAddress,
+          minLSTOut: 0n,
+          poolFee: 2500,
+        },
+        mintParams: {
+          minMintOut: 0n,
+          recipient: zeroAddress,
+          deadline: BigInt(Math.floor(Date.now() / 1000) + 3600),
+        },
+      });
+      const mintReceipt = await publicClient.waitForTransactionReceipt({ hash: mintHash });
+      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);
+
+      // Step 2: Redeem apUSD → USDT via V3
+      console.log(`  Redeeming ${formatAmount(apUSDMinted)} apUSD → USDT...`);
+      await approve(TOKENS.apUSD, apUSDMinted);
+      
+      const usdtBefore = await getBalance(TOKENS.USDT);
+      const path = encodeV3Path([TOKENS.slisBNB, TOKENS.WBNB, TOKENS.USDT], [500, 500]);
+      
+      const redeemHash = await writeClient.redeemApUSDAndSwap({
+        lst: TOKENS.slisBNB,
+        amount: apUSDMinted,
+        path,
+        minOut: 0n,
+        deadline: BigInt(Math.floor(Date.now() / 1000) + 3600),
+      });
+      const redeemReceipt = await publicClient.waitForTransactionReceipt({ hash: redeemHash });
+      expect(redeemReceipt.status).toBe("success");
+      
+      const usdtAfter = await getBalance(TOKENS.USDT);
+      console.log(`  Received: ${formatAmount(usdtAfter - usdtBefore)} USDT ✓`);
+      expect(usdtAfter).toBeGreaterThan(usdtBefore);
+    }, 180000);
+
+    // Test 4: USDT → xBNB → slisBNB
+    it.skipIf(!HAS_PRIVATE_KEY)("USDT → xBNB → slisBNB", async () => {
+      console.log(`\n[E2E 4] USDT → xBNB → slisBNB`);
+      
+      // Check USDT balance
+      const usdtBalance = await getBalance(TOKENS.USDT);
+      if (usdtBalance < USDT_AMOUNT) {
+        console.log(`  ⚠️ Insufficient USDT (${formatAmount(usdtBalance)}), skipping`);
+        return;
+      }
+
+      // Step 1: Approve + Swap USDT → xBNB
+      console.log(`  Swapping ${formatAmount(USDT_AMOUNT)} USDT...`);
+      await approve(TOKENS.USDT, USDT_AMOUNT);
+      
+      const xBNBBefore = await getBalance(TOKENS.xBNB);
+      
+      const mintHash = await writeClient.swapAndMintXBNB({
+        swapParams: {
+          inputToken: TOKENS.USDT,
+          inputAmount: USDT_AMOUNT,
+          targetLST: zeroAddress,
+          minLSTOut: 0n,
+          poolFee: 2500,
+        },
+        mintParams: {
+          minMintOut: 0n,
+          recipient: zeroAddress,
+          deadline: BigInt(Math.floor(Date.now() / 1000) + 3600),
+        },
+      });
+      const mintReceipt = await publicClient.waitForTransactionReceipt({ hash: mintHash });
+      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);
+
+      // Step 2: Redeem xBNB → slisBNB
+      console.log(`  Redeeming ${formatAmount(xBNBMinted, 8)} xBNB...`);
+      await approve(TOKENS.xBNB, xBNBMinted);
+      
+      const slisBNBBefore = await getBalance(TOKENS.slisBNB);
+      
+      const redeemHash = await writeClient.redeemXBNB({
+        lst: TOKENS.slisBNB,
+        xBNBAmount: xBNBMinted,
+        minOut: 0n,
+      });
+      const redeemReceipt = await publicClient.waitForTransactionReceipt({ hash: redeemHash });
+      expect(redeemReceipt.status).toBe("success");
+      
+      const slisBNBAfter = await getBalance(TOKENS.slisBNB);
+      console.log(`  Received: ${formatAmount(slisBNBAfter - slisBNBBefore)} slisBNB ✓`);
+      expect(slisBNBAfter).toBeGreaterThan(slisBNBBefore);
+    }, 180000);
+  });
+});