@aspan/sdk 0.4.0 → 0.4.1

package/src/bot/services/risk-keeper.ts

@@ -0,0 +1,519 @@
+/**
+ * Risk Keeper Service
+ * Executes risk management actions: SM2 trigger and TWAP vault cleaning
+ */
+
+import {
+  createPublicClient,
+  createWalletClient,
+  http,
+  type Address,
+  type PublicClient,
+  type WalletClient,
+  type Chain,
+  type Account,
+  type Hash,
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { bsc } from "viem/chains";
+import type { AspanReadClient } from "../../client";
+import { DiamondABI } from "../../abi/diamond";
+import { SApUSDABI } from "../../abi/sApUSD";
+import type { SlackService } from "./slack";
+import { SlackColors } from "./slack";
+import type { BotConfig } from "../config";
+import { withRetry } from "./rpc-client";
+
+// ============ Types ============
+
+export interface RiskKeeperConfig {
+  /** Diamond contract address */
+  diamondAddress: Address;
+  /** sApUSD vault address */
+  sApUSDAddress: Address;
+  /** DEX router address (PancakeSwap) */
+  routerAddress: Address;
+  /** WBNB address */
+  wbnbAddress: Address;
+  /** Keeper private key */
+  privateKey: `0x${string}`;
+  /** RPC URL */
+  rpcUrl: string;
+  /** Chain */
+  chain?: Chain;
+  /** SM2 cooldown in ms (default 30 min) */
+  sm2CooldownMs?: number;
+  /** SM2 max pool percentage per trigger (default 40%) */
+  sm2MaxPoolPercent?: number;
+  /** TWAP interval in ms (default 10 min) */
+  twapIntervalMs?: number;
+  /** TWAP percentage per batch (default 5%) */
+  twapPercentage?: number;
+  /** Max slippage BPS (default 50 = 0.5%) */
+  maxSlippageBps?: number;
+  /** CR threshold to start TWAP cleaning (default 13500 = 135%) */
+  twapStartCR?: bigint;
+  /** Max BNB price volatility for TWAP (default 5%) */
+  maxVolatilityPercent?: number;
+}
+
+interface KeeperState {
+  lastSM2Trigger: number;
+  lastTWAPExecution: number;
+  isProcessing: boolean;
+}
+
+// ============ Risk Keeper Service ============
+
+export class RiskKeeperService {
+  private readonly client: AspanReadClient;
+  private readonly publicClient: PublicClient;
+  private readonly walletClient: WalletClient;
+  private readonly slack: SlackService;
+  private readonly config: BotConfig;
+  private readonly keeperConfig: RiskKeeperConfig;
+  private readonly account: Account;
+
+  private state: KeeperState = {
+    lastSM2Trigger: 0,
+    lastTWAPExecution: 0,
+    isProcessing: false,
+  };
+
+  private sm2IntervalId?: ReturnType<typeof setInterval>;
+  private twapIntervalId?: ReturnType<typeof setInterval>;
+
+  // Defaults
+  private readonly SM2_COOLDOWN_MS: number;
+  private readonly SM2_MAX_POOL_PERCENT: number;
+  private readonly TWAP_INTERVAL_MS: number;
+  private readonly TWAP_PERCENTAGE: number;
+  private readonly MAX_SLIPPAGE_BPS: number;
+  private readonly TWAP_START_CR: bigint;
+  private readonly MAX_VOLATILITY_PERCENT: number;
+
+  // Price tracking for volatility
+  private lastBNBPrice: bigint = 0n;
+  /** Timestamp of last BNB price check (used for volatility tracking) */
+  public lastPriceTime: number = 0;
+
+  constructor(
+    client: AspanReadClient,
+    slack: SlackService,
+    botConfig: BotConfig,
+    keeperConfig: RiskKeeperConfig
+  ) {
+    this.client = client;
+    this.slack = slack;
+    this.config = botConfig;
+    this.keeperConfig = keeperConfig;
+
+    // Set defaults
+    this.SM2_COOLDOWN_MS = keeperConfig.sm2CooldownMs ?? 30 * 60 * 1000; // 30 min
+    this.SM2_MAX_POOL_PERCENT = keeperConfig.sm2MaxPoolPercent ?? 40; // 40% max per trigger
+    this.TWAP_INTERVAL_MS = keeperConfig.twapIntervalMs ?? 10 * 60 * 1000; // 10 min
+    this.TWAP_PERCENTAGE = keeperConfig.twapPercentage ?? 5; // 5%
+    this.MAX_SLIPPAGE_BPS = keeperConfig.maxSlippageBps ?? 50; // 0.5%
+    this.TWAP_START_CR = keeperConfig.twapStartCR ?? 13500n; // 135%
+    this.MAX_VOLATILITY_PERCENT = keeperConfig.maxVolatilityPercent ?? 5; // 5%
+
+    // Setup account and clients
+    this.account = privateKeyToAccount(keeperConfig.privateKey);
+    const chain = keeperConfig.chain ?? bsc;
+
+    this.publicClient = createPublicClient({
+      chain,
+      transport: http(keeperConfig.rpcUrl),
+    });
+
+    this.walletClient = createWalletClient({
+      chain,
+      transport: http(keeperConfig.rpcUrl),
+      account: this.account,
+    });
+
+    console.log(`[RiskKeeper] Initialized with address: ${this.account.address}`);
+  }
+
+  // ============ Lifecycle ============
+
+  start(): void {
+    console.log("[RiskKeeper] Starting risk keeper service...");
+    console.log(`[RiskKeeper] SM2 cooldown: ${this.SM2_COOLDOWN_MS / 1000}s`);
+    console.log(`[RiskKeeper] TWAP interval: ${this.TWAP_INTERVAL_MS / 1000}s`);
+    console.log(`[RiskKeeper] TWAP percentage: ${this.TWAP_PERCENTAGE}%`);
+
+    // Initial checks
+    this.checkAndTriggerSM2();
+    this.checkAndExecuteTWAP();
+
+    // Schedule regular checks
+    this.sm2IntervalId = setInterval(
+      () => this.checkAndTriggerSM2(),
+      30 * 1000 // Check every 30 seconds
+    );
+
+    this.twapIntervalId = setInterval(
+      () => this.checkAndExecuteTWAP(),
+      this.TWAP_INTERVAL_MS
+    );
+
+    console.log("[RiskKeeper] Service started");
+  }
+
+  stop(): void {
+    if (this.sm2IntervalId) {
+      clearInterval(this.sm2IntervalId);
+      this.sm2IntervalId = undefined;
+    }
+    if (this.twapIntervalId) {
+      clearInterval(this.twapIntervalId);
+      this.twapIntervalId = undefined;
+    }
+    console.log("[RiskKeeper] Service stopped");
+  }
+
+  // ============ Stability Mode 2 ============
+
+  private async checkAndTriggerSM2(): Promise<void> {
+    if (this.state.isProcessing) return;
+
+    try {
+      // Check cooldown
+      const now = Date.now();
+      if (now - this.state.lastSM2Trigger < this.SM2_COOLDOWN_MS) {
+        return;
+      }
+
+      // Check if SM2 can be triggered
+      const sm2Info = await withRetry(
+        () => this.client.canTriggerStabilityMode2(),
+        this.config,
+        "canTriggerStabilityMode2"
+      );
+
+      if (!sm2Info.canTrigger) {
+        return;
+      }
+
+      // Check if stability pool has balance
+      if (sm2Info.potentialConversion === 0n) {
+        console.log("[RiskKeeper] SM2 triggered but no conversion possible (empty pool)");
+        return;
+      }
+
+      // Get pool balance and enforce 40% max
+      const poolStats = await withRetry(
+        () => this.client.getStabilityPoolStats(),
+        this.config,
+        "getStabilityPoolStats"
+      );
+
+      const maxConversion = (poolStats.totalStaked * BigInt(this.SM2_MAX_POOL_PERCENT)) / 100n;
+      
+      // If potential conversion exceeds 40%, we need a lower target CR
+      // For simplicity, we'll just warn and proceed - the contract will cap at pool balance anyway
+      if (sm2Info.potentialConversion > maxConversion) {
+        console.log(`[RiskKeeper] Potential conversion ${sm2Info.potentialConversion} exceeds ${this.SM2_MAX_POOL_PERCENT}% limit (${maxConversion})`);
+        console.log(`[RiskKeeper] Will execute with reduced target to stay within limit`);
+      }
+
+      console.log(`[RiskKeeper] SM2 conditions met! CR: ${sm2Info.currentCR}, Potential: ${sm2Info.potentialConversion}`);
+
+      this.state.isProcessing = true;
+
+      // Calculate target CR that respects the 40% limit
+      // If potentialConversion > maxConversion, use a lower target
+      let targetCR = 14000n; // Default 140%
+      if (sm2Info.potentialConversion > maxConversion && maxConversion > 0n) {
+        // Calculate what CR we'd get with maxConversion
+        // This is approximate - actual CR depends on TVL which we fetch
+        const tvl = await withRetry(
+          () => this.client.getTVLInUSD(),
+          this.config,
+          "getTVLInUSD"
+        );
+        const apUSDSupply = await withRetry(
+          () => this.client.getApUSDSupply(),
+          this.config,
+          "getApUSDSupply"
+        );
+        
+        // New supply after burning maxConversion
+        const newSupply = apUSDSupply - maxConversion;
+        if (newSupply > 0n) {
+          // targetCR = TVL * 10000 / newSupply
+          targetCR = (tvl * 10000n) / newSupply;
+          // Cap at 140% max
+          if (targetCR > 14000n) targetCR = 14000n;
+        }
+        console.log(`[RiskKeeper] Adjusted target CR to ${targetCR} to respect ${this.SM2_MAX_POOL_PERCENT}% limit`);
+      }
+
+      // Execute SM2
+      const txHash = await this.executeSM2(targetCR);
+
+      // Wait for confirmation
+      const receipt = await this.publicClient.waitForTransactionReceipt({ hash: txHash });
+
+      if (receipt.status === "success") {
+        this.state.lastSM2Trigger = now;
+        await this.notifySM2Success(sm2Info.currentCR, sm2Info.potentialConversion, txHash);
+      } else {
+        await this.notifySM2Failure(txHash, "Transaction reverted");
+      }
+    } catch (error) {
+      console.error("[RiskKeeper] SM2 check/trigger failed:", error);
+      await this.notifySM2Failure(undefined, String(error));
+    } finally {
+      this.state.isProcessing = false;
+    }
+  }
+
+  private async executeSM2(targetCR: bigint): Promise<Hash> {
+    console.log(`[RiskKeeper] Executing SM2 with target CR: ${targetCR}`);
+
+    return this.walletClient.writeContract({
+      chain: bsc,
+      account: this.account,      address: this.keeperConfig.diamondAddress,
+      abi: DiamondABI,
+      functionName: "triggerStabilityMode2",
+      args: [targetCR],
+    });
+  }
+
+  // ============ TWAP Vault Cleaning ============
+
+  private async checkAndExecuteTWAP(): Promise<void> {
+    if (this.state.isProcessing) return;
+
+    try {
+      // Check if vault is dirty (has xBNB)
+      const vaultState = await this.getVaultState();
+
+      if (!vaultState.hasXBNB || vaultState.xBNBAmount === 0n) {
+        return;
+      }
+
+      // Check CR is above threshold (safe to sell xBNB)
+      const sm = await withRetry(
+        () => this.client.getStabilityMode(),
+        this.config,
+        "getStabilityMode"
+      );
+
+      if (sm.currentCR < this.TWAP_START_CR) {
+        console.log(`[RiskKeeper] CR ${sm.currentCR} below TWAP threshold ${this.TWAP_START_CR}, skipping`);
+        return;
+      }
+
+      // Check BNB price volatility
+      const isVolatile = await this.checkVolatility();
+      if (isVolatile) {
+        console.log(`[RiskKeeper] BNB price too volatile (>${this.MAX_VOLATILITY_PERCENT}%), skipping TWAP`);
+        return;
+      }
+
+      console.log(`[RiskKeeper] Vault dirty with ${vaultState.xBNBAmount} xBNB, executing TWAP clean`);
+
+      this.state.isProcessing = true;
+
+      // Calculate amount to clean (X% of total)
+      const cleanAmount = (vaultState.xBNBAmount * BigInt(this.TWAP_PERCENTAGE)) / 100n;
+
+      if (cleanAmount === 0n) {
+        console.log("[RiskKeeper] Clean amount too small, skipping");
+        return;
+      }
+
+      // Execute TWAP clean
+      const txHash = await this.executeVaultClean(cleanAmount);
+
+      // Wait for confirmation
+      const receipt = await this.publicClient.waitForTransactionReceipt({ hash: txHash });
+
+      if (receipt.status === "success") {
+        this.state.lastTWAPExecution = Date.now();
+        await this.notifyTWAPSuccess(cleanAmount, txHash);
+      } else {
+        await this.notifyTWAPFailure(txHash, "Transaction reverted");
+      }
+    } catch (error) {
+      console.error("[RiskKeeper] TWAP check/execute failed:", error);
+      await this.notifyTWAPFailure(undefined, String(error));
+    } finally {
+      this.state.isProcessing = false;
+    }
+  }
+
+  /**
+   * Check if BNB price is too volatile for TWAP execution
+   * Returns true if volatility exceeds threshold
+   */
+  private async checkVolatility(): Promise<boolean> {
+    try {
+      const currentPrice = await withRetry(
+        () => this.client.getBNBPriceUSD(),
+        this.config,
+        "getBNBPriceUSD"
+      );
+
+      const now = Date.now();
+
+      // First run - just record price
+      if (this.lastBNBPrice === 0n) {
+        this.lastBNBPrice = currentPrice;
+        this.lastPriceTime = now;
+        return false;
+      }
+
+      // Calculate price change percentage
+      const priceDiff = currentPrice > this.lastBNBPrice
+        ? currentPrice - this.lastBNBPrice
+        : this.lastBNBPrice - currentPrice;
+      
+      const changePercent = Number((priceDiff * 100n) / this.lastBNBPrice);
+
+      // Update tracked price
+      this.lastBNBPrice = currentPrice;
+      this.lastPriceTime = now;
+
+      if (changePercent > this.MAX_VOLATILITY_PERCENT) {
+        console.log(`[RiskKeeper] Volatility: ${changePercent.toFixed(2)}% > ${this.MAX_VOLATILITY_PERCENT}%`);
+        return true;
+      }
+
+      return false;
+    } catch (error) {
+      console.error("[RiskKeeper] Volatility check failed:", error);
+      // If we can't check volatility, be conservative and skip
+      return true;
+    }
+  }
+
+  private async getVaultState(): Promise<{ hasXBNB: boolean; xBNBAmount: bigint }> {
+    const result = await this.publicClient.readContract({
+      address: this.keeperConfig.sApUSDAddress,
+      abi: SApUSDABI,
+      functionName: "hasStabilityConversion",
+    });
+
+    return {
+      hasXBNB: result[0],
+      xBNBAmount: result[1],
+    };
+  }
+
+  private async executeVaultClean(xBNBAmount: bigint): Promise<Hash> {
+    console.log(`[RiskKeeper] Cleaning ${xBNBAmount} xBNB from vault`);
+
+    // Build swap path: xBNB -> WBNB -> apUSD
+    // Note: In production, might need xBNB -> WBNB -> USDT -> apUSD
+    const path = [
+      await this.getXBNBAddress(),
+      this.keeperConfig.wbnbAddress,
+      await this.getApUSDAddress(),
+    ];
+
+    // Preview output
+    const expectedOut = await this.previewClean(xBNBAmount, path);
+
+    // Calculate min out with slippage
+    const minOut = (expectedOut * BigInt(10000 - this.MAX_SLIPPAGE_BPS)) / 10000n;
+
+    // Deadline: 5 minutes from now
+    const deadline = BigInt(Math.floor(Date.now() / 1000) + 300);
+
+    return this.walletClient.writeContract({
+      chain: bsc,
+      account: this.account,      address: this.keeperConfig.sApUSDAddress,
+      abi: SApUSDABI,
+      functionName: "cleanXBNB",
+      args: [xBNBAmount, minOut, this.keeperConfig.routerAddress, path, deadline],
+    });
+  }
+
+  private async previewClean(xBNBAmount: bigint, path: Address[]): Promise<bigint> {
+    return this.publicClient.readContract({
+      address: this.keeperConfig.sApUSDAddress,
+      abi: SApUSDABI,
+      functionName: "previewCleanXBNB",
+      args: [xBNBAmount, this.keeperConfig.routerAddress, path],
+    });
+  }
+
+  private async getXBNBAddress(): Promise<Address> {
+    const tokens = await this.client.getTokens();
+    return tokens.xBNB;
+  }
+
+  private async getApUSDAddress(): Promise<Address> {
+    const tokens = await this.client.getTokens();
+    return tokens.apUSD;
+  }
+
+  // ============ Notifications ============
+
+  private async notifySM2Success(cr: bigint, amount: bigint, txHash: Hash): Promise<void> {
+    console.log(`[RiskKeeper] SM2 executed successfully: ${txHash}`);
+
+    await this.slack.send({
+      attachments: [{
+        color: SlackColors.warning,
+        title: ":rotating_light: Stability Mode 2 Triggered",
+        text: "Forced conversion executed to restore CR",
+        fields: [
+          { title: "CR Before", value: `${Number(cr) / 100}%`, short: true },
+          { title: "Amount Converted", value: `${Number(amount) / 1e18} apUSD`, short: true },
+          { title: "TX", value: `<https://bscscan.com/tx/${txHash}|View>`, short: true },
+        ],
+        ts: Math.floor(Date.now() / 1000),
+      }],
+    });
+  }
+
+  private async notifySM2Failure(txHash: Hash | undefined, error: string): Promise<void> {
+    console.error(`[RiskKeeper] SM2 execution failed: ${error}`);
+
+    await this.slack.send({
+      attachments: [{
+        color: SlackColors.danger,
+        title: ":x: SM2 Execution Failed",
+        text: error,
+        fields: txHash ? [{ title: "TX", value: `<https://bscscan.com/tx/${txHash}|View>`, short: true }] : [],
+        ts: Math.floor(Date.now() / 1000),
+      }],
+    });
+  }
+
+  private async notifyTWAPSuccess(amount: bigint, txHash: Hash): Promise<void> {
+    console.log(`[RiskKeeper] TWAP clean executed successfully: ${txHash}`);
+
+    await this.slack.send({
+      attachments: [{
+        color: SlackColors.success,
+        title: ":broom: Vault TWAP Clean Executed",
+        text: "xBNB cleaned from stability pool vault",
+        fields: [
+          { title: "xBNB Sold", value: `${Number(amount) / 1e18}`, short: true },
+          { title: "TX", value: `<https://bscscan.com/tx/${txHash}|View>`, short: true },
+        ],
+        ts: Math.floor(Date.now() / 1000),
+      }],
+    });
+  }
+
+  private async notifyTWAPFailure(txHash: Hash | undefined, error: string): Promise<void> {
+    console.error(`[RiskKeeper] TWAP execution failed: ${error}`);
+
+    await this.slack.send({
+      attachments: [{
+        color: SlackColors.danger,
+        title: ":x: TWAP Clean Failed",
+        text: error,
+        fields: txHash ? [{ title: "TX", value: `<https://bscscan.com/tx/${txHash}|View>`, short: true }] : [],
+        ts: Math.floor(Date.now() / 1000),
+      }],
+    });
+  }
+}

package/src/client.ts

@@ -798,6 +798,32 @@ export class AspanReadClient {
     });
   }
 
