@aspan/sdk 0.4.0 → 0.4.2

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

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