@aspan/sdk 0.4.6 → 0.4.7

package/src/__tests__/risk.test.ts

@@ -0,0 +1,2084 @@
+/**
+ * Aspan Risk Control Tests — Dual Mode (Fork + Live)
+ *
+ * Supports two execution modes:
+ *
+ *   1. Fork Mode (Anvil):
+ *      Full test suite with CR manipulation, snapshot/revert, whale funding.
+ *      Requires a running Anvil instance:
+ *        anvil --fork-url https://bsc-dataseed.binance.org/ --fork-block-number <recent>
+ *      Run: npm run test:risk   (or: ANVIL_RPC=http://127.0.0.1:8545 npm run test:risk)
+ *
+ *   2. Live Mode (Real BSC):
+ *      Tests at the current on-chain CR zone using your own wallet funds.
+ *      Fork-only tests (CR manipulation, oracle staleness, stability pool SM2) are skipped.
+ *      Run: PRIVATE_KEY=0x... npm run test:risk
+ *      Optional: BSC_RPC_URL=https://... to specify RPC endpoint
+ *
+ * Covers:
+ *   FC-01:  Dynamic Fee Control (Zone A/B/C/D fee verification, auto-switch, recovery)  [Fork]
+ *   FC-02:  Stability Pool Intervention (SM2, dirty pool, exchangeRate)                 [Fork]
+ *   FC-04:  Extreme Scenarios (Oracle freeze mode)                                      [Fork]
+ *   P-01:   apUSD Stablecoin Full Paths (USDT → apUSD → USDT per zone)                 [Fork]
+ *   P-02:   xBNB / LST Full Paths (BNB/slisBNB/asBNB → xBNB per zone)                 [Fork]
+ *   P-03:   Zap Cross-boundary Paths                                                   [Fork]
+ *   P-04:   Stability Pool Closed Loop (deposit → SM2 → dual-asset withdraw)           [Fork]
+ *   L-01~06: Current zone fee + path + stats verification                              [Live]
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { privateKeyToAccount } from "viem/accounts";
+import {
+  createPublicClient,
+  createTestClient,
+  createWalletClient,
+  decodeEventLog,
+  http,
+  parseEther,
+  zeroAddress,
+  type Address,
+  type Hash,
+} from "viem";
+import { bsc } from "viem/chains";
+import {
+  AspanClient,
+  AspanReadClient,
+  AspanRouterClient,
+  AspanRouterReadClient,
+  DiamondABI,
+  formatAmount,
+  formatCR,
+  parseAmount,
+  encodeV3Path,
+  type CurrentFees,
+  type FeeTier,
+} from "../index";
+
+// ============ Configuration ============
+
+const ANVIL_RPC = process.env.ANVIL_RPC || "http://127.0.0.1:8545";
+const BSC_RPC_URL = process.env.BSC_RPC_URL || "https://bsc-dataseed.binance.org/";
+const ANVIL_DEFAULT_KEY = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";
+
+const DIAMOND = "0x6a11B30d3a70727d5477D6d8090e144443fA1c78" as Address;
+const ROUTER = "0x34a64c4EbDe830773083BA8c9469456616F6723b" as Address;
+
+const TOKENS = {
+  WBNB: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c" as Address,
+  USDT: "0x55d398326f99059fF775485246999027B3197955" as Address,
+  USDC: "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d" as Address,
+  slisBNB: "0xB0b84D294e0C75A6abe60171b70edEb2EFd14A1B" as Address,
+  asBNB: "0x77734e70b6E88b4d82fE632a168EDf6e700912b6" as Address,
+  wclisBNB: "0x448f7c2fa4e5135a4a5B50879602cf3CD428e108" as Address,
+  apUSD: "0x4570047eeB5aDb4081c5d470494EB5134e34A287" as Address,
+  xBNB: "0x0A0c9CD826e747D99F90D63e780B3727Da4D0d43" as Address,
+  sApUSD: "0xE2BE739C4aA4126ee72D612d9548C38B1B0e5A1b" as Address,
+};
+
+// Whale addresses for token funding (Binance hot wallets on BSC)
+const USDT_WHALE = "0xF977814e90dA44bFA03b6295A0616a897441aceC" as Address;
+const USDC_WHALE = "0x8894E0a0c962CB723c1ef8580d0d3Bfe0f8BC51e" as Address;
+const FEE_RECIPIENT = "0xcFe16C686b0697c90FC83f27150e4fc31B107874" as Address;
+
+// ERC20 Transfer event topic0
+const TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+
+// Fee rates and CR boundaries - populated dynamically from contract in beforeAll
+let ZONE_FEES: Record<string, {
+  xBNBMintFee: number; xBNBRedeemFee: number;
+  apUSDMintFee: number; apUSDRedeemFee: number;
+  apUSDMintDisabled: boolean;
+}> = {};
+
+let ZONE_CR: Record<string, bigint> = {};
+let ZONE_LAST_LABEL = "D";
+
+const ERC20_ABI = [
+  { name: "balanceOf", type: "function", stateMutability: "view", inputs: [{ type: "address" }], outputs: [{ type: "uint256" }] },
+  { name: "approve", type: "function", stateMutability: "nonpayable", inputs: [{ type: "address" }, { type: "uint256" }], outputs: [{ type: "bool" }] },
+  { name: "transfer", type: "function", stateMutability: "nonpayable", inputs: [{ type: "address" }, { type: "uint256" }], outputs: [{ type: "bool" }] },
+] as const;
+
+const isAnvilAvailable = async (): Promise<boolean> => {
+  try {
+    const client = createPublicClient({ transport: http(ANVIL_RPC) });
+    await client.getChainId();
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const IS_FORK = await isAnvilAvailable();
+const IS_LIVE = !IS_FORK && !!process.env.PRIVATE_KEY;
+const RPC_URL = IS_FORK ? ANVIL_RPC : BSC_RPC_URL;
+const PRIVATE_KEY_HEX = (IS_FORK ? ANVIL_DEFAULT_KEY : process.env.PRIVATE_KEY) as `0x${string}`;
+
+// ============ Main Test Suite ============
+
+describe.skipIf(!IS_FORK && !IS_LIVE)("Risk Control Tests", () => {
+  let diamondRead: AspanReadClient;
+  let diamondWrite: AspanClient;
+  let routerRead: AspanRouterReadClient;
+  let routerWrite: AspanRouterClient;
+  let publicClient: ReturnType<typeof createPublicClient>;
+  let testClient: ReturnType<typeof createTestClient>;
+  let walletClient: ReturnType<typeof createWalletClient>;
+  let account: ReturnType<typeof privateKeyToAccount>;
+
+  const sleep = (ms: number) => new Promise(r => setTimeout(r, ms));
+
+  // ============ Helpers ============
+
+  const getBalance = async (token: Address): Promise<bigint> =>
+    publicClient.readContract({
+      address: token, abi: ERC20_ABI, functionName: "balanceOf", args: [account.address],
+    }) as Promise<bigint>;
+
+  const MAX_UINT256 = 2n ** 256n - 1n;
+  const approvedPairs = new Set<string>();
+  const MIN_GAS_BNB = parseEther("0.0003");
+  let txWaitMs = 500;
+
+  const approve = async (token: Address, spender: Address, amount: bigint) => {
+    const key = `${token.toLowerCase()}-${spender.toLowerCase()}`;
+    if (approvedPairs.has(key)) return;
+    const hash = await walletClient.writeContract({
+      address: token, abi: ERC20_ABI, functionName: "approve", args: [spender, MAX_UINT256],
+      chain: bsc, account: account,
+    });
+    await publicClient.waitForTransactionReceipt({ hash });
+    approvedPairs.add(key);
+    if (IS_LIVE) await sleep(500);
+  };
+
+  const ensureGas = async (label: string): Promise<boolean> => {
+    const bnbBal = await publicClient.getBalance({ address: account.address });
+    if (bnbBal < MIN_GAS_BNB) {
+      console.log(`  ⚠️ [${label}] Insufficient BNB for gas: ${formatAmount(bnbBal)} BNB (need ≥ ${formatAmount(MIN_GAS_BNB)})`);
+      return false;
+    }
+    return true;
+  };
+
+  const waitTx = async (hash: Hash) => {
+    const receipt = await publicClient.waitForTransactionReceipt({ hash });
+    expect(receipt.status).toBe("success");
+    if (IS_LIVE) await sleep(txWaitMs);
+    return receipt;
+  };
+
+  const getCR = () => diamondRead.getCollateralRatio();
+  const getFees = () => diamondRead.getCurrentFees();
+  const dl = () => BigInt(Math.floor(Date.now() / 1000) + 7200);
+
+  /** Atomic read of CR + TVL + supply via multicall (same block guarantee) */
+  const readProtocolState = async () => {
+    const results = await publicClient.multicall({
+      contracts: [
+        { address: DIAMOND, abi: DiamondABI, functionName: "getCollateralRatio" },
+        { address: DIAMOND, abi: DiamondABI, functionName: "getTVLInBNB" },
+        { address: DIAMOND, abi: DiamondABI, functionName: "getTVLInUSD" },
+        { address: DIAMOND, abi: DiamondABI, functionName: "getApUSDSupply" },
+      ] as const,
+      allowFailure: true,
+    });
+    let cr = results[0].status === "success" ? (results[0].result as bigint) : 0n;
+    if (cr > 100000000n) cr = 0n;
+    const tvlBNB = results[1].status === "success" ? (results[1].result as bigint) : 0n;
+    const tvlUSD = results[2].status === "success" ? (results[2].result as bigint) : 0n;
+    const supply = results[3].status === "success" ? (results[3].result as bigint) : 0n;
+    return { cr, tvlBNB, tvlUSD, supply };
+  };
+
+  const getZone = (cr: bigint): string => {
+    const zones = Object.entries(ZONE_CR)
+      .map(([key, min]) => ({ label: key.replace("_MIN", ""), min }))
+      .sort((a, b) => (a.min > b.min ? -1 : 1));
+    for (const { label, min } of zones) {
+      if (cr >= min) return label;
+    }
+    return ZONE_LAST_LABEL;
+  };
+
+  const verifyCR = async (label: string) => {
+    const { cr: contractCR, tvlUSD: tvlInUSD, supply: apUSDSupply } = await readProtocolState();
+
+    let calculatedCR = 0n;
+    if (apUSDSupply > 0n) {
+      calculatedCR = tvlInUSD * 10000n / apUSDSupply;
+    }
+
+    const zone = getZone(contractCR);
+    console.log(`  ${label}: TVL=$${formatAmount(tvlInUSD)} | apUSD=${formatAmount(apUSDSupply)} | CR(contract)=${formatCR(contractCR)} | CR(calc)=${formatCR(calculatedCR)} | Zone ${zone}`);
+
+    if (apUSDSupply > 0n) {
+      const diff = contractCR > calculatedCR
+        ? contractCR - calculatedCR
+        : calculatedCR - contractCR;
+      expect(diff).toBeLessThanOrEqual(1n);
+    }
+
+    return { contractCR, calculatedCR, tvlInUSD, apUSDSupply, zone };
+  };
+
+  const verifyFees = (fees: CurrentFees, zone: keyof typeof ZONE_FEES, label: string) => {
+    const expected = ZONE_FEES[zone];
+    console.log(`  ${label}: CR=${formatCR(fees.currentCR)} | xBNBMint=${fees.xBNBMintFee} xBNBRedeem=${fees.xBNBRedeemFee} apUSDMint=${fees.apUSDMintFee} apUSDRedeem=${fees.apUSDRedeemFee} disabled=${fees.apUSDMintDisabled}`);
+    expect(fees.xBNBMintFee).toBe(expected.xBNBMintFee);
+    expect(fees.xBNBRedeemFee).toBe(expected.xBNBRedeemFee);
+    expect(fees.apUSDMintFee).toBe(expected.apUSDMintFee);
+    expect(fees.apUSDRedeemFee).toBe(expected.apUSDRedeemFee);
+    expect(fees.apUSDMintDisabled).toBe(expected.apUSDMintDisabled);
+  };
+
+  /**
+   * Parse Diamond event args (lstAmount, feeBPS, etc.) from a receipt.
+   */
+  const parseDiamondEvent = (receipt: any, eventName: string): any | null => {
+    for (const log of receipt.logs) {
+      try {
+        const decoded = decodeEventLog({
+          abi: DiamondABI,
+          data: log.data,
+          topics: log.topics,
+        });
+        if (decoded.eventName === eventName) {
+          return decoded.args;
+        }
+      } catch { /* not a Diamond event */ }
+    }
+    return null;
+  };
+
+  /**
+   * Parse ERC20 Transfer events that send tokens to the fee recipient address.
+   */
+  const parseFeeIncome = (receipt: any): Array<{ token: Address; amount: bigint }> => {
+    const recipientTopic = "0x" + FEE_RECIPIENT.slice(2).toLowerCase().padStart(64, "0");
+    const results: Array<{ token: Address; amount: bigint }> = [];
+    for (const log of receipt.logs) {
+      if (
+        log.topics?.length >= 3 &&
+        log.topics[0] === TRANSFER_TOPIC &&
+        log.topics[2]?.toLowerCase() === recipientTopic
+      ) {
+        results.push({ token: log.address as Address, amount: BigInt(log.data) });
+      }
+    }
+    return results;
+  };
+
+  const tokenName = (addr: Address): string =>
+    Object.entries(TOKENS).find(([, a]) => a.toLowerCase() === addr.toLowerCase())?.[0] || addr.slice(0, 10);
+
+  /**
+   * Verify fees from events + actual treasury income for a mint+redeem round-trip.
+   *  1. Event feeBPS matches expected zone fee
+   *  2. Treasury (FEE_RECIPIENT) actually received tokens
+   *  3. Treasury income amount cross-check:
+   *     - Mint fee: lstAmount * feeBPS / 10000 (fee in LST)
+   *     - apUSD redeem fee: lstAmount * feeBPS / (10000 - feeBPS) (fee in LST, deducted from output)
+   *     - xBNB redeem fee: xBNBAmount * feeBPS / 10000 (fee in xBNB, deducted from input)
+   */
+  const verifyEventFees = (
+    mintReceipt: any,
+    redeemReceipt: any,
+    isXBNB: boolean,
+    zone: keyof typeof ZONE_FEES,
+    label: string,
+  ) => {
+    const mintEvent = isXBNB ? "XBNBMinted" : "ApUSDMinted";
+    const redeemEvent = isXBNB ? "XBNBRedeemed" : "ApUSDRedeemed";
+    const expectedMint = isXBNB ? ZONE_FEES[zone].xBNBMintFee : ZONE_FEES[zone].apUSDMintFee;
+    const expectedRedeem = isXBNB ? ZONE_FEES[zone].xBNBRedeemFee : ZONE_FEES[zone].apUSDRedeemFee;
+
+    // 1) Verify event feeBPS
+    const mintArgs = parseDiamondEvent(mintReceipt, mintEvent);
+    const redeemArgs = parseDiamondEvent(redeemReceipt, redeemEvent);
+    const actualMintFee = mintArgs ? Number(mintArgs.feeBPS) : null;
+    const actualRedeemFee = redeemArgs ? Number(redeemArgs.feeBPS) : null;
+
+    console.log(`  ${label} event fees:`);
+    console.log(`    Mint:   ${actualMintFee} BPS (expected ${expectedMint})`);
+    console.log(`    Redeem: ${actualRedeemFee} BPS (expected ${expectedRedeem})`);
+    expect(actualMintFee).toBe(expectedMint);
+    expect(actualRedeemFee).toBe(expectedRedeem);
+
+    // 2) Verify actual treasury income from Transfer events
+    const mintIncome = parseFeeIncome(mintReceipt);
+    const redeemIncome = parseFeeIncome(redeemReceipt);
+
+    // Fee denomination depends on operation and is identified by fi.token:
+    //   Mint:         fee deducted from input LST → fi.token = LST address
+    //   apUSD redeem: fee deducted from input apUSD → fi.token = apUSD address
+    //   xBNB redeem:  fee deducted from input xBNB → fi.token = xBNB address
+    const computeExpected = (fi: { token: Address; amount: bigint }, args: any, feeBPS: number): { expected: bigint; unit: string } | null => {
+      const feeToken = fi.token.toLowerCase();
+      const fee = BigInt(feeBPS);
+      if (feeToken === TOKENS.apUSD.toLowerCase() && args?.apUSDAmount) {
+        return { expected: args.apUSDAmount * fee / 10000n, unit: "apUSD" };
+      }
+      if (feeToken === TOKENS.xBNB.toLowerCase() && args?.xBNBAmount) {
+        return { expected: args.xBNBAmount * fee / 10000n, unit: "xBNB" };
+      }
+      if (args?.lstAmount) {
+        return { expected: args.lstAmount * fee / 10000n, unit: "LST" };
+      }
+      return null;
+    };
+
+    const verifyIncome = (income: Array<{ token: Address; amount: bigint }>, args: any, feeBPS: number, label: string) => {
+      if (feeBPS === 0) {
+        expect(income.length).toBe(0);
+        console.log(`    ${label} treasury:  $0 (0% fee, correctly no transfer)`);
+        return;
+      }
+      expect(income.length).toBeGreaterThan(0);
+      for (const fi of income) {
+        const calc = computeExpected(fi, args, feeBPS);
+        if (!calc) continue;
+        console.log(`    ${label} treasury:  +${formatAmount(fi.amount)} ${tokenName(fi.token)} (expected ≈${formatAmount(calc.expected)} ${calc.unit})`);
+        const diff = fi.amount > calc.expected ? fi.amount - calc.expected : calc.expected - fi.amount;
+        const tolerance = calc.expected / 10n + 1n;
+        expect(diff).toBeLessThanOrEqual(tolerance);
+        console.log(`    ✓ ${label} treasury income matches (within 10%)`);
+      }
+    };
+
+    if (actualMintFee !== null) verifyIncome(mintIncome, mintArgs, actualMintFee, "Mint");
+    if (actualRedeemFee !== null) verifyIncome(redeemIncome, redeemArgs, actualRedeemFee, "Redeem");
+
+    console.log(`    ✓ Fees verified`);
+  };
+
+  const mintApUSDWithBNB = async (bnbAmount: bigint) => {
+    const hash = await routerWrite.stakeAndMint({
+      targetLST: TOKENS.slisBNB, isXBNB: false, minMintOut: 0n, deadline: dl(), value: bnbAmount,
+    });
+    return waitTx(hash);
+  };
+
+  const mintXBNBWithBNB = async (bnbAmount: bigint) => {
+    const hash = await routerWrite.stakeAndMint({
+      targetLST: TOKENS.slisBNB, isXBNB: true, minMintOut: 0n, deadline: dl(), value: bnbAmount,
+    });
+    return waitTx(hash);
+  };
+
+  const fundFromWhale = async (token: Address, whale: Address, amount: bigint) => {
+    if (!IS_FORK) throw new Error("fundFromWhale is only available in fork mode");
+    await testClient.impersonateAccount({ address: whale });
+    await testClient.setBalance({ address: whale, value: parseEther("1") });
+    const whaleWallet = createWalletClient({ account: whale, chain: bsc, transport: http(RPC_URL) });
+    const hash = await whaleWallet.writeContract({
+      address: token, abi: ERC20_ABI, functionName: "transfer", args: [account.address, amount],
+    });
+    await publicClient.waitForTransactionReceipt({ hash });
+    await testClient.stopImpersonatingAccount({ address: whale });
+  };
+
+  const ensureUSDT = async (needed: bigint) => {
+    if (IS_FORK) {
+      await fundFromWhale(TOKENS.USDT, USDT_WHALE, needed);
+    } else {
+      const bal = await getBalance(TOKENS.USDT);
+      if (bal < needed) throw new Error(`Insufficient USDT: have ${formatAmount(bal)}, need ${formatAmount(needed)}`);
+    }
+  };
+
+  const mintApUSDWithUSDT = async (usdtAmount: bigint) => {
+    await ensureUSDT(usdtAmount);
+    await approve(TOKENS.USDT, ROUTER, usdtAmount);
+    const hash = await routerWrite.swapAndMintDefault({
+      inputToken: TOKENS.USDT, inputAmount: usdtAmount, mintXBNB: false, minMintOut: 0n, deadline: dl(),
+    });
+    return waitTx(hash);
+  };
+
+  const mintXBNBWithUSDT = async (usdtAmount: bigint) => {
+    await ensureUSDT(usdtAmount);
+    await approve(TOKENS.USDT, ROUTER, usdtAmount);
+    const hash = await routerWrite.swapAndMintDefault({
+      inputToken: TOKENS.USDT, inputAmount: usdtAmount, mintXBNB: true, minMintOut: 0n, deadline: dl(),
+    });
+    return waitTx(hash);
+  };
+
+  const redeemToUSDT = async (amount: bigint, isXBNB: boolean) => {
+    const token = isXBNB ? TOKENS.xBNB : TOKENS.apUSD;
+    await approve(token, ROUTER, amount);
+    const path = encodeV3Path([TOKENS.slisBNB, TOKENS.WBNB, TOKENS.USDT], [500, 500]);
+    const hash = await routerWrite.redeemAndSwap({
+      lst: TOKENS.slisBNB, redeemXBNB: isXBNB, amount, path, minOut: 0n, deadline: dl(), unwrapBNB: false,
+    });
+    return waitTx(hash);
+  };
+
+  /**
+   * Lower CR by minting apUSD (adds equal TVL and supply, pushing CR toward 100%).
+   * Fork mode: uses BNB via stakeAndMint.
+   * Live mode: uses USDT via swapAndMintDefault (no BNB needed).
+   *
+   * Math: new_CR = (TVL + V) / (supply + V), solve for V: V = supply × (CR − target) / (target − 10000)
+   */
+  /**
+   * Lower CR by:
+   *   Live mode: 1) redeem xBNB → USDT (removes TVL, lowers CR, recovers USDT)
+   *              2) if xBNB exhausted, mint apUSD with USDT (adds supply)
+   *   Fork mode: mint apUSD with BNB (whale-funded)
+   */
+  const lowerCRTo = async (targetBPS: bigint) => {
+    // Max 3 attempts: calculate exact amount → send 1 tx → verify → small correction if needed
+    for (let i = 0; i < 3; i++) {
+      if (i > 0 && IS_LIVE) await sleep(3000);
+      const { cr, tvlBNB, tvlUSD, supply } = await readProtocolState();
+      console.log(`    lowerCR[${i}] read: CR=${formatCR(cr)}, target=${formatCR(targetBPS)}, TVL=$${formatAmount(tvlUSD)}, supply=${formatAmount(supply)}`);
+      if ((cr <= targetBPS && cr > 0n) || cr === 0n) return;
+
+      if (IS_LIVE && !(await ensureGas("lowerCR"))) {
+        throw new Error(`Out of gas at CR=${formatCR(cr)}, target=${formatCR(targetBPS)}`);
+      }
+
+      if (IS_LIVE) {
+        // Strategy 1: redeem xBNB (removes TVL, supply unchanged)
+        // Exact math: neededTVLRemoval = TVL - target * supply / 10000
+        const neededTVLRemoval = tvlUSD - targetBPS * supply / 10000n;
+        const xBNBBalance = await getBalance(TOKENS.xBNB);
+
+        if (xBNBBalance > parseAmount("0.0001") && neededTVLRemoval > 0n) {
+          const xBNBSupply = await diamondRead.getXBNBSupply();
+          let redeemAmount = xBNBSupply > 0n
+            ? neededTVLRemoval * xBNBSupply / tvlUSD
+            : xBNBBalance;
+          // +10% buffer for redeem fee + swap slippage; +20% on retries
+          redeemAmount = redeemAmount * (i === 0 ? 11n : 12n) / 10n;
+          if (redeemAmount > xBNBBalance) redeemAmount = xBNBBalance;
+          if (redeemAmount < parseAmount("0.0001")) redeemAmount = parseAmount("0.0001");
+
+          console.log(`    lowerCR[${i}]: redeem ${formatAmount(redeemAmount)} xBNB (CR ${formatCR(cr)} → ${formatCR(targetBPS)}, need $${formatAmount(neededTVLRemoval)} TVL removal)`);
+          try {
+            await redeemToUSDT(redeemAmount, true);
+            continue;
+          } catch (err: any) {
+            console.log(`    lowerCR: xBNB redeem failed, trying apUSD mint`);
+          }
+        }
+
+        // Strategy 2: mint apUSD (adds equal TVL+supply → pushes CR toward 100%)
+        // Exact math: X = (TVL*10000 - target*supply) / (target - 10000)
+        const usdtBal = await getBalance(TOKENS.USDT);
+        if (usdtBal < parseAmount("0.1")) throw new Error(`Insufficient USDT to lower CR: ${formatAmount(usdtBal)}`);
+        let chunk: bigint;
+        if (tvlUSD > 0n && supply > 0n && targetBPS > 10000n) {
+          chunk = (tvlUSD * 10000n - targetBPS * supply) / (targetBPS - 10000n);
+          chunk = chunk * (i === 0 ? 11n : 12n) / 10n;
+        } else {
+          chunk = parseAmount("0.5");
+        }
+        if (chunk < parseAmount("0.1")) chunk = parseAmount("0.1");
+        if (chunk > usdtBal) chunk = usdtBal;
+        if (chunk > parseAmount("10")) chunk = parseAmount("10");
+
+        console.log(`    lowerCR[${i}]: mint apUSD with ${formatAmount(chunk)} USDT (CR ${formatCR(cr)} → ${formatCR(targetBPS)})`);
+        try {
+          await mintApUSDWithUSDT(chunk);
+        } catch {
+          const cur = await getCR();
+          if (cur <= targetBPS && cur > 0n) return;
+          throw new Error(`Cannot lower CR further: stuck at ${formatCR(cur)}`);
+        }
+      } else {
+        let chunk: bigint;
+        if (tvlUSD > 0n && supply > 0n && targetBPS > 10000n) {
+          const neededUSD = supply * (cr - targetBPS) / (targetBPS - 10000n);
+          chunk = neededUSD * tvlBNB / tvlUSD * 11n / 10n;
+        } else {
+          chunk = parseEther("0.01");
+        }
+        if (chunk < parseEther("0.001")) chunk = parseEther("0.001");
+        if (chunk > parseEther("5")) chunk = parseEther("5");
+        try {
+          await mintApUSDWithBNB(chunk);
+        } catch {
+          const cur = await getCR();
+          if (cur <= targetBPS && cur > 0n) return;
+          throw new Error(`Cannot lower CR further: stuck at ${formatCR(cur)}`);
+        }
+      }
+    }
+    if (IS_LIVE) await sleep(3000);
+    const finalCR = await getCR();
+    if (finalCR <= targetBPS && finalCR > 0n) return;
+    throw new Error(`Failed to lower CR to ${formatCR(targetBPS)} (stuck at ${formatCR(finalCR)})`);
+  };
+
+  /**
+   * Raise CR by:
+   *   Live mode: 1) redeem apUSD → USDT (reduces supply, raises CR, recovers USDT)
+   *              2) if apUSD exhausted, mint xBNB with USDT (adds TVL)
+   *   Fork mode: mint xBNB with USDT (whale-funded)
+   *
+   * Redeem math: new_CR = (TVL − X) / (supply − X)
+   *   → X = supply × (target − CR) / (target − 10000)
+   */
+  const raiseCRTo = async (targetBPS: bigint) => {
+    // Max 3 attempts: calculate exact amount → send 1 tx → verify → small correction if needed
+    for (let i = 0; i < 3; i++) {
+      if (i > 0 && IS_LIVE) await sleep(3000);
+      const { cr, tvlUSD, supply } = await readProtocolState();
+      console.log(`    raiseCR[${i}] read: CR=${formatCR(cr)}, target=${formatCR(targetBPS)}, TVL=$${formatAmount(tvlUSD)}, supply=${formatAmount(supply)}`);
+      if (cr >= targetBPS) return;
+
+      if (IS_LIVE && !(await ensureGas("raiseCR"))) {
+        throw new Error(`Out of gas at CR=${formatCR(cr)}, target=${formatCR(targetBPS)}`);
+      }
+
+      if (IS_LIVE) {
+        // Strategy 1: redeem apUSD (reduces both TVL and supply equally → CR rises when CR > 100%)
+        // Exact math: X = (target*supply - TVL*10000) / (target - 10000)
+        const apUSDBalance = await getBalance(TOKENS.apUSD);
+        if (apUSDBalance > parseAmount("0.05") && targetBPS > 10000n) {
+          const neededRedeem = (targetBPS * supply - tvlUSD * 10000n) / (targetBPS - 10000n);
+          let redeemAmount = neededRedeem > 0n ? neededRedeem : parseAmount("0.1");
+          redeemAmount = redeemAmount * (i === 0 ? 11n : 12n) / 10n;
+          if (redeemAmount > apUSDBalance) redeemAmount = apUSDBalance;
+          if (redeemAmount < parseAmount("0.05")) redeemAmount = parseAmount("0.05");
+
+          console.log(`    raiseCR[${i}]: redeem ${formatAmount(redeemAmount)} apUSD (CR ${formatCR(cr)} → ${formatCR(targetBPS)})`);
+          try {
+            await redeemToUSDT(redeemAmount, false);
+            continue;
+          } catch (err: any) {
+            console.log(`    raiseCR: apUSD redeem failed, trying xBNB mint`);
+          }
+        }
+
+        // Strategy 2: mint xBNB (adds TVL, supply unchanged)
+        // Exact math: X = target * supply / 10000 - TVL
+        const usdtBal = await getBalance(TOKENS.USDT);
+        if (usdtBal < parseAmount("0.1")) throw new Error(`Insufficient USDT to raise CR: ${formatAmount(usdtBal)}`);
+        let chunk: bigint;
+        if (supply > 0n && targetBPS > 0n) {
+          const neededTVL = targetBPS * supply / 10000n - tvlUSD;
+          chunk = neededTVL > 0n ? neededTVL : parseAmount("0.1");
+          chunk = chunk * (i === 0 ? 11n : 12n) / 10n;
+        } else {
+          chunk = parseAmount("0.5");
+        }
+        if (chunk < parseAmount("0.1")) chunk = parseAmount("0.1");
+        if (chunk > usdtBal) chunk = usdtBal;
+        if (chunk > parseAmount("10")) chunk = parseAmount("10");
+
+        console.log(`    raiseCR[${i}]: mint xBNB with ${formatAmount(chunk)} USDT (CR ${formatCR(cr)} → ${formatCR(targetBPS)})`);
+        try {
+          await mintXBNBWithUSDT(chunk);
+        } catch {
+          const cur = await getCR();
+          if (cur >= targetBPS) return;
+          throw new Error(`Cannot raise CR further: stuck at ${formatCR(cur)}`);
+        }
+      } else {
+        let chunk: bigint;
+        if (tvlUSD > 0n && supply > 0n && targetBPS > 0n) {
+          const neededTVL = targetBPS * supply / 10000n - tvlUSD;
+          chunk = neededTVL > 0n ? neededTVL * 11n / 10n : parseAmount("0.5");
+        } else {
+          chunk = parseAmount("0.5");
+        }
+        if (chunk < parseAmount("0.5")) chunk = parseAmount("0.5");
+        if (chunk > parseAmount("100")) chunk = parseAmount("100");
+
+        try {
+          await mintXBNBWithUSDT(chunk);
+        } catch {
+          const cur = await getCR();
+          if (cur >= targetBPS) return;
+          throw new Error(`Cannot raise CR further: stuck at ${formatCR(cur)}`);
+        }
+      }
+    }
+    if (IS_LIVE) await sleep(3000);
+    const finalCR = await getCR();
+    if (finalCR >= targetBPS) return;
+    throw new Error(`Failed to raise CR to ${formatCR(targetBPS)} (stuck at ${formatCR(finalCR)})`);
+  };
+
+  // ============ Setup ============
+
+  beforeAll(async () => {
+    account = privateKeyToAccount(PRIVATE_KEY_HEX);
+    publicClient = createPublicClient({ chain: bsc, transport: http(RPC_URL) });
+    walletClient = createWalletClient({ account, chain: bsc, transport: http(RPC_URL) });
+
+    if (IS_FORK) {
+      testClient = createTestClient({ chain: bsc, transport: http(RPC_URL), mode: "anvil" });
+      await testClient.setBalance({ address: account.address, value: parseEther("500000") });
+    }
+
+    diamondRead = new AspanReadClient({ diamondAddress: DIAMOND, chain: bsc, rpcUrl: RPC_URL });
+    diamondWrite = new AspanClient({ diamondAddress: DIAMOND, account, chain: bsc, rpcUrl: RPC_URL });
+    routerRead = new AspanRouterReadClient({ routerAddress: ROUTER, chain: bsc, rpcUrl: RPC_URL });
+    routerWrite = new AspanRouterClient({ routerAddress: ROUTER, account, chain: bsc, rpcUrl: RPC_URL });
+
+    // Read actual fee tiers from contract (source of truth)
+    const tierCount = await diamondRead.getFeeTierCount();
+    const tiers: FeeTier[] = [];
+    for (let i = 0n; i < tierCount; i++) {
+      tiers.push(await diamondRead.getFeeTier(i));
+    }
+    tiers.sort((a, b) => (a.minCR > b.minCR ? -1 : a.minCR < b.minCR ? 1 : 0));
+
+    const labels = ["A", "B", "C", "D", "E", "F"];
+    tiers.forEach((tier, idx) => {
+      const label = labels[idx] || `Z${idx}`;
+      ZONE_FEES[label] = {
+        xBNBMintFee: tier.xBNBMintFee,
+        xBNBRedeemFee: tier.xBNBRedeemFee,
+        apUSDMintFee: tier.apUSDMintFee,
+        apUSDRedeemFee: tier.apUSDRedeemFee,
+        apUSDMintDisabled: tier.apUSDMintDisabled,
+      };
+      if (tier.minCR > 0n) {
+        ZONE_CR[`${label}_MIN`] = tier.minCR;
+      }
+    });
+
+    ZONE_LAST_LABEL = labels[tiers.length - 1] || "D";
+
+    console.log(`📍 Wallet: ${account.address}`);
+    console.log(`📊 Fee tiers (${tierCount} from contract):`);
+    tiers.forEach((t, i) => {
+      console.log(`  ${labels[i]}: minCR=${formatCR(t.minCR)} xBNBMint=${t.xBNBMintFee} xBNBRedeem=${t.xBNBRedeemFee} apUSDMint=${t.apUSDMintFee} apUSDRedeem=${t.apUSDRedeemFee} disabled=${t.apUSDMintDisabled}`);
+    });
+    await verifyCR("Initial");
+  });
+
+  // ================================================================
+  //  FC-01: Fee Tier Configuration (consistency check)
+  // ================================================================
+
+  describe("FC-01: Fee Tier Configuration", () => {
+    it("FC-01: getCurrentFees matches fee tier for current CR", async () => {
+      const fees = await getFees();
+      const zone = getZone(fees.currentCR);
+      const expected = ZONE_FEES[zone];
+      console.log(`  Current zone: ${zone}, CR: ${formatCR(fees.currentCR)}`);
+      console.log(`  Fees: xBNBMint=${fees.xBNBMintFee} xBNBRedeem=${fees.xBNBRedeemFee} apUSDMint=${fees.apUSDMintFee} apUSDRedeem=${fees.apUSDRedeemFee} disabled=${fees.apUSDMintDisabled}`);
+
+      expect(fees.xBNBMintFee).toBe(expected.xBNBMintFee);
+      expect(fees.xBNBRedeemFee).toBe(expected.xBNBRedeemFee);
+      expect(fees.apUSDMintFee).toBe(expected.apUSDMintFee);
+      expect(fees.apUSDRedeemFee).toBe(expected.apUSDRedeemFee);
+      expect(fees.apUSDMintDisabled).toBe(expected.apUSDMintDisabled);
+    });
+
+    it("CR independent verification: TVL / apUSD_Supply matches contract CR", async () => {
+      const { contractCR, calculatedCR, tvlInUSD, apUSDSupply } = await verifyCR("CR Check");
+
+      if (apUSDSupply === 0n) {
+        console.log(`  ⚠️ No apUSD supply yet, CR check N/A`);
+        return;
+      }
+
+      const diff = contractCR > calculatedCR
+        ? contractCR - calculatedCR
+        : calculatedCR - contractCR;
+      console.log(`  Contract CR: ${formatCR(contractCR)}, Calculated CR: ${formatCR(calculatedCR)}, Diff: ${diff} BPS`);
+      expect(diff).toBeLessThanOrEqual(1n);
+      console.log(`  ✓ Contract CR matches independent calculation (TVL * 10000 / apUSD_Supply)`);
+    });
+  });
+
+  // ================================================================
+  //  Zone A: FC-01-01, P-01-01, P-02-01, P-03-01
+  // ================================================================
+
+  describe.skipIf(!IS_FORK)("Zone A (CR > 170%) [Fork]", () => {
+    let snap: `0x${string}`;
+    beforeAll(async () => { snap = await testClient.snapshot(); });
+    afterAll(async () => { await testClient.revert({ id: snap }); });
+
+    it("FC-01-01: Zone A fee + CR verification", async () => {
+      const cr = await getCR();
+      if (cr < ZONE_CR.A_MIN) {
+        console.log(`  CR=${formatCR(cr)}, raising to Zone A...`);
+        try {
+          await raiseCRTo(ZONE_CR.A_MIN + 500n);
+        } catch (err: any) {
+          console.log(`  ⚠️ Could not raise CR to Zone A: ${err.message?.slice(0, 80)}`);
+          console.log(`  Verifying fees for current zone instead`);
+        }
+      }
+      const { zone } = await verifyCR("Zone A CR");
+      const fees = await getFees();
+      const actualZone = getZone(fees.currentCR);
+      verifyFees(fees, actualZone, `Zone ${actualZone}`);
+      if (actualZone !== "A") {
+        console.log(`  ⚠️ Target was Zone A but CR is in Zone ${actualZone}`);
+      }
+    }, 600000);
+
+    it("P-01-01: USDT → apUSD → USDT (Zone A, Mint=0%, Redeem=1%)", async () => {
+      console.log(`\n[P-01-01] USDT → apUSD → USDT`);
+      const AMOUNT = parseAmount("1");
+
+      await fundFromWhale(TOKENS.USDT, USDT_WHALE, AMOUNT);
+      await approve(TOKENS.USDT, ROUTER, AMOUNT);
+
+      const apUSDBefore = await getBalance(TOKENS.apUSD);
+      let mintReceipt: any;
+      try {
+        mintReceipt = await waitTx(await routerWrite.swapAndMintDefault({
+          inputToken: TOKENS.USDT, inputAmount: AMOUNT, mintXBNB: false, minMintOut: 0n, deadline: dl(),
+        }));
+      } catch (err: any) {
+        console.log(`  ⚠️ apUSD minting failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+        return;
+      }
+      const apUSDMinted = (await getBalance(TOKENS.apUSD)) - apUSDBefore;
+      console.log(`  Minted: ${formatAmount(apUSDMinted)} apUSD`);
+      expect(apUSDMinted).toBeGreaterThan(0n);
+
+      await approve(TOKENS.apUSD, ROUTER, apUSDMinted);
+      const usdtBefore = await getBalance(TOKENS.USDT);
+      const path = encodeV3Path([TOKENS.slisBNB, TOKENS.WBNB, TOKENS.USDT], [500, 500]);
+      let redeemReceipt: any;
+      try {
+        redeemReceipt = await waitTx(await routerWrite.redeemAndSwap({
+          lst: TOKENS.slisBNB, redeemXBNB: false, amount: apUSDMinted, path, minOut: 0n, deadline: dl(), unwrapBNB: false,
+        }));
+      } catch (err: any) {
+        console.log(`  ⚠️ Redeem swap failed (PancakeSwap liquidity shifted after CR manipulation): ${err.shortMessage || err.message?.slice(0, 80)}`);
+        return;
+      }
+      const usdtReceived = (await getBalance(TOKENS.USDT)) - usdtBefore;
+      console.log(`  Received: ${formatAmount(usdtReceived)} USDT`);
+      expect(usdtReceived).toBeGreaterThan(0n);
+
+      const fees = await getFees();
+      const zone = getZone(fees.currentCR);
+      verifyEventFees(mintReceipt, redeemReceipt, false, zone, `apUSD Zone ${zone}`);
+    }, 180000);
+
+    it("P-02-01: USDT → xBNB → USDT (Zone A)", async () => {
+      console.log(`\n[P-02-01] USDT → xBNB → USDT`);
+      const AMOUNT = parseAmount("1");
+
+      const xBNBBefore = await getBalance(TOKENS.xBNB);
+      let mintReceipt: any;
+      try {
+        mintReceipt = await mintXBNBWithUSDT(AMOUNT);
+      } catch (err: any) {
+        console.log(`  ⚠️ xBNB minting failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+        return;
+      }
+      const xBNBMinted = (await getBalance(TOKENS.xBNB)) - xBNBBefore;
+      console.log(`  Minted: ${formatAmount(xBNBMinted, 8)} xBNB`);
+      expect(xBNBMinted).toBeGreaterThan(0n);
+
+      const usdtBefore = await getBalance(TOKENS.USDT);
+      let redeemReceipt: any;
+      try {
+        redeemReceipt = await redeemToUSDT(xBNBMinted, true);
+      } catch (err: any) {
+        console.log(`  ⚠️ xBNB redeem swap failed (PancakeSwap liquidity): ${err.shortMessage || err.message?.slice(0, 80)}`);
+        return;
+      }
+      const usdtReceived = (await getBalance(TOKENS.USDT)) - usdtBefore;
+      console.log(`  Received: ${formatAmount(usdtReceived)} USDT`);
+      expect(usdtReceived).toBeGreaterThan(0n);
+
+      const fees = await getFees();
+      const zone = getZone(fees.currentCR);
+      verifyEventFees(mintReceipt, redeemReceipt, true, zone, `xBNB Zone ${zone}`);
+    }, 180000);
+
+    it("P-03-01: USDT → xBNB → USDT Zap round-trip (Zone A)", async () => {
+      console.log(`\n[P-03-01] USDT → xBNB → USDT Zap`);
+      const AMOUNT = parseAmount("1");
+
+      const xBNBBefore = await getBalance(TOKENS.xBNB);
+      let mintReceipt: any;
+      try {
+        mintReceipt = await mintXBNBWithUSDT(AMOUNT);
+      } catch (err: any) {
+        console.log(`  ⚠️ xBNB minting failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+        return;
+      }
+      const xBNBMinted = (await getBalance(TOKENS.xBNB)) - xBNBBefore;
+      console.log(`  Minted: ${formatAmount(xBNBMinted, 8)} xBNB, Gas: ${mintReceipt.gasUsed}`);
+      expect(xBNBMinted).toBeGreaterThan(0n);
+
+      const usdtBefore = await getBalance(TOKENS.USDT);
+      let redeemReceipt: any;
+      try {
+        redeemReceipt = await redeemToUSDT(xBNBMinted, true);
+      } catch (err: any) {
+        console.log(`  ⚠️ xBNB redeem swap failed (PancakeSwap liquidity): ${err.shortMessage || err.message?.slice(0, 80)}`);
+        return;
+      }
+      const usdtReceived = (await getBalance(TOKENS.USDT)) - usdtBefore;
+      console.log(`  Received: ${formatAmount(usdtReceived)} USDT`);
+      expect(usdtReceived).toBeGreaterThan(0n);
+
+      const fees = await getFees();
+      const zone = getZone(fees.currentCR);
+      verifyEventFees(mintReceipt, redeemReceipt, true, zone, `xBNB Zap Zone ${zone}`);
+    }, 180000);
+  });
+
+  // ================================================================
+  //  Zone B: FC-01-02, P-01-02, P-02-02, P-03-02
+  // ================================================================
+
+  describe.skipIf(!IS_FORK)("Zone B (150-170%) [Fork]", () => {
+    let snap: `0x${string}`;
+    beforeAll(async () => {
+      snap = await testClient.snapshot();
+      console.log(`  Lowering CR to Zone B...`);
+      await lowerCRTo(ZONE_CR.B_MIN + 500n);
+    }, 600000);
+    afterAll(async () => { await testClient.revert({ id: snap }); });
+
+    it("FC-01-02: Zone B fee + CR verification", async () => {
+      await verifyCR("Zone B CR");
+      const fees = await getFees();
+      const actualZone = getZone(fees.currentCR);
+      verifyFees(fees, actualZone, `Zone ${actualZone}`);
+      if (actualZone !== "B") {
+        console.log(`  ⚠️ Target was Zone B but CR is in Zone ${actualZone} (CR=${formatCR(fees.currentCR)})`);
+      }
+    });
+
+    it("P-01-02: USDC → apUSD → USDT (Zone B)", async () => {
+      console.log(`\n[P-01-02] USDC → apUSD → USDT`);
+      const fees = await getFees();
+      if (fees.apUSDMintDisabled) {
+        console.log(`  ⚠️ apUSD minting disabled in Zone B, skipping`);
+        return;
+      }
+      const AMOUNT = parseAmount("1");
+
+      try {
+        await fundFromWhale(TOKENS.USDC, USDC_WHALE, AMOUNT);
+      } catch {
+        console.log(`  ⚠️ USDC whale has insufficient balance, skipping`);
+        return;
+      }
+      await approve(TOKENS.USDC, ROUTER, AMOUNT);
+
+      const apUSDBefore = await getBalance(TOKENS.apUSD);
+      const mintReceipt = await waitTx(await routerWrite.swapAndMintDefault({
+        inputToken: TOKENS.USDC, inputAmount: AMOUNT, mintXBNB: false, minMintOut: 0n, deadline: dl(),
+      }));
+      const apUSDMinted = (await getBalance(TOKENS.apUSD)) - apUSDBefore;
+      console.log(`  Minted: ${formatAmount(apUSDMinted)} apUSD`);
+      expect(apUSDMinted).toBeGreaterThan(0n);
+
+      await approve(TOKENS.apUSD, ROUTER, apUSDMinted);
+      const usdtBefore = await getBalance(TOKENS.USDT);
+      const path = encodeV3Path([TOKENS.slisBNB, TOKENS.WBNB, TOKENS.USDT], [500, 500]);
+      const redeemReceipt = await waitTx(await routerWrite.redeemAndSwap({
+        lst: TOKENS.slisBNB, redeemXBNB: false, amount: apUSDMinted, path, minOut: 0n, deadline: dl(), unwrapBNB: false,
+      }));
+      const usdtReceived = (await getBalance(TOKENS.USDT)) - usdtBefore;
+      console.log(`  Received: ${formatAmount(usdtReceived)} USDT`);
+      expect(usdtReceived).toBeGreaterThan(0n);
+
+      const curFees = await getFees();
+      const curZone = getZone(curFees.currentCR);
+      verifyEventFees(mintReceipt, redeemReceipt, false, curZone, `apUSD Zone ${curZone}`);
+    }, 180000);
+
+    it("P-02-02: USDT → xBNB → USDT (Zone B)", async () => {
+      console.log(`\n[P-02-02] USDT → xBNB → USDT`);
+      const AMOUNT = parseAmount("1");
+
+      const xBNBBefore = await getBalance(TOKENS.xBNB);
+      let mintReceipt: any;
+      try {
+        mintReceipt = await mintXBNBWithUSDT(AMOUNT);
+      } catch (err: any) {
+        console.log(`  ⚠️ xBNB minting failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+        return;
+      }
+      const xBNBMinted = (await getBalance(TOKENS.xBNB)) - xBNBBefore;
+      console.log(`  Minted: ${formatAmount(xBNBMinted, 8)} xBNB`);
+      expect(xBNBMinted).toBeGreaterThan(0n);
+
+      const usdtBefore = await getBalance(TOKENS.USDT);
+      let redeemReceipt: any;
+      try {
+        redeemReceipt = await redeemToUSDT(xBNBMinted, true);
+      } catch (err: any) {
+        console.log(`  ⚠️ xBNB redeem swap failed (PancakeSwap liquidity): ${err.shortMessage || err.message?.slice(0, 80)}`);
+        return;
+      }
+      const usdtReceived = (await getBalance(TOKENS.USDT)) - usdtBefore;
+      console.log(`  Received: ${formatAmount(usdtReceived)} USDT`);
+      expect(usdtReceived).toBeGreaterThan(0n);
+
+      const fees = await getFees();
+      const zone = getZone(fees.currentCR);
+      verifyEventFees(mintReceipt, redeemReceipt, true, zone, `xBNB Zone ${zone}`);
+    }, 180000);
+
+    it("P-03-02: USDT → apUSD → USDT (Zone B)", async () => {
+      console.log(`\n[P-03-02] USDT → apUSD → USDT`);
+      const fees = await getFees();
+      if (fees.apUSDMintDisabled) {
+        console.log(`  ⚠️ apUSD minting disabled, skipping`);
+        return;
+      }
+      const AMOUNT = parseAmount("1");
+
+      const apUSDBefore = await getBalance(TOKENS.apUSD);
+      let mintReceipt: any;
+      try {
+        mintReceipt = await mintApUSDWithUSDT(AMOUNT);
+      } catch (err: any) {
+        console.log(`  ⚠️ apUSD minting failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+        return;
+      }
+      const apUSDMinted = (await getBalance(TOKENS.apUSD)) - apUSDBefore;
+      console.log(`  Minted: ${formatAmount(apUSDMinted)} apUSD`);
+      expect(apUSDMinted).toBeGreaterThan(0n);
+
+      const usdtBefore = await getBalance(TOKENS.USDT);
+      let redeemReceipt: any;
+      try {
+        redeemReceipt = await redeemToUSDT(apUSDMinted, false);
+      } catch (err: any) {
+        console.log(`  ⚠️ Redeem swap failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+        return;
+      }
+      const usdtReceived = (await getBalance(TOKENS.USDT)) - usdtBefore;
+      console.log(`  Received: ${formatAmount(usdtReceived)} USDT`);
+      expect(usdtReceived).toBeGreaterThan(0n);
+
+      const zone = getZone(fees.currentCR);
+      verifyEventFees(mintReceipt, redeemReceipt, false, zone, `apUSD Zone ${zone}`);
+    }, 180000);
+  });
+
+  // ================================================================
+  //  Zone C: FC-01-03, P-01-03, P-02-03
+  // ================================================================
+
+  describe.skipIf(!IS_FORK)("Zone C (130-150%) [Fork]", () => {
+    let snap: `0x${string}`;
+    beforeAll(async () => {
+      snap = await testClient.snapshot();
+      console.log(`  Lowering CR to Zone C...`);
+      await lowerCRTo(ZONE_CR.C_MIN + 500n);
+    }, 600000);
+    afterAll(async () => { await testClient.revert({ id: snap }); });
+
+    it("FC-01-03: Zone C fee + CR verification (high xBNB redeem penalty)", async () => {
+      await verifyCR("Zone C CR");
+      const fees = await getFees();
+      const actualZone = getZone(fees.currentCR);
+      verifyFees(fees, actualZone, `Zone ${actualZone}`);
+      if (actualZone !== "C") {
+        console.log(`  ⚠️ Target was Zone C but CR is in Zone ${actualZone} (CR=${formatCR(fees.currentCR)})`);
+      }
+    });
+
+    it("P-01-03: USDT → apUSD → USDC (Zone C)", async () => {
+      console.log(`\n[P-01-03] USDT → apUSD → USDC`);
+      const currentFees = await getFees();
+      if (currentFees.apUSDMintDisabled) {
+        console.log(`  ⚠️ apUSD minting disabled in Zone C, skipping`);
+        return;
+      }
+      const AMOUNT = parseAmount("1");
+
+      await fundFromWhale(TOKENS.USDT, USDT_WHALE, AMOUNT);
+      await approve(TOKENS.USDT, ROUTER, AMOUNT);
+
+      const apUSDBefore = await getBalance(TOKENS.apUSD);
+      const mintReceipt = await waitTx(await routerWrite.swapAndMintDefault({
+        inputToken: TOKENS.USDT, inputAmount: AMOUNT, mintXBNB: false, minMintOut: 0n, deadline: dl(),
+      }));
+      const apUSDMinted = (await getBalance(TOKENS.apUSD)) - apUSDBefore;
+      console.log(`  Minted: ${formatAmount(apUSDMinted)} apUSD`);
+      expect(apUSDMinted).toBeGreaterThan(0n);
+
+      await approve(TOKENS.apUSD, ROUTER, apUSDMinted);
+      const usdcBefore = await getBalance(TOKENS.USDC);
+      const path = encodeV3Path([TOKENS.slisBNB, TOKENS.WBNB, TOKENS.USDC], [500, 500]);
+      const redeemReceipt = await waitTx(await routerWrite.redeemAndSwap({
+        lst: TOKENS.slisBNB, redeemXBNB: false, amount: apUSDMinted, path, minOut: 0n, deadline: dl(), unwrapBNB: false,
+      }));
+      const usdcReceived = (await getBalance(TOKENS.USDC)) - usdcBefore;
+      console.log(`  Received: ${formatAmount(usdcReceived)} USDC`);
+      expect(usdcReceived).toBeGreaterThan(0n);
+
+      const postFees = await getFees();
+      const zone = getZone(postFees.currentCR);
+      verifyEventFees(mintReceipt, redeemReceipt, false, zone, `apUSD Zone ${zone}`);
+    }, 180000);
+
+    it("P-02-03: USDT → xBNB → USDT (Zone C)", async () => {
+      console.log(`\n[P-02-03] USDT → xBNB → USDT`);
+      const AMOUNT = parseAmount("1");
+
+      let mintReceipt: any;
+      const xBNBBefore = await getBalance(TOKENS.xBNB);
+      try {
+        mintReceipt = await mintXBNBWithUSDT(AMOUNT);
+      } catch (err: any) {
+        console.log(`  ⚠️ xBNB minting failed in Zone C (swap/liquidity issue), skipping: ${err.shortMessage || err.message?.slice(0, 80)}`);
+        return;
+      }
+      const xBNBMinted = (await getBalance(TOKENS.xBNB)) - xBNBBefore;
+      console.log(`  Minted: ${formatAmount(xBNBMinted, 8)} xBNB`);
+      expect(xBNBMinted).toBeGreaterThan(0n);
+
+      const usdtBefore = await getBalance(TOKENS.USDT);
+      let redeemReceipt: any;
+      try {
+        redeemReceipt = await redeemToUSDT(xBNBMinted, true);
+      } catch (err: any) {
+        console.log(`  ⚠️ xBNB redeem swap failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+        return;
+      }
+      const usdtReceived = (await getBalance(TOKENS.USDT)) - usdtBefore;
+      console.log(`  Received: ${formatAmount(usdtReceived)} USDT`);
+      expect(usdtReceived).toBeGreaterThan(0n);
+
+      const fees = await getFees();
+      const zone = getZone(fees.currentCR);
+      verifyEventFees(mintReceipt, redeemReceipt, true, zone, `xBNB Zone ${zone}`);
+    }, 180000);
+  });
+
+  // ================================================================
+  //  Zone D: FC-01-04~06, P-01-04, P-02-04
+  // ================================================================
+
+  describe.skipIf(!IS_FORK)("Zone D (CR < 130%) [Fork]", () => {
+    let snap: `0x${string}`;
+    beforeAll(async () => {
+      snap = await testClient.snapshot();
+      console.log(`  Lowering CR to Zone D...`);
+      await lowerCRTo(ZONE_CR.C_MIN - 100n);
+    }, 600000);
+    afterAll(async () => { await testClient.revert({ id: snap }); });
+
+    it("FC-01-04: Zone D fee + CR verification (emergency lockdown)", async () => {
+      await verifyCR("Zone D CR");
+      const fees = await getFees();
+      const actualZone = getZone(fees.currentCR);
+      verifyFees(fees, actualZone, `Zone ${actualZone}`);
+      if (actualZone !== "D") {
+        console.log(`  ⚠️ Target was Zone D but CR is in Zone ${actualZone}`);
+      }
+    });
+
+    it("FC-01-05: Zone D apUSD minting is suspended", async () => {
+      console.log(`\n[FC-01-05] apUSD mint in Zone D`);
+      const fees = await getFees();
+      expect(fees.apUSDMintDisabled).toBe(true);
+
+      await expect(mintApUSDWithUSDT(parseAmount("1"))).rejects.toThrow();
+      console.log(`  ✓ apUSD minting correctly blocked`);
+    }, 60000);
+
+    it("FC-01-06: Zone D xBNB redeem fee (USDT round-trip)", async () => {
+      console.log(`\n[FC-01-06] USDT → xBNB → USDT in Zone D`);
+      const AMOUNT = parseAmount("1");
+
+      let mintReceipt: any;
+      const xBNBBefore = await getBalance(TOKENS.xBNB);
+      try {
+        mintReceipt = await mintXBNBWithUSDT(AMOUNT);
+      } catch (err: any) {
+        console.log(`  ⚠️ xBNB minting failed in Zone D (swap/liquidity issue), skipping: ${err.shortMessage || err.message?.slice(0, 80)}`);
+        return;
+      }
+      const xBNBMinted = (await getBalance(TOKENS.xBNB)) - xBNBBefore;
+      console.log(`  Minted: ${formatAmount(xBNBMinted, 8)} xBNB`);
+      expect(xBNBMinted).toBeGreaterThan(0n);
+
+      const usdtBefore = await getBalance(TOKENS.USDT);
+      let redeemReceipt: any;
+      try {
+        redeemReceipt = await redeemToUSDT(xBNBMinted, true);
+      } catch (err: any) {
+        console.log(`  ⚠️ xBNB redeem swap failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+        return;
+      }
+      const usdtReceived = (await getBalance(TOKENS.USDT)) - usdtBefore;
+      console.log(`  Received: ${formatAmount(usdtReceived)} USDT`);
+      expect(usdtReceived).toBeGreaterThan(0n);
+
+      const fees = await getFees();
+      const zone = getZone(fees.currentCR);
+      verifyEventFees(mintReceipt, redeemReceipt, true, zone, `xBNB Zone ${zone}`);
+    }, 180000);
+
+    it("P-01-04: apUSD minting blocked in Zone D, existing holders can redeem at 0%", async () => {
+      console.log(`\n[P-01-04] Zone D: mint blocked, redeem 0%`);
+      const fees = await getFees();
+      expect(fees.apUSDMintDisabled).toBe(true);
+      console.log(`  apUSD redeem fee: ${fees.apUSDRedeemFee} BPS`);
+
+      const apUSDBalance = await getBalance(TOKENS.apUSD);
+      if (apUSDBalance > 0n) {
+        const redeemAmount = apUSDBalance > parseAmount("1") ? parseAmount("1") : apUSDBalance;
+        console.log(`  Existing apUSD holder: ${formatAmount(apUSDBalance)} apUSD, redeeming ${formatAmount(redeemAmount)}`);
+        try {
+          const usdtBefore = await getBalance(TOKENS.USDT);
+          await redeemToUSDT(redeemAmount, false);
+          const usdtReceived = (await getBalance(TOKENS.USDT)) - usdtBefore;
+          console.log(`  Received: ${formatAmount(usdtReceived)} USDT ✓`);
+          expect(usdtReceived).toBeGreaterThan(0n);
+        } catch (err: any) {
+          console.log(`  ⚠️ Redeem swap failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+        }
+      } else {
+        console.log(`  No apUSD balance to test redeem (normal in Zone D fork)`);
+      }
+    }, 180000);
+
+    it("P-02-04: xBNB extreme fees in Zone D", async () => {
+      console.log(`\n[P-02-04] Zone D extreme fees`);
+      const fees = await getFees();
+      const zone = getZone(fees.currentCR);
+      const expected = ZONE_FEES[zone];
+      console.log(`  Zone ${zone}: xBNBMint=${fees.xBNBMintFee}BPS xBNBRedeem=${fees.xBNBRedeemFee}BPS`);
+      expect(fees.xBNBMintFee).toBe(expected.xBNBMintFee);
+      expect(fees.xBNBRedeemFee).toBe(expected.xBNBRedeemFee);
+      console.log(`  ✓ xBNB fees match zone ${zone} configuration`);
+    });
+  });
+
+  // ================================================================
+  //  FC-01-07: CR Recovery (Zone D → Zone A)
+  // ================================================================
+
+  describe.skipIf(!IS_FORK)("FC-01-07: CR Recovery [Fork]", () => {
+    let snap: `0x${string}`;
+    beforeAll(async () => { snap = await testClient.snapshot(); });
+    afterAll(async () => { await testClient.revert({ id: snap }); });
+
+    it("FC-01-07: Fees restore to Zone A after CR recovery", async () => {
+      console.log(`\n[FC-01-07] Zone D → Zone A recovery`);
+
+      // First lower to Zone D
+      console.log(`  Step 1: Lower CR to Zone D...`);
+      await lowerCRTo(ZONE_CR.C_MIN - 100n);
+      let fees = await getFees();
+      let zone = getZone(fees.currentCR);
+      verifyFees(fees, zone, `${zone} (before recovery)`);
+
+      // Then raise back to Zone A by minting xBNB
+      console.log(`  Step 2: Raise CR to Zone A...`);
+      try {
+        await raiseCRTo(ZONE_CR.A_MIN + 500n);
+      } catch (err: any) {
+        console.log(`  ⚠️ Could not raise to Zone A: ${err.message?.slice(0, 80)}`);
+        console.log(`  Verifying fees auto-switch at whatever CR we reached`);
+      }
+      fees = await getFees();
+      zone = getZone(fees.currentCR);
+      verifyFees(fees, zone, `${zone} (after recovery)`);
+
+      const crAfter = fees.currentCR;
+      console.log(`  Final CR: ${formatCR(crAfter)}, Zone: ${zone}`);
+      if (zone === "A") {
+        console.log(`  ✓ Fee auto-recovery to Zone A confirmed`);
+      } else {
+        console.log(`  ⚠️ Only recovered to Zone ${zone}`);
+      }
+    }, 1200000);
+  });
+
+  // ================================================================
+  //  FC-02 + P-04: Stability Pool Intervention
+  // ================================================================
+
+  describe.skipIf(!IS_FORK)("FC-02 + P-04: Stability Pool Intervention [Fork]", () => {
+    let snap: `0x${string}`;
+    beforeAll(async () => { snap = await testClient.snapshot(); });
+    afterAll(async () => { await testClient.revert({ id: snap }); });
+
+    let depositedApUSD = 0n;
+
+    it("Setup: Mint apUSD and deposit to stability pool", async () => {
+      console.log(`\n[FC-02 Setup] Mint and deposit to stability pool`);
+
+      const fees = await getFees();
+      const cr = fees.currentCR;
+      if (fees.apUSDMintDisabled || cr < ZONE_CR.B_MIN) {
+        console.log(`  CR=${formatCR(cr)} too low for apUSD minting, raising to Zone B...`);
+        await raiseCRTo(ZONE_CR.B_MIN + 500n);
+      }
+
+      await mintApUSDWithUSDT(parseAmount("1"));
+      depositedApUSD = await getBalance(TOKENS.apUSD);
+      console.log(`  Minted: ${formatAmount(depositedApUSD)} apUSD`);
+      expect(depositedApUSD).toBeGreaterThan(0n);
+
+      await approve(TOKENS.apUSD, DIAMOND, depositedApUSD);
+      try {
+        await waitTx(await diamondWrite.deposit({ apUSDAmount: depositedApUSD }));
+      } catch (err: any) {
+        console.log(`  ⚠️ Deposit failed (AccessControl or not configured): ${err.shortMessage || err.message?.slice(0, 100)}`);
+        console.log(`  Skipping remaining FC-02 tests`);
+        return;
+      }
+
+      const shares = await diamondRead.getShares(account.address);
+      const stats = await diamondRead.getStabilityPoolStats();
+      console.log(`  Shares: ${formatAmount(shares)}`);
+      console.log(`  Pool total: ${formatAmount(stats.totalStaked)}, Rate: ${formatAmount(stats.exchangeRate)}`);
+      expect(shares).toBeGreaterThan(0n);
+    }, 120000);
+
+    it("FC-02-01: SM2 not triggerable above 130%", async () => {
+      const sm2 = await diamondRead.canTriggerStabilityMode2();
+      const cr = await getCR();
+      console.log(`  CR: ${formatCR(cr)}, canTrigger: ${sm2.canTrigger}`);
+      if (cr >= ZONE_CR.C_MIN) {
+        expect(sm2.canTrigger).toBe(false);
+        console.log(`  ✓ SM2 correctly not triggerable`);
+      }
+    });
+
+    it("FC-02-01b: SM2 becomes triggerable below 130%", async () => {
+      const shares = await diamondRead.getShares(account.address);
+      if (shares === 0n) {
+        console.log(`  ⚠️ No shares deposited (setup failed), skipping SM2 tests`);
+        return;
+      }
+      console.log(`  Lowering CR below 130%...`);
+      await lowerCRTo(12500n);
+      const sm2 = await diamondRead.canTriggerStabilityMode2();
+      console.log(`  CR: ${formatCR(sm2.currentCR)}, canTrigger: ${sm2.canTrigger}, conversion: ${formatAmount(sm2.potentialConversion)} apUSD`);
+      expect(sm2.canTrigger).toBe(true);
+      expect(sm2.potentialConversion).toBeGreaterThan(0n);
+    }, 600000);
+
+    it("FC-02-02 + FC-02-03: SM2 execution with 40% burn cap", async () => {
+      console.log(`\n[FC-02-02/03] SM2 execution`);
+      const shares = await diamondRead.getShares(account.address);
+      if (shares === 0n) {
+        console.log(`  ⚠️ No shares deposited, skipping`);
+        return;
+      }
+
+      const poolBefore = await diamondRead.getTotalStaked();
+      console.log(`  Pool before: ${formatAmount(poolBefore)} apUSD`);
+
+      try {
+        await waitTx(await diamondWrite.triggerStabilityMode2());
+      } catch (err: any) {
+        console.log(`  ⚠️ SM2 trigger failed: ${err.shortMessage || err.message?.slice(0, 100)}`);
+        return;
+      }
+
+      const poolAfter = await diamondRead.getTotalStaked();
+      const burned = poolBefore - poolAfter;
+      console.log(`  Pool after: ${formatAmount(poolAfter)}, Burned: ${formatAmount(burned)}`);
+
+      if (poolBefore > 0n) {
+        const burnPct = Number(burned * 10000n / poolBefore) / 100;
+        console.log(`  Burn ratio: ${burnPct.toFixed(1)}%`);
+        expect(burnPct).toBeLessThanOrEqual(40.5);
+      }
+      console.log(`  ✓ SM2 executed within 40% cap`);
+    }, 120000);
+
+    it("FC-02-07: exchangeRate after SM2", async () => {
+      const shares = await diamondRead.getShares(account.address);
+      if (shares === 0n) {
+        console.log(`  ⚠️ No shares (SM2 tests skipped), checking exchange rate only`);
+      }
+      const rate = await diamondRead.getExchangeRate();
+      const ONE = 10n ** 18n;
+      console.log(`  Exchange rate: ${formatAmount(rate)} (1.0 = ${formatAmount(ONE)})`);
+      if (rate < ONE) {
+        console.log(`  ✓ Exchange rate shrunk as expected`);
+      } else {
+        console.log(`  ⚠️ Exchange rate >= 1.0 (SM2 may not have executed)`);
+      }
+    });
+
+    it("FC-02-04: SM2 cooldown period - second trigger reverts", async () => {
+      console.log(`\n[FC-02-04] Cooldown test`);
+      try {
+        await diamondWrite.triggerStabilityMode2();
+        console.log(`  ⚠️ SM2 did not revert (may not have been triggered previously)`);
+      } catch {
+        console.log(`  ✓ SM2 correctly rejected (cooldown or not triggerable)`);
+      }
+    }, 30000);
+
+    it("FC-02-06 + P-04-01: Dirty pool withdraw returns dual assets (apUSD + xBNB)", async () => {
+      console.log(`\n[FC-02-06] Dirty pool withdrawal + value verification`);
+
+      const currentShares = await diamondRead.getShares(account.address);
+      if (currentShares === 0n) {
+        console.log(`  ⚠️ No shares to withdraw, skipping`);
+        return;
+      }
+
+      // Advance time past minimum deposit period
+      try {
+        const minPeriod = await diamondRead.getMinDepositPeriod();
+        console.log(`  Advancing time by ${minPeriod}s (minDepositPeriod)...`);
+        await testClient.increaseTime({ seconds: Number(minPeriod) + 60 });
+        await testClient.mine({ blocks: 1 });
+      } catch {
+        console.log(`  Advancing time by 1 hour (fallback)...`);
+        await testClient.increaseTime({ seconds: 3600 });
+        await testClient.mine({ blocks: 1 });
+      }
+
+      const ONE = 10n ** 18n;
+      const [exchangeRate, xBNBPriceUSD] = await Promise.all([
+        diamondRead.getExchangeRate(),
+        diamondRead.getXBNBPriceUSD(),
+      ]);
+      console.log(`  Exchange rate: ${formatAmount(exchangeRate)}`);
+      console.log(`  xBNB price:    $${formatAmount(xBNBPriceUSD)}`);
+
+      const xBNBBefore = await getBalance(TOKENS.xBNB);
+      const apUSDBefore = await getBalance(TOKENS.apUSD);
+
+      console.log(`  Withdrawing ${formatAmount(currentShares)} shares...`);
+      try {
+        await waitTx(await diamondWrite.withdraw({ shares: currentShares }));
+      } catch (err: any) {
+        console.log(`  ⚠️ Withdraw failed: ${err.shortMessage || err.message?.slice(0, 100)}`);
+        return;
+      }
+
+      const apUSDReceived = (await getBalance(TOKENS.apUSD)) - apUSDBefore;
+      const xBNBReceived = (await getBalance(TOKENS.xBNB)) - xBNBBefore;
+      console.log(`  Received: ${formatAmount(apUSDReceived)} apUSD + ${formatAmount(xBNBReceived, 8)} xBNB`);
+
+      expect(apUSDReceived).toBeGreaterThanOrEqual(0n);
+
+      // Value verification: sApUSD × exchangeRate ≈ apUSD × $1 + xBNB × xBNBPrice
+      // expectedValue = shares × exchangeRate / 1e18 (in apUSD units, $1 each)
+      // actualValue   = apUSD + xBNB × xBNBPrice / 1e18
+      const expectedValue = currentShares * exchangeRate / ONE;
+      const apUSDValue = apUSDReceived;
+      const xBNBValue = xBNBPriceUSD > 0n ? xBNBReceived * xBNBPriceUSD / ONE : 0n;
+      const actualValue = apUSDValue + xBNBValue;
+
+      console.log(`  Expected value: $${formatAmount(expectedValue)} (${formatAmount(currentShares)} shares × ${formatAmount(exchangeRate)} rate)`);
+      console.log(`  Actual value:   $${formatAmount(actualValue)} (apUSD=$${formatAmount(apUSDValue)} + xBNB=$${formatAmount(xBNBValue)})`);
+
+      if (xBNBReceived > 0n) {
+        console.log(`  ✓ Dual-asset return confirmed (pool was dirty)`);
+      } else {
+        console.log(`  ⚠️ Only apUSD received — pool may not be dirty`);
+      }
+
+      if (expectedValue > 0n) {
+        const minAcceptable = expectedValue * 95n / 100n;
+        console.log(`  Min acceptable: $${formatAmount(minAcceptable)} (95% of expected)`);
+        expect(actualValue).toBeGreaterThanOrEqual(minAcceptable);
+        if (actualValue >= expectedValue) {
+          console.log(`  ✓ Value check passed: received >= expected (${(Number(actualValue * 10000n / expectedValue) / 100).toFixed(2)}%)`);
+        } else {
+          const lossPct = Number((expectedValue - actualValue) * 10000n / expectedValue) / 100;
+          console.log(`  ✓ Value check passed: loss ${lossPct.toFixed(2)}% (within 5% tolerance)`);
+        }
+      }
+    }, 120000);
+  });
+
+  // ================================================================
+  //  FC-04: Extreme Scenarios
+  // ================================================================
+
+  describe.skipIf(!IS_FORK)("FC-04: Extreme Scenarios [Fork]", () => {
+    let snap: `0x${string}`;
+    beforeAll(async () => { snap = await testClient.snapshot(); });
+    afterAll(async () => { await testClient.revert({ id: snap }); });
+
+    it("FC-04-03 + FC-04-04: Oracle staleness → operations rejected", async () => {
+      console.log(`\n[FC-04-03/04] Oracle freeze mode`);
+
+      let maxPriceAge: bigint;
+      try {
+        maxPriceAge = await diamondRead.getMaxPriceAge();
+      } catch {
+        console.log(`  ⚠️ getMaxPriceAge not available on this Diamond deployment, skipping`);
+        return;
+      }
+      console.log(`  Max oracle price age: ${maxPriceAge}s`);
+
+      const fastForward = Number(maxPriceAge) + 7200;
+      console.log(`  Fast-forwarding ${fastForward}s past oracle freshness window...`);
+      await testClient.increaseTime({ seconds: fastForward });
+      await testClient.mine({ blocks: 1 });
+
+      // All minting should fail due to stale oracle
+      let apUSDBlocked = false;
+      try {
+        await mintApUSDWithUSDT(parseAmount("1"));
+        console.log(`  ⚠️ apUSD mint succeeded (oracle might have fallback)`);
+      } catch {
+        apUSDBlocked = true;
+        console.log(`  ✓ apUSD mint rejected (stale oracle)`);
+      }
+
+      let xBNBBlocked = false;
+      try {
+        await mintXBNBWithUSDT(parseAmount("1"));
+        console.log(`  ⚠️ xBNB mint succeeded (oracle might have fallback)`);
+      } catch {
+        xBNBBlocked = true;
+        console.log(`  ✓ xBNB mint rejected (stale oracle)`);
+      }
+
+      expect(apUSDBlocked || xBNBBlocked).toBe(true);
+
+      // These may also fail when oracle is stale (contract checks oracle internally)
+      try {
+        const mode = await diamondRead.getStabilityMode();
+        const paused = await diamondRead.isPaused();
+        console.log(`  Stability mode: ${mode.mode}, Paused: ${paused}`);
+      } catch {
+        console.log(`  ⚠️ getStabilityMode/isPaused also reverted due to stale oracle (expected in strict oracle mode)`);
+      }
+    }, 120000);
+  });
+
+  // ================================================================
+  //  Live Mode: Current Zone Path Tests
+  //  Runs on real BSC with PRIVATE_KEY, testing fees + round-trips
+  //  at whatever the current on-chain CR zone is.
+  // ================================================================
+
+  describe.skipIf(!IS_LIVE)("Live Mode: Current Zone Path Tests", () => {
+    it("L-01: Fee tier + CR verification at current zone", async () => {
+      const fees = await getFees();
+      const zone = getZone(fees.currentCR);
+      const { contractCR, calculatedCR, tvlInUSD, apUSDSupply } = await verifyCR("Live CR");
+      console.log(`  Current zone: ${zone}, CR: ${formatCR(fees.currentCR)}`);
+      verifyFees(fees, zone, `Live Zone ${zone}`);
+
+      if (apUSDSupply > 0n) {
+        const diff = contractCR > calculatedCR ? contractCR - calculatedCR : calculatedCR - contractCR;
+        expect(diff).toBeLessThanOrEqual(1n);
+      }
+    });
+
+    it("L-02: USDT → apUSD → USDT (current zone)", async () => {
+      const fees = await getFees();
+      if (fees.apUSDMintDisabled) {
+        console.log(`  ⚠️ apUSD minting disabled at current CR, skipping`);
+        return;
+      }
+
+      const AMOUNT = parseAmount("0.1");
+      const usdtBal = await getBalance(TOKENS.USDT);
+      if (usdtBal < AMOUNT) {
+        console.log(`  ⚠️ Insufficient USDT (${formatAmount(usdtBal)}), skipping`);
+        return;
+      }
+
+      await approve(TOKENS.USDT, ROUTER, AMOUNT);
+      const apUSDBefore = await getBalance(TOKENS.apUSD);
+      let mintReceipt: any;
+      try {
+        const mintHash = await routerWrite.swapAndMintDefault({
+          inputToken: TOKENS.USDT, inputAmount: AMOUNT, mintXBNB: false, minMintOut: 0n, deadline: dl(),
+        });
+        mintReceipt = await publicClient.waitForTransactionReceipt({ hash: mintHash });
+      } catch (err: any) {
+        console.log(`  ⚠️ apUSD mint tx failed: ${err.shortMessage || err.message?.slice(0, 120)}`);
+        return;
+      }
+      if (mintReceipt.status !== "success") {
+        console.log(`  ⚠️ apUSD mint reverted on chain (possible liquidity/routing issue), skipping`);
+        return;
+      }
+      const apUSDAfter = await getBalance(TOKENS.apUSD);
+      const apUSDMinted = apUSDAfter - apUSDBefore;
+      console.log(`  Minted ${formatAmount(apUSDMinted)} apUSD from ${formatAmount(AMOUNT)} USDT`);
+      if (apUSDMinted === 0n) {
+        console.log(`  ⚠️ Minted 0 apUSD (Zone restriction or routing issue), skipping redeem`);
+        return;
+      }
+
+      // Verify mint fee against zone at mint time
+      const mintFees = await getFees();
+      const mintZone = getZone(mintFees.currentCR);
+      const mintArgs = parseDiamondEvent(mintReceipt, "ApUSDMinted");
+      if (mintArgs) {
+        const actualMintFee = Number(mintArgs.feeBPS);
+        console.log(`  Mint fee: ${actualMintFee} BPS (Zone ${mintZone} expects ${ZONE_FEES[mintZone].apUSDMintFee})`);
+        expect(actualMintFee).toBe(ZONE_FEES[mintZone].apUSDMintFee);
+      }
+
+      const redeemAmount = apUSDMinted / 2n;
+      if (redeemAmount === 0n) {
+        console.log(`  ⚠️ Minted amount too small to redeem`);
+        return;
+      }
+      const usdtBefore = await getBalance(TOKENS.USDT);
+      let redeemReceipt: any;
+      try {
+        redeemReceipt = await redeemToUSDT(redeemAmount, false);
+      } catch (err: any) {
+        console.log(`  ⚠️ Redeem failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+        return;
+      }
+      const usdtAfter = await getBalance(TOKENS.USDT);
+      console.log(`  Redeemed ${formatAmount(redeemAmount)} apUSD → ${formatAmount(usdtAfter - usdtBefore)} USDT`);
+      expect(usdtAfter).toBeGreaterThan(usdtBefore);
+
+      // Verify redeem fee against zone at redeem time (may differ from mint zone in small pools)
+      const redeemFees = await getFees();
+      const redeemZone = getZone(redeemFees.currentCR);
+      const redeemArgs = parseDiamondEvent(redeemReceipt, "ApUSDRedeemed");
+      if (redeemArgs) {
+        const actualRedeemFee = Number(redeemArgs.feeBPS);
+        console.log(`  Redeem fee: ${actualRedeemFee} BPS (Zone ${redeemZone} expects ${ZONE_FEES[redeemZone].apUSDRedeemFee})`);
+        expect(actualRedeemFee).toBe(ZONE_FEES[redeemZone].apUSDRedeemFee);
+      }
+      if (mintZone !== redeemZone) {
+        console.log(`  ⚠️ Zone shifted during test: mint in Zone ${mintZone}, redeem in Zone ${redeemZone}`);
+      }
+    }, 180000);
+
+    it("L-03: USDT → xBNB → USDT (current zone)", async () => {
+      const AMOUNT = parseAmount("0.1");
+      const usdtBal = await getBalance(TOKENS.USDT);
+      if (usdtBal < AMOUNT) {
+        console.log(`  ⚠️ Insufficient USDT (${formatAmount(usdtBal)}), skipping`);
+        return;
+      }
+
+      await approve(TOKENS.USDT, ROUTER, AMOUNT);
+      const xBNBBefore = await getBalance(TOKENS.xBNB);
+      let mintReceipt: any;
+      try {
+        const mintHash = await routerWrite.swapAndMintDefault({
+          inputToken: TOKENS.USDT, inputAmount: AMOUNT, mintXBNB: true, minMintOut: 0n, deadline: dl(),
+        });
+        mintReceipt = await publicClient.waitForTransactionReceipt({ hash: mintHash });
+      } catch (err: any) {
+        console.log(`  ⚠️ xBNB mint tx failed: ${err.shortMessage || err.message?.slice(0, 120)}`);
+        return;
+      }
+      if (mintReceipt.status !== "success") {
+        console.log(`  ⚠️ xBNB mint reverted on chain (possible liquidity/routing issue), skipping`);
+        return;
+      }
+      const xBNBAfter = await getBalance(TOKENS.xBNB);
+      const xBNBMinted = xBNBAfter - xBNBBefore;
+      console.log(`  Minted ${formatAmount(xBNBMinted)} xBNB from ${formatAmount(AMOUNT)} USDT`);
+      if (xBNBMinted === 0n) {
+        console.log(`  ⚠️ Minted 0 xBNB (routing issue), skipping redeem`);
+        return;
+      }
+
+      // Verify mint fee against zone at mint time
+      const mintFees = await getFees();
+      const mintZone = getZone(mintFees.currentCR);
+      const xMintArgs = parseDiamondEvent(mintReceipt, "XBNBMinted");
+      if (xMintArgs) {
+        const actualMintFee = Number(xMintArgs.feeBPS);
+        console.log(`  Mint fee: ${actualMintFee} BPS (Zone ${mintZone} expects ${ZONE_FEES[mintZone].xBNBMintFee})`);
+        expect(actualMintFee).toBe(ZONE_FEES[mintZone].xBNBMintFee);
+      }
+
+      const redeemAmount = xBNBMinted / 2n;
+      if (redeemAmount === 0n) {
+        console.log(`  ⚠️ Minted amount too small to redeem`);
+        return;
+      }
+      const usdtBefore = await getBalance(TOKENS.USDT);
+      let redeemReceipt: any;
+      try {
+        redeemReceipt = await redeemToUSDT(redeemAmount, true);
+      } catch (err: any) {
+        console.log(`  ⚠️ Redeem failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+        return;
+      }
+      const usdtAfter = await getBalance(TOKENS.USDT);
+      console.log(`  Redeemed ${formatAmount(redeemAmount)} xBNB → ${formatAmount(usdtAfter - usdtBefore)} USDT`);
+      expect(usdtAfter).toBeGreaterThan(usdtBefore);
+
+      // Verify redeem fee against zone at redeem time
+      const redeemFees = await getFees();
+      const redeemZone = getZone(redeemFees.currentCR);
+      const xRedeemArgs = parseDiamondEvent(redeemReceipt, "XBNBRedeemed");
+      if (xRedeemArgs) {
+        const actualRedeemFee = Number(xRedeemArgs.feeBPS);
+        console.log(`  Redeem fee: ${actualRedeemFee} BPS (Zone ${redeemZone} expects ${ZONE_FEES[redeemZone].xBNBRedeemFee})`);
+        expect(actualRedeemFee).toBe(ZONE_FEES[redeemZone].xBNBRedeemFee);
+      }
+      if (mintZone !== redeemZone) {
+        console.log(`  ⚠️ Zone shifted during test: mint in Zone ${mintZone}, redeem in Zone ${redeemZone}`);
+      }
+    }, 180000);
+
+    it("L-04: BNB → xBNB (stakeAndMint, current zone)", async () => {
+      const BNB_AMOUNT = parseEther("0.0005");
+      const bnbBal = await publicClient.getBalance({ address: account.address });
+      const minRequired = BNB_AMOUNT + parseEther("0.0005");
+      if (bnbBal < minRequired) {
+        console.log(`  ⚠️ Insufficient BNB: have ${formatAmount(bnbBal)}, need ${formatAmount(minRequired)} (value+gas), skipping`);
+        return;
+      }
+      const xBNBBefore = await getBalance(TOKENS.xBNB);
+      try {
+        const hash = await routerWrite.stakeAndMint({
+          targetLST: TOKENS.slisBNB, isXBNB: true, minMintOut: 0n, deadline: dl(), value: BNB_AMOUNT,
+        });
+        const receipt = await waitTx(hash);
+        const xBNBAfter = await getBalance(TOKENS.xBNB);
+        console.log(`  Staked ${formatAmount(BNB_AMOUNT)} BNB → ${formatAmount(xBNBAfter - xBNBBefore)} xBNB`);
+        expect(xBNBAfter).toBeGreaterThan(xBNBBefore);
+      } catch (err: any) {
+        console.log(`  ⚠️ stakeAndMint failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+      }
+    }, 120000);
+
+    it("L-05: BNB → apUSD (stakeAndMint, current zone)", async () => {
+      const fees = await getFees();
+      if (fees.apUSDMintDisabled) {
+        console.log(`  ⚠️ apUSD minting disabled at current CR, skipping`);
+        return;
+      }
+
+      const BNB_AMOUNT = parseEther("0.0005");
+      const bnbBal = await publicClient.getBalance({ address: account.address });
+      const minRequired = BNB_AMOUNT + parseEther("0.0005");
+      if (bnbBal < minRequired) {
+        console.log(`  ⚠️ Insufficient BNB: have ${formatAmount(bnbBal)}, need ${formatAmount(minRequired)} (value+gas), skipping`);
+        return;
+      }
+      const apUSDBefore = await getBalance(TOKENS.apUSD);
+      try {
+        const hash = await routerWrite.stakeAndMint({
+          targetLST: TOKENS.slisBNB, isXBNB: false, minMintOut: 0n, deadline: dl(), value: BNB_AMOUNT,
+        });
+        const receipt = await waitTx(hash);
+        const apUSDAfter = await getBalance(TOKENS.apUSD);
+        console.log(`  Staked ${formatAmount(BNB_AMOUNT)} BNB → ${formatAmount(apUSDAfter - apUSDBefore)} apUSD`);
+        expect(apUSDAfter).toBeGreaterThan(apUSDBefore);
+      } catch (err: any) {
+        console.log(`  ⚠️ stakeAndMint failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+      }
+    }, 120000);
+
+    it("L-06: Read-only protocol stats", async () => {
+      const [cr, tvlBNB, tvlUSD, supply, xBNBSupply, lsts] = await Promise.all([
+        getCR(),
+        diamondRead.getTVLInBNB(),
+        diamondRead.getTVLInUSD(),
+        diamondRead.getApUSDSupply(),
+        diamondRead.getXBNBSupply(),
+        diamondRead.getSupportedLSTs(),
+      ]);
+
+      console.log(`  CR: ${formatCR(cr)}`);
+      console.log(`  TVL(BNB): ${formatAmount(tvlBNB)} | TVL(USD): $${formatAmount(tvlUSD)}`);
+      console.log(`  apUSD supply: ${formatAmount(supply)} | xBNB supply: ${formatAmount(xBNBSupply)}`);
+      console.log(`  Supported LSTs: ${lsts.length}`);
+
+      expect(cr).toBeGreaterThan(0n);
+      expect(tvlBNB).toBeGreaterThan(0n);
+      expect(tvlUSD).toBeGreaterThan(0n);
+      expect(supply).toBeGreaterThan(0n);
+    });
+
+    // Zone traversal: A → B → C → D, verify fees at each zone
+    // Uses real USDT to manipulate CR. Requires ~15 USDT.
+    // Slower tx wait (3s) so operator can check bot alerts at each zone transition.
+
+    it("L-07: Raise to Zone A → verify fees + real mint/redeem", async () => {
+      txWaitMs = 3000;
+      if (!(await ensureGas("L-07"))) return;
+      const usdtBal = await getBalance(TOKENS.USDT);
+      if (usdtBal < parseAmount("3")) {
+        console.log(`  ⚠️ Insufficient USDT (${formatAmount(usdtBal)}) for zone traversal, skipping`);
+        return;
+      }
+
+      const crBefore = await getCR();
+      console.log(`  CR before: ${formatCR(crBefore)}`);
+
+      try {
+        await raiseCRTo(ZONE_CR.A_MIN + 500n);
+      } catch (err: any) {
+        console.log(`  ⚠️ Could not raise to Zone A: ${err.message?.slice(0, 80)}`);
+        const cur = await getCR();
+        const zone = getZone(cur);
+        console.log(`  Verifying fees for current zone ${zone} instead`);
+        const fees = await getFees();
+        verifyFees(fees, zone, `Zone ${zone}`);
+        return;
+      }
+
+      if (IS_LIVE) {
+        console.log(`  ⏳ Zone A reached, waiting 30s for bot alert check...`);
+        await sleep(30000);
+      }
+
+      const { zone } = await verifyCR("Zone A");
+      const fees = await getFees();
+      verifyFees(fees, zone, `Zone ${zone}`);
+
+      const TEST_AMT = parseAmount("0.1");
+
+      // apUSD round-trip: USDT → apUSD → USDT
+      if (!fees.apUSDMintDisabled) {
+        console.log(`  [Zone ${zone}] apUSD round-trip (0.1 USDT)...`);
+        const apUSDBefore = await getBalance(TOKENS.apUSD);
+        let mintReceipt: any;
+        try {
+          mintReceipt = await mintApUSDWithUSDT(TEST_AMT);
+        } catch (err: any) {
+          console.log(`  ⚠️ apUSD mint failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+          mintReceipt = null;
+        }
+        if (mintReceipt) {
+          const apUSDMinted = (await getBalance(TOKENS.apUSD)) - apUSDBefore;
+          console.log(`    Minted: ${formatAmount(apUSDMinted)} apUSD`);
+          if (apUSDMinted > 0n) {
+            const usdtBefore = await getBalance(TOKENS.USDT);
+            try {
+              const redeemReceipt = await redeemToUSDT(apUSDMinted, false);
+              const usdtReceived = (await getBalance(TOKENS.USDT)) - usdtBefore;
+              console.log(`    Redeemed: ${formatAmount(usdtReceived)} USDT`);
+              const curFees = await getFees();
+              const curZone = getZone(curFees.currentCR);
+              verifyEventFees(mintReceipt, redeemReceipt, false, curZone, `Zone ${curZone} apUSD`);
+            } catch (err: any) {
+              console.log(`  ⚠️ apUSD redeem failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+            }
+          }
+        }
+      } else {
+        console.log(`  [Zone ${zone}] apUSD minting disabled, skipping apUSD round-trip`);
+      }
+
+      // xBNB round-trip: USDT → xBNB → USDT
+      console.log(`  [Zone ${zone}] xBNB round-trip (0.1 USDT)...`);
+      const xBNBBefore = await getBalance(TOKENS.xBNB);
+      let xMintReceipt: any;
+      try {
+        xMintReceipt = await mintXBNBWithUSDT(TEST_AMT);
+      } catch (err: any) {
+        console.log(`  ⚠️ xBNB mint failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+        xMintReceipt = null;
+      }
+      if (xMintReceipt) {
+        const xBNBMinted = (await getBalance(TOKENS.xBNB)) - xBNBBefore;
+        console.log(`    Minted: ${formatAmount(xBNBMinted, 8)} xBNB`);
+        if (xBNBMinted > 0n) {
+          const usdtBefore = await getBalance(TOKENS.USDT);
+          try {
+            const redeemReceipt = await redeemToUSDT(xBNBMinted, true);
+            const usdtReceived = (await getBalance(TOKENS.USDT)) - usdtBefore;
+            console.log(`    Redeemed: ${formatAmount(usdtReceived)} USDT`);
+            const curFees = await getFees();
+            const curZone = getZone(curFees.currentCR);
+            verifyEventFees(xMintReceipt, redeemReceipt, true, curZone, `Zone ${curZone} xBNB`);
+          } catch (err: any) {
+            console.log(`  ⚠️ xBNB redeem failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+          }
+        }
+      }
+
+      console.log(`  USDT remaining: ${formatAmount(await getBalance(TOKENS.USDT))}`);
+    }, 600000);
+
+    it("L-08: Lower to Zone B → verify fees + real mint/redeem", async () => {
+      if (!(await ensureGas("L-08"))) return;
+      const cr = await getCR();
+      if (!ZONE_CR.B_MIN || cr < ZONE_CR.B_MIN) {
+        console.log(`  ⚠️ Already below Zone B (CR=${formatCR(cr)}), skipping`);
+        return;
+      }
+
+      try {
+        await lowerCRTo(ZONE_CR.B_MIN + 500n);
+      } catch (err: any) {
+        console.log(`  ⚠️ Could not lower to Zone B: ${err.message?.slice(0, 80)}`);
+      }
+
+      if (IS_LIVE) {
+        console.log(`  ⏳ Zone B reached, waiting 30s for bot alert check...`);
+        await sleep(30000);
+      }
+
+      const { zone } = await verifyCR("Zone B");
+      const fees = await getFees();
+      const actualZone = getZone(fees.currentCR);
+      verifyFees(fees, actualZone, `Zone ${actualZone}`);
+
+      const TEST_AMT = parseAmount("0.1");
+
+      // apUSD round-trip: USDT → apUSD → USDT
+      if (!fees.apUSDMintDisabled) {
+        console.log(`  [Zone ${actualZone}] apUSD round-trip (0.1 USDT)...`);
+        const apUSDBefore = await getBalance(TOKENS.apUSD);
+        let mintReceipt: any;
+        try {
+          mintReceipt = await mintApUSDWithUSDT(TEST_AMT);
+        } catch (err: any) {
+          console.log(`  ⚠️ apUSD mint failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+          mintReceipt = null;
+        }
+        if (mintReceipt) {
+          const apUSDMinted = (await getBalance(TOKENS.apUSD)) - apUSDBefore;
+          console.log(`    Minted: ${formatAmount(apUSDMinted)} apUSD`);
+          if (apUSDMinted > 0n) {
+            const usdtBefore = await getBalance(TOKENS.USDT);
+            try {
+              const redeemReceipt = await redeemToUSDT(apUSDMinted, false);
+              const usdtReceived = (await getBalance(TOKENS.USDT)) - usdtBefore;
+              console.log(`    Redeemed: ${formatAmount(usdtReceived)} USDT`);
+              const curFees = await getFees();
+              const curZone = getZone(curFees.currentCR);
+              verifyEventFees(mintReceipt, redeemReceipt, false, curZone, `Zone ${curZone} apUSD`);
+            } catch (err: any) {
+              console.log(`  ⚠️ apUSD redeem failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+            }
+          }
+        }
+      } else {
+        console.log(`  [Zone ${actualZone}] apUSD minting disabled, skipping apUSD round-trip`);
+      }
+
+      // xBNB round-trip: USDT → xBNB → USDT
+      console.log(`  [Zone ${actualZone}] xBNB round-trip (0.1 USDT)...`);
+      const xBNBBefore = await getBalance(TOKENS.xBNB);
+      let xMintReceipt: any;
+      try {
+        xMintReceipt = await mintXBNBWithUSDT(TEST_AMT);
+      } catch (err: any) {
+        console.log(`  ⚠️ xBNB mint failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+        xMintReceipt = null;
+      }
+      if (xMintReceipt) {
+        const xBNBMinted = (await getBalance(TOKENS.xBNB)) - xBNBBefore;
+        console.log(`    Minted: ${formatAmount(xBNBMinted, 8)} xBNB`);
+        if (xBNBMinted > 0n) {
+          const usdtBefore = await getBalance(TOKENS.USDT);
+          try {
+            const redeemReceipt = await redeemToUSDT(xBNBMinted, true);
+            const usdtReceived = (await getBalance(TOKENS.USDT)) - usdtBefore;
+            console.log(`    Redeemed: ${formatAmount(usdtReceived)} USDT`);
+            const curFees = await getFees();
+            const curZone = getZone(curFees.currentCR);
+            verifyEventFees(xMintReceipt, redeemReceipt, true, curZone, `Zone ${curZone} xBNB`);
+          } catch (err: any) {
+            console.log(`  ⚠️ xBNB redeem failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+          }
+        }
+      }
+
+      console.log(`  USDT remaining: ${formatAmount(await getBalance(TOKENS.USDT))}`);
+    }, 600000);
+
+    it("L-09: Lower to Zone C → verify fees + real mint/redeem", async () => {
+      if (!(await ensureGas("L-09"))) return;
+      const cr = await getCR();
+      if (!ZONE_CR.C_MIN || cr < ZONE_CR.C_MIN) {
+        console.log(`  ⚠️ Already below Zone C (CR=${formatCR(cr)}), skipping`);
+        return;
+      }
+
+      try {
+        await lowerCRTo(ZONE_CR.C_MIN + 500n);
+      } catch (err: any) {
+        console.log(`  ⚠️ Could not lower to Zone C: ${err.message?.slice(0, 80)}`);
+      }
+
+      if (IS_LIVE) {
+        console.log(`  ⏳ Zone C reached, waiting 30s for bot alert check...`);
+        await sleep(30000);
+      }
+
+      const { zone } = await verifyCR("Zone C");
+      const fees = await getFees();
+      const actualZone = getZone(fees.currentCR);
+      verifyFees(fees, actualZone, `Zone ${actualZone}`);
+
+      const TEST_AMT = parseAmount("0.1");
+
+      // apUSD round-trip: USDT → apUSD → USDT
+      if (!fees.apUSDMintDisabled) {
+        console.log(`  [Zone ${actualZone}] apUSD round-trip (0.1 USDT)...`);
+        const apUSDBefore = await getBalance(TOKENS.apUSD);
+        let mintReceipt: any;
+        try {
+          mintReceipt = await mintApUSDWithUSDT(TEST_AMT);
+        } catch (err: any) {
+          console.log(`  ⚠️ apUSD mint failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+          mintReceipt = null;
+        }
+        if (mintReceipt) {
+          const apUSDMinted = (await getBalance(TOKENS.apUSD)) - apUSDBefore;
+          console.log(`    Minted: ${formatAmount(apUSDMinted)} apUSD`);
+          if (apUSDMinted > 0n) {
+            const usdtBefore = await getBalance(TOKENS.USDT);
+            try {
+              const redeemReceipt = await redeemToUSDT(apUSDMinted, false);
+              const usdtReceived = (await getBalance(TOKENS.USDT)) - usdtBefore;
+              console.log(`    Redeemed: ${formatAmount(usdtReceived)} USDT`);
+              const curFees = await getFees();
+              const curZone = getZone(curFees.currentCR);
+              verifyEventFees(mintReceipt, redeemReceipt, false, curZone, `Zone ${curZone} apUSD`);
+            } catch (err: any) {
+              console.log(`  ⚠️ apUSD redeem failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+            }
+          }
+        }
+      } else {
+        console.log(`  [Zone ${actualZone}] apUSD minting disabled, skipping apUSD round-trip`);
+      }
+
+      // xBNB round-trip: USDT → xBNB → USDT
+      console.log(`  [Zone ${actualZone}] xBNB round-trip (0.1 USDT)...`);
+      const xBNBBefore = await getBalance(TOKENS.xBNB);
+      let xMintReceipt: any;
+      try {
+        xMintReceipt = await mintXBNBWithUSDT(TEST_AMT);
+      } catch (err: any) {
+        console.log(`  ⚠️ xBNB mint failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+        xMintReceipt = null;
+      }
+      if (xMintReceipt) {
+        const xBNBMinted = (await getBalance(TOKENS.xBNB)) - xBNBBefore;
+        console.log(`    Minted: ${formatAmount(xBNBMinted, 8)} xBNB`);
+        if (xBNBMinted > 0n) {
+          const usdtBefore = await getBalance(TOKENS.USDT);
+          try {
+            const redeemReceipt = await redeemToUSDT(xBNBMinted, true);
+            const usdtReceived = (await getBalance(TOKENS.USDT)) - usdtBefore;
+            console.log(`    Redeemed: ${formatAmount(usdtReceived)} USDT`);
+            const curFees = await getFees();
+            const curZone = getZone(curFees.currentCR);
+            verifyEventFees(xMintReceipt, redeemReceipt, true, curZone, `Zone ${curZone} xBNB`);
+          } catch (err: any) {
+            console.log(`  ⚠️ xBNB redeem failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+          }
+        }
+      }
+
+      console.log(`  USDT remaining: ${formatAmount(await getBalance(TOKENS.USDT))}`);
+    }, 600000);
+
+    it("L-10: Lower to Zone D → verify apUSD disabled + fees + real xBNB mint/redeem", async () => {
+      if (!(await ensureGas("L-10"))) return;
+      const cr = await getCR();
+      if (!ZONE_CR.C_MIN || cr < 11000n) {
+        console.log(`  ⚠️ CR already very low (${formatCR(cr)}), skipping`);
+        return;
+      }
+
+      // Target: middle of Zone D. Use D_MIN if available, otherwise C_MIN - 1500
+      const zoneDTarget = ZONE_CR.D_MIN
+        ? ZONE_CR.D_MIN + (ZONE_CR.C_MIN - ZONE_CR.D_MIN) / 2n
+        : ZONE_CR.C_MIN - 1500n;
+      console.log(`  Lowering CR to Zone D target: ${formatCR(zoneDTarget)} (current: ${formatCR(cr)})`);
+
+      try {
+        await lowerCRTo(zoneDTarget);
+      } catch (err: any) {
+        console.log(`  ⚠️ Could not lower to Zone D: ${err.message?.slice(0, 80)}`);
+      }
+
+      if (IS_LIVE) {
+        const crNow = await getCR();
+        console.log(`  ⏳ Zone D reached (CR=${formatCR(crNow)}), waiting 60s for bot alert check...`);
+        await sleep(60000);
+      }
+
+      const fees = await getFees();
+      const actualZone = getZone(fees.currentCR);
+      console.log(`  Zone ${actualZone}: CR=${formatCR(fees.currentCR)} disabled=${fees.apUSDMintDisabled}`);
+      verifyFees(fees, actualZone, `Zone ${actualZone}`);
+
+      if (actualZone === ZONE_LAST_LABEL) {
+        expect(fees.apUSDMintDisabled).toBe(true);
+        console.log(`  ✓ apUSD minting is disabled in Zone ${actualZone} as expected`);
+
+        // Verify apUSD mint is actually blocked on-chain
+        try {
+          await mintApUSDWithUSDT(parseAmount("0.1"));
+          console.log(`  ⚠️ apUSD mint unexpectedly succeeded in Zone ${actualZone}`);
+        } catch {
+          console.log(`  ✓ apUSD mint correctly rejected in Zone ${actualZone}`);
+        }
+      }
+
+      // xBNB round-trip: USDT → xBNB → USDT (extreme fees in Zone D)
+      const TEST_AMT = parseAmount("0.1");
+      console.log(`  [Zone ${actualZone}] xBNB round-trip (0.1 USDT, extreme fees)...`);
+      const xBNBBefore = await getBalance(TOKENS.xBNB);
+      let xMintReceipt: any;
+      try {
+        xMintReceipt = await mintXBNBWithUSDT(TEST_AMT);
+      } catch (err: any) {
+        console.log(`  ⚠️ xBNB mint failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+        xMintReceipt = null;
+      }
+      if (xMintReceipt) {
+        const xBNBMinted = (await getBalance(TOKENS.xBNB)) - xBNBBefore;
+        console.log(`    Minted: ${formatAmount(xBNBMinted, 8)} xBNB`);
+        if (xBNBMinted > 0n) {
+          const usdtBefore = await getBalance(TOKENS.USDT);
+          try {
+            const redeemReceipt = await redeemToUSDT(xBNBMinted, true);
+            const usdtReceived = (await getBalance(TOKENS.USDT)) - usdtBefore;
+            console.log(`    Redeemed: ${formatAmount(usdtReceived)} USDT`);
+            const curFees = await getFees();
+            const curZone = getZone(curFees.currentCR);
+            verifyEventFees(xMintReceipt, redeemReceipt, true, curZone, `Zone ${curZone} xBNB`);
+          } catch (err: any) {
+            console.log(`  ⚠️ xBNB redeem failed: ${err.shortMessage || err.message?.slice(0, 80)}`);
+          }
+        }
+      }
+
+      console.log(`  USDT remaining: ${formatAmount(await getBalance(TOKENS.USDT))}`);
+    }, 600000);
+
+    it("L-11: Restore CR to safe zone (Zone B/C)", async () => {
+      txWaitMs = 500;
+      if (!(await ensureGas("L-11"))) return;
+      const cr = await getCR();
+      const targetCR = ZONE_CR.B_MIN ? ZONE_CR.B_MIN + 500n : 15500n;
+      if (cr >= targetCR) {
+        console.log(`  CR already at ${formatCR(cr)}, no restore needed`);
+        return;
+      }
+
+      const usdtBal = await getBalance(TOKENS.USDT);
+      if (usdtBal < parseAmount("0.5")) {
+        console.log(`  ⚠️ Not enough USDT to restore CR (${formatAmount(usdtBal)})`);
+        console.log(`  ⚠️ Current CR: ${formatCR(cr)} — you may need to manually mint xBNB to raise CR`);
+        return;
+      }
+
+      console.log(`  Restoring CR from ${formatCR(cr)} to ${formatCR(targetCR)}...`);
+      try {
+        await raiseCRTo(targetCR);
+      } catch (err: any) {
+        console.log(`  ⚠️ Could not fully restore CR: ${err.message?.slice(0, 80)}`);
+      }
+
+      const finalCR = await getCR();
+      const finalZone = getZone(finalCR);
+      console.log(`  Final CR: ${formatCR(finalCR)} (Zone ${finalZone})`);
+      console.log(`  USDT remaining: ${formatAmount(await getBalance(TOKENS.USDT))}`);
+    }, 600000);
+  });
+});