@aspan/sdk 0.4.6 → 0.4.8

package/src/abi/diamond.ts

@@ -254,13 +254,6 @@ export const DiamondABI = [
     outputs: [{ name: "assets", type: "uint256", internalType: "uint256" }],
     stateMutability: "nonpayable"
   },
-  {
-    type: "function",
-    name: "withdrawAssets",
-    inputs: [{ name: "_assets", type: "uint256", internalType: "uint256" }],
-    outputs: [{ name: "shares", type: "uint256", internalType: "uint256" }],
-    stateMutability: "nonpayable"
-  },
   {
     type: "function",
     name: "getShares",

package/src/abi/router.ts

@@ -185,6 +185,20 @@ export const RouterABI = [
     outputs: [{ type: "bool" }],
     stateMutability: "view",
   },
+  {
+    type: "function",
+    name: "lstModes",
+    inputs: [{ name: "lst", type: "address" }],
+    outputs: [{ type: "uint8" }],
+    stateMutability: "view",
+  },
+  {
+    type: "function",
+    name: "isLSTRoutable",
+    inputs: [{ name: "lst", type: "address" }],
+    outputs: [{ type: "bool" }],
+    stateMutability: "view",
+  },
 
   // Preview functions - unified
   {

package/src/abi/sApUSD.ts

@@ -27,13 +27,13 @@ export const SApUSDABI = [
   },
   {
     type: "function",
-    name: "previewRedeemMulti",
+    name: "previewRedeem",
     inputs: [
       { name: "shares", type: "uint256", internalType: "uint256" }
     ],
     outputs: [
-      { name: "assets", type: "address[]", internalType: "address[]" },
-      { name: "amounts", type: "uint256[]", internalType: "uint256[]" }
+      { name: "apUSDOut", type: "uint256", internalType: "uint256" },
+      { name: "xBNBOut", type: "uint256", internalType: "uint256" }
     ],
     stateMutability: "view"
   },
@@ -80,57 +80,71 @@ export const SApUSDABI = [
   },
   {
     type: "function",
-    name: "previewCleanXBNB",
+    name: "hasRole",
     inputs: [
-      { name: "_xBNBAmount", type: "uint256", internalType: "uint256" },
-      { name: "_router", type: "address", internalType: "address" },
-      { name: "_path", type: "address[]", internalType: "address[]" }
+      { name: "role", type: "bytes32", internalType: "bytes32" },
+      { name: "account", type: "address", internalType: "address" }
     ],
-    outputs: [{ name: "expectedApUSD", type: "uint256", internalType: "uint256" }],
+    outputs: [{ name: "", type: "bool", internalType: "bool" }],
     stateMutability: "view"
   },
+
+  // ============ Write Functions ============
   {
     type: "function",
-    name: "KEEPER_ROLE",
-    inputs: [],
-    outputs: [{ name: "", type: "bytes32", internalType: "bytes32" }],
-    stateMutability: "view"
+    name: "redeem",
+    inputs: [
+      { name: "shares", type: "uint256", internalType: "uint256" },
+      { name: "receiver", type: "address", internalType: "address" },
+      { name: "owner", type: "address", internalType: "address" }
+    ],
+    outputs: [
+      { name: "apUSDOut", type: "uint256", internalType: "uint256" },
+      { name: "xBNBOut", type: "uint256", internalType: "uint256" }
+    ],
+    stateMutability: "nonpayable"
   },
   {
     type: "function",
-    name: "hasRole",
+    name: "deposit",
     inputs: [
-      { name: "role", type: "bytes32", internalType: "bytes32" },
-      { name: "account", type: "address", internalType: "address" }
+      { name: "assets", type: "uint256", internalType: "uint256" },
+      { name: "receiver", type: "address", internalType: "address" }
     ],
-    outputs: [{ name: "", type: "bool", internalType: "bool" }],
-    stateMutability: "view"
+    outputs: [{ name: "shares", type: "uint256", internalType: "uint256" }],
+    stateMutability: "nonpayable"
   },
 
-  // ============ Keeper Functions ============
+  // ============ Accounting Functions ============
   {
     type: "function",
-    name: "cleanXBNB",
+    name: "addAccounting",
     inputs: [
-      { name: "_xBNBAmount", type: "uint256", internalType: "uint256" },
-      { name: "_minApUSDOut", type: "uint256", internalType: "uint256" },
-      { name: "_router", type: "address", internalType: "address" },
-      { name: "_path", type: "address[]", internalType: "address[]" },
-      { name: "_deadline", type: "uint256", internalType: "uint256" }
+      { name: "apUSD", type: "uint256", internalType: "uint256" },
+      { name: "xBNB", type: "uint256", internalType: "uint256" }
     ],
-    outputs: [{ name: "apUSDReceived", type: "uint256", internalType: "uint256" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "subAccounting",
+    inputs: [
+      { name: "apUSD", type: "uint256", internalType: "uint256" },
+      { name: "xBNB", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [],
     stateMutability: "nonpayable"
   },
 
-  // ============ Events ============
+  // ============ Admin Functions ============
   {
-    type: "event",
-    name: "VaultCleaned",
+    type: "function",
+    name: "sweepExcess",
     inputs: [
-      { name: "xBNBSold", type: "uint256", indexed: false, internalType: "uint256" },
-      { name: "apUSDReceived", type: "uint256", indexed: false, internalType: "uint256" },
-      { name: "keeper", type: "address", indexed: true, internalType: "address" }
+      { name: "recipient", type: "address", internalType: "address" }
     ],
-    anonymous: false
-  }
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
 ] as const;

package/src/client.ts

@@ -75,7 +75,6 @@ import type {
   RedeemXBNBParams,
   DepositParams,
   WithdrawParams,
-  WithdrawAssetsParams,
 } from "./types";
 
 // ============ Configuration ============
@@ -118,6 +117,7 @@ export class AspanReadClient {
     this.publicClient = createPublicClient({
       chain: this.chain,
       transport: http(config.rpcUrl),
+      batch: { multicall: true },
     });
   }
 
@@ -1210,22 +1210,6 @@ export class AspanClient extends AspanReadClient {
     });
   }
 
-  /**
-   * Withdraw from stability pool by asset amount
-   * @param params Withdraw parameters
-   * @returns Transaction hash
-   */
-  async withdrawAssets(params: WithdrawAssetsParams): Promise<Hash> {
-    return this.walletClient.writeContract({
-      chain: this.chain,
-      account: this.walletClient.account!,
-      address: this.diamondAddress,
-      abi: DiamondABI,
-      functionName: "withdrawAssets",
-      args: [params.assets],
-    });
-  }
-
   /**
    * Harvest yield from LSTs
    * @returns Transaction hash

package/src/index.ts

@@ -68,7 +68,6 @@ export type {
   RedeemXBNBParams,
   DepositParams,
   WithdrawParams,
-  WithdrawAssetsParams,
   // Events
   ApUSDMintedEvent,
   ApUSDRedeemedEvent,
@@ -117,7 +116,7 @@ export const PRICE_PRECISION = 10n ** 8n; // Chainlink price precision
 // ============ Contract Addresses (BSC Mainnet) ============
 export const BSC_ADDRESSES = {
   diamond: "0x6a11B30d3a70727d5477D6d8090e144443fA1c78" as const,
-  router: "0x29dd49b2e98674ee7531f17e4d40a7725918c3f6" as const,
+  router: "0x34a64c4EbDe830773083BA8c9469456616F6723b" as const,
   apUSD: "0x4570047eeB5aDb4081c5d470494EB5134e34A287" as const,
   xBNB: "0x0A0c9CD826e747D99F90D63e780B3727Da4D0d43" as const,
   sApUSD: "0x896770Dba7c0481539E25aaB56bE285ECF6D65eB" as const,

package/src/router.ts

@@ -20,6 +20,7 @@ import {
 import { bsc, bscTestnet } from "viem/chains";
 import { pharosTestnet, CHAIN_IDS, getChainById } from "./client";
 import { RouterABI } from "./abi/router";
+import { DiamondABI } from "./abi/diamond";
 import type {
   SwapAndMintParams,
   StakeAndMintParams,
@@ -58,6 +59,7 @@ export class AspanRouterReadClient {
   protected readonly publicClient: PublicClient;
   protected readonly routerAddress: Address;
   protected readonly chain: Chain;
+  private readonly _addressCache = new Map<string, Address>();
 
   constructor(config: AspanRouterClientConfig) {
     this.routerAddress = config.routerAddress;
@@ -66,9 +68,18 @@ export class AspanRouterReadClient {
     this.publicClient = createPublicClient({
       chain: this.chain,
       transport: http(config.rpcUrl),
+      batch: { multicall: true },
     });
   }
 
+  protected async _getCachedAddress(key: string, fetcher: () => Promise<Address>): Promise<Address> {
+    const cached = this._addressCache.get(key);
+    if (cached) return cached;
+    const addr = await fetcher();
+    this._addressCache.set(key, addr);
+    return addr;
+  }
+
   // ============ View Functions ============
 
   /**
@@ -107,16 +118,43 @@ export class AspanRouterReadClient {
   }
 
   /**
-   * Get the Diamond contract address
+   * Get LST mode (0 = SYNC, 1 = ASYNC_DIRECT_ONLY)
    */
-  async getDiamond(): Promise<Address> {
+  async getLSTMode(lst: Address): Promise<number> {
+    const mode = await this.publicClient.readContract({
+      address: this.routerAddress,
+      abi: RouterABI,
+      functionName: "lstModes",
+      args: [lst],
+    });
+    return Number(mode);
+  }
+
+  /**
+   * Check whether an LST supports routed flows (swap/stake/redeemAndSwap)
+   */
+  async isLSTRoutable(lst: Address): Promise<boolean> {
     return this.publicClient.readContract({
       address: this.routerAddress,
       abi: RouterABI,
-      functionName: "diamond",
+      functionName: "isLSTRoutable",
+      args: [lst],
     });
   }
 
+  /**
+   * Get the Diamond contract address
+   */
+  async getDiamond(): Promise<Address> {
+    return this._getCachedAddress("diamond", async () =>
+      this.publicClient.readContract({
+        address: this.routerAddress,
+        abi: RouterABI,
+        functionName: "diamond",
+      })
+    );
+  }
+
   /**
    * Preview mint output for a given LST amount
    * @param lst LST token address
@@ -147,6 +185,122 @@ export class AspanRouterReadClient {
     });
   }
 
+  /**
+   * SDK-only preview: input token -> estimated LST -> previewMint
+   * Note: oracle-based estimation (does not include live DEX slippage/price impact)
+   */
+  async previewMintByInput(
+    inputToken: Address,
+    inputAmount: bigint,
+    targetLST: Address,
+    mintXBNB: boolean
+  ): Promise<{ lstAmount: bigint; mintedAmount: bigint }> {
+    if (inputAmount === 0n) return { lstAmount: 0n, mintedAmount: 0n };
+
+    let lstAmount = 0n;
+    const inNorm = inputToken.toLowerCase();
+    
+    if (inNorm === targetLST.toLowerCase()) {
+      lstAmount = inputAmount;
+    } else {
+      const [diamond, wbnb, usdt, usdc] = await Promise.all([
+        this.getDiamond(),
+        this.getWBNB(),
+        this.getUSDT(),
+        this.getUSDC(),
+      ]);
+
+      const [bnbPrice8, lstPrice] = await Promise.all([
+        this.publicClient.readContract({
+          address: diamond,
+          abi: DiamondABI,
+          functionName: "getBNBPriceUSD",
+        }),
+        this.publicClient.readContract({
+          address: diamond,
+          abi: DiamondABI,
+          functionName: "getLSTPriceUSD",
+          args: [targetLST],
+        }),
+      ]);
+
+      const bnbPrice18 = BigInt(bnbPrice8) * 10n ** 10n;
+      const lstPrice18 = BigInt(lstPrice);
+      const one = 10n ** 18n;
+
+      if (inNorm === zeroAddress.toLowerCase() || inNorm === wbnb.toLowerCase()) {
+        // BNB/WBNB -> USD -> LST
+        const usdValue = (inputAmount * bnbPrice18) / one;
+        lstAmount = lstPrice18 === 0n ? 0n : (usdValue * one) / lstPrice18;
+      } else if (inNorm === usdt.toLowerCase() || inNorm === usdc.toLowerCase()) {
+        // stablecoin (18-decimal normalized in this SDK path) -> LST
+        lstAmount = lstPrice18 === 0n ? 0n : (inputAmount * one) / lstPrice18;
+      } else {
+        throw new Error("Unsupported input token for SDK preview");
+      }
+    }
+
+    const mintedAmount = await this.previewMint(targetLST, lstAmount, mintXBNB);
+    return { lstAmount, mintedAmount };
+  }
+
+  /**
+   * SDK-only preview: previewRedeem -> estimated output token
+   * Note: oracle-based estimation (does not include live DEX slippage/price impact)
+   */
+  async previewRedeemToOutput(
+    lst: Address,
+    redeemXBNB: boolean,
+    amount: bigint,
+    outputToken: Address
+  ): Promise<{ lstAmount: bigint; outputAmount: bigint }> {
+    const lstAmount = await this.previewRedeem(lst, redeemXBNB, amount);
+    if (lstAmount === 0n) return { lstAmount: 0n, outputAmount: 0n };
+
+    let outputAmount = 0n;
+    const outNorm = outputToken.toLowerCase();
+
+    if (outNorm === lst.toLowerCase()) {
+      outputAmount = lstAmount;
+    } else {
+      const [diamond, wbnb, usdt, usdc] = await Promise.all([
+        this.getDiamond(),
+        this.getWBNB(),
+        this.getUSDT(),
+        this.getUSDC(),
+      ]);
+
+      const [bnbPrice8, lstPrice] = await Promise.all([
+        this.publicClient.readContract({
+          address: diamond,
+          abi: DiamondABI,
+          functionName: "getBNBPriceUSD",
+        }),
+        this.publicClient.readContract({
+          address: diamond,
+          abi: DiamondABI,
+          functionName: "getLSTPriceUSD",
+          args: [lst],
+        }),
+      ]);
+
+      const bnbPrice18 = BigInt(bnbPrice8) * 10n ** 10n;
+      const lstPrice18 = BigInt(lstPrice);
+      const one = 10n ** 18n;
+      const usdValue = (lstAmount * lstPrice18) / one;
+
+      if (outNorm === zeroAddress.toLowerCase() || outNorm === wbnb.toLowerCase()) {
+        outputAmount = bnbPrice18 === 0n ? 0n : (usdValue * one) / bnbPrice18;
+      } else if (outNorm === usdt.toLowerCase() || outNorm === usdc.toLowerCase()) {
+        outputAmount = usdValue;
+      } else {
+        throw new Error("Unsupported output token for SDK preview");
+      }
+    }
+
+    return { lstAmount, outputAmount };
+  }
+
   /**
    * Get user's withdrawal request indices
    */
@@ -182,67 +336,83 @@ export class AspanRouterReadClient {
   // ============ Token Address Getters ============
 
   async getWBNB(): Promise<Address> {
-    return this.publicClient.readContract({
-      address: this.routerAddress,
-      abi: RouterABI,
-      functionName: "wbnb",
-    });
+    return this._getCachedAddress("wbnb", async () =>
+      this.publicClient.readContract({
+        address: this.routerAddress,
+        abi: RouterABI,
+        functionName: "wbnb",
+      })
+    );
   }
 
   async getUSDT(): Promise<Address> {
-    return this.publicClient.readContract({
-      address: this.routerAddress,
-      abi: RouterABI,
-      functionName: "usdt",
-    });
+    return this._getCachedAddress("usdt", async () =>
+      this.publicClient.readContract({
+        address: this.routerAddress,
+        abi: RouterABI,
+        functionName: "usdt",
+      })
+    );
   }
 
   async getUSDC(): Promise<Address> {
-    return this.publicClient.readContract({
-      address: this.routerAddress,
-      abi: RouterABI,
-      functionName: "usdc",
-    });
+    return this._getCachedAddress("usdc", async () =>
+      this.publicClient.readContract({
+        address: this.routerAddress,
+        abi: RouterABI,
+        functionName: "usdc",
+      })
+    );
   }
 
   async getSlisBNB(): Promise<Address> {
-    return this.publicClient.readContract({
-      address: this.routerAddress,
-      abi: RouterABI,
-      functionName: "slisBNB",
-    });
+    return this._getCachedAddress("slisBNB", async () =>
+      this.publicClient.readContract({
+        address: this.routerAddress,
+        abi: RouterABI,
+        functionName: "slisBNB",
+      })
+    );
   }
 
   async getAsBNB(): Promise<Address> {
-    return this.publicClient.readContract({
-      address: this.routerAddress,
-      abi: RouterABI,
-      functionName: "asBNB",
-    });
+    return this._getCachedAddress("asBNB", async () =>
+      this.publicClient.readContract({
+        address: this.routerAddress,
+        abi: RouterABI,
+        functionName: "asBNB",
+      })
+    );
   }
 
   async getWclisBNB(): Promise<Address> {
-    return this.publicClient.readContract({
-      address: this.routerAddress,
-      abi: RouterABI,
-      functionName: "wclisBNB",
-    });
+    return this._getCachedAddress("wclisBNB", async () =>
+      this.publicClient.readContract({
+        address: this.routerAddress,
+        abi: RouterABI,
+        functionName: "wclisBNB",
+      })
+    );
   }
 
   async getApUSD(): Promise<Address> {
-    return this.publicClient.readContract({
-      address: this.routerAddress,
-      abi: RouterABI,
-      functionName: "apUSD",
-    });
+    return this._getCachedAddress("apUSD", async () =>
+      this.publicClient.readContract({
+        address: this.routerAddress,
+        abi: RouterABI,
+        functionName: "apUSD",
+      })
+    );
   }
 
   async getXBNB(): Promise<Address> {
-    return this.publicClient.readContract({
-      address: this.routerAddress,
-      abi: RouterABI,
-      functionName: "xBNB",
-    });
+    return this._getCachedAddress("xBNB", async () =>
+      this.publicClient.readContract({
+        address: this.routerAddress,
+        abi: RouterABI,
+        functionName: "xBNB",
+      })
+    );
   }
 }
 

package/src/types.ts

@@ -128,11 +128,6 @@ export interface WithdrawParams {
   shares: bigint;
 }
 
-/** Parameters for withdrawing assets from stability pool */
-export interface WithdrawAssetsParams {
-  assets: bigint;
-}
-
 // ============ Protocol Stats ============
 
 /** Overall protocol statistics */