+  // ============ Bootstrap View Functions ============
+
+  /**
+   * Check if xBNB liquidity has been bootstrapped
+   * @returns true if bootstrap has been called
+   */
+  async isBootstrapped(): Promise<boolean> {
+    return this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: DiamondABI,
+      functionName: "isBootstrapped",
+    });
+  }
+
+  /**
+   * Get the amount of xBNB locked in bootstrap (burned to dead address)
+   * @returns xBNB amount in wei
+   */
+  async getBootstrapXBNBAmount(): Promise<bigint> {
+    return this.publicClient.readContract({
+      address: this.diamondAddress,
+      abi: DiamondABI,
+      functionName: "getBootstrapXBNBAmount",
+    });
+  }
+
   // ============ Stability Mode View Functions ============
 
   async getStabilityMode(): Promise<StabilityModeInfo> {
@@ -1031,6 +1057,89 @@ export class AspanClient extends AspanReadClient {
     });
   }
 
+  // ============ Risk Management Functions ============
+
+  /**
+   * Trigger Stability Mode 2 forced conversion
+   * @description Anyone can call when CR < 130%. Burns apUSD from stability pool
+   * and mints xBNB to compensate stakers.
+   * @param targetCR Target CR to restore to (in BPS, e.g., 14000 = 140%)
+   * @returns Transaction hash
+   */
+  async triggerStabilityMode2(targetCR: bigint = 14000n): Promise<Hash> {
+    return this.walletClient.writeContract({
+      chain: this.chain,
+      account: this.walletClient.account!,
+      address: this.diamondAddress,
+      abi: DiamondABI,
+      functionName: "triggerStabilityMode2",
+      args: [targetCR],
+    });
+  }
+
+  /**
+   * Clean underwater xBNB (burn without getting LST back)
+   * @description Only works when xBNB is underwater (price = 0)
+   * @param xBNBAmount Amount of xBNB to clean (burn)
+   * @returns Transaction hash
+   */
+  async cleanXbnb(xBNBAmount: bigint): Promise<Hash> {
+    return this.walletClient.writeContract({
+      chain: this.chain,
+      account: this.walletClient.account!,
+      address: this.diamondAddress,
+      abi: DiamondABI,
+      functionName: "cleanXbnb",
+      args: [xBNBAmount],
+    });
+  }
+
+  // ============ Fee Management Functions ============
+
+  /**
+   * Set fee tiers (requires feeManager or owner role)
+   * @param tiers Array of fee tier configurations
+   * @returns Transaction hash
+   */
+  async setFeeTiers(tiers: Array<{
+    minCR: bigint;
+    apUSDMintFee: number;
+    apUSDRedeemFee: number;
+    xBNBMintFee: number;
+    xBNBRedeemFee: number;
+    apUSDMintDisabled: boolean;
+  }>): Promise<Hash> {
+    return this.walletClient.writeContract({
+      chain: this.chain,
+      account: this.walletClient.account!,
+      address: this.diamondAddress,
+      abi: DiamondABI,
+      functionName: "setFeeTiers",
+      args: [tiers],
+    });
+  }
+
+  // ============ Admin Functions ============
+
+  /**
+   * Bootstrap xBNB liquidity (owner only)
+   * @description Initializes xBNB supply by minting to dead address, preventing extreme initial prices.
+   * Similar to Uniswap V2's MINIMUM_LIQUIDITY. Can only be called once.
+   * @param lstToken LST token address to deposit
+   * @param lstAmount Amount of LST to deposit for bootstrap
+   * @returns Transaction hash
+   */
+  async bootstrap(lstToken: Address, lstAmount: bigint): Promise<Hash> {
+    return this.walletClient.writeContract({
+      chain: this.chain,
+      account: this.walletClient.account!,
+      address: this.diamondAddress,
+      abi: DiamondABI,
+      functionName: "bootstrap",
+      args: [lstToken, lstAmount],
+    });
+  }
+
   // ============ Transaction Helpers ============
 
   /**

package/src/index.ts

@@ -102,15 +102,15 @@ export const PRICE_PRECISION = 10n ** 8n; // Chainlink price precision
 
 // ============ Contract Addresses (BSC Mainnet) ============
 export const BSC_ADDRESSES = {
-  diamond: "0x10d25Ae0690533e0BA9E64EC7ae77dbD4fE8A46f" as const,
+  diamond: "0x6a11B30d3a70727d5477D6d8090e144443fA1c78" as const,
   router: "0x813d3D1A3154950E2f1d8718305426a335A974A9" as const,
-  apUSD: "0x1977097E2E5697A6DD91b6732F368a14F50f6B3d" as const,
-  xBNB: "0xB78eB4d5928bAb158Eb23c3154544084cD2661d5" as const,
-  sApUSD: "0xE2BE739C4aA4126ee72D612d9548C38B1B0e5A1b" as const,
+  apUSD: "0x4570047eeB5aDb4081c5d470494EB5134e34A287" as const,
+  xBNB: "0x0A0c9CD826e747D99F90D63e780B3727Da4D0d43" as const,
+  sApUSD: "0x73407A291c007a47CC926EcD5CaC256A1E2d00cF" as const,
   // LSTs
   slisBNB: "0xB0b84D294e0C75A6abe60171b70edEb2EFd14A1B" as const,
   asBNB: "0x77734e70b6E88b4d82fE632a168EDf6e700912b6" as const,
-  wclisBNB: "0x439faaC2229559121C4Ad4fd8B3FE13Dff038046" as const,
+  wclisBNB: "0x448f7c2fa4e5135a4a5B50879602cf3CD428e108" as const,
   // Stablecoins
   USDT: "0x55d398326f99059fF775485246999027B3197955" as const,
   USDC: "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d" as const,