@aspan/sdk 0.4.0 → 0.4.1

package/src/bot/config.ts

@@ -32,6 +32,29 @@ export interface BotConfig {
   maxRetries: number;
   retryDelayMs: number;
   retryBackoffMultiplier: number;
+
+  // Risk Keeper Configuration (optional)
+  riskKeeper?: {
+    enabled: boolean;
+    sApUSDAddress: Address;
+    routerAddress: Address;
+    wbnbAddress: Address;
+    privateKey: `0x${string}`;
+    sm2CooldownMs: number;
+    sm2MaxPoolPercent: number;
+    twapIntervalMs: number;
+    twapPercentage: number;
+    maxSlippageBps: number;
+    twapStartCR: bigint;
+    maxVolatilityPercent: number;
+  };
+
+  // Fee Manager Configuration (optional)
+  feeManager?: {
+    enabled: boolean;
+    privateKey: `0x${string}`;
+    checkIntervalMs: number;
+  };
 }
 
 export function loadConfig(): BotConfig {
@@ -50,7 +73,7 @@ export function loadConfig(): BotConfig {
 
     // Contract
     diamondAddress: (process.env.DIAMOND_ADDRESS ??
-      "0x10d25Ae0690533e0BA9E64EC7ae77dbD4fE8A46f") as Address,
+      "0x6a11B30d3a70727d5477D6d8090e144443fA1c78") as Address,
 
     // Intervals
     statsReportInterval: parseInt(
@@ -80,5 +103,32 @@ export function loadConfig(): BotConfig {
     maxRetries: parseInt(process.env.MAX_RETRIES ?? "3", 10),
     retryDelayMs: parseInt(process.env.RETRY_DELAY_MS ?? "1000", 10),
     retryBackoffMultiplier: parseFloat(process.env.RETRY_BACKOFF ?? "2"),
+
+    // Risk Keeper (optional - only enabled if private key is provided)
+    riskKeeper: process.env.KEEPER_PRIVATE_KEY
+      ? {
+          enabled: process.env.RISK_KEEPER_ENABLED === "true",
+          sApUSDAddress: (process.env.SAPUSD_ADDRESS ?? "") as Address,
+          routerAddress: (process.env.ROUTER_ADDRESS ?? "0x10ED43C718714eb63d5aA57B78B54704E256024E") as Address, // PancakeSwap V2
+          wbnbAddress: (process.env.WBNB_ADDRESS ?? "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c") as Address,
+          privateKey: process.env.KEEPER_PRIVATE_KEY as `0x${string}`,
+          sm2CooldownMs: parseInt(process.env.SM2_COOLDOWN_MS ?? "1800000", 10), // 30 min
+          sm2MaxPoolPercent: parseInt(process.env.SM2_MAX_POOL_PERCENT ?? "40", 10), // 40%
+          twapIntervalMs: parseInt(process.env.TWAP_INTERVAL_MS ?? "600000", 10), // 10 min
+          twapPercentage: parseInt(process.env.TWAP_PERCENTAGE ?? "5", 10), // 5%
+          maxSlippageBps: parseInt(process.env.MAX_SLIPPAGE_BPS ?? "50", 10), // 0.5%
+          twapStartCR: BigInt(process.env.TWAP_START_CR ?? "13500"), // 135%
+          maxVolatilityPercent: parseInt(process.env.MAX_VOLATILITY_PERCENT ?? "5", 10), // 5%
+        }
+      : undefined,
+
+    // Fee Manager (optional - uses same or different private key)
+    feeManager: process.env.FEE_MANAGER_ENABLED === "true" && process.env.FEE_MANAGER_PRIVATE_KEY
+      ? {
+          enabled: true,
+          privateKey: process.env.FEE_MANAGER_PRIVATE_KEY as `0x${string}`,
+          checkIntervalMs: parseInt(process.env.FEE_CHECK_INTERVAL_MS ?? "60000", 10), // 1 min
+        }
+      : undefined,
   };
 }

package/src/bot/index.ts

@@ -11,6 +11,8 @@ import { createRobustClient } from "./services/rpc-client";
 import { StatsMonitor } from "./monitors/stats-monitor";
 import { CRMonitor } from "./monitors/cr-monitor";
 import { MempoolMonitor } from "./monitors/mempool-monitor";
+import { RiskKeeperService } from "./services/risk-keeper";
+import { FeeManagerService } from "./services/fee-manager";
 
 class AspanMonitoringBot {
   private config = loadConfig();
@@ -18,6 +20,8 @@ class AspanMonitoringBot {
   private statsMonitor: StatsMonitor;
   private crMonitor: CRMonitor;
   private mempoolMonitor: MempoolMonitor;
+  private riskKeeper?: RiskKeeperService;
+  private feeManager?: FeeManagerService;
   private isRunning = false;
 
   constructor() {
@@ -48,6 +52,47 @@ class AspanMonitoringBot {
       this.config
     );
 
+    // Initialize Risk Keeper if enabled
+    if (this.config.riskKeeper?.enabled) {
+      console.log("Initializing Risk Keeper...");
+      this.riskKeeper = new RiskKeeperService(
+        aspanClient,
+        this.slack,
+        this.config,
+        {
+          diamondAddress: this.config.diamondAddress,
+          sApUSDAddress: this.config.riskKeeper.sApUSDAddress,
+          routerAddress: this.config.riskKeeper.routerAddress,
+          wbnbAddress: this.config.riskKeeper.wbnbAddress,
+          privateKey: this.config.riskKeeper.privateKey,
+          rpcUrl: this.config.rpcUrl,
+          sm2CooldownMs: this.config.riskKeeper.sm2CooldownMs,
+          sm2MaxPoolPercent: this.config.riskKeeper.sm2MaxPoolPercent,
+          twapIntervalMs: this.config.riskKeeper.twapIntervalMs,
+          twapPercentage: this.config.riskKeeper.twapPercentage,
+          maxSlippageBps: this.config.riskKeeper.maxSlippageBps,
+          twapStartCR: this.config.riskKeeper.twapStartCR,
+          maxVolatilityPercent: this.config.riskKeeper.maxVolatilityPercent,
+        }
+      );
+    }
+
+    // Initialize Fee Manager if enabled
+    if (this.config.feeManager?.enabled) {
+      console.log("Initializing Fee Manager...");
+      this.feeManager = new FeeManagerService(
+        aspanClient,
+        this.slack,
+        this.config,
+        {
+          diamondAddress: this.config.diamondAddress,
+          privateKey: this.config.feeManager.privateKey,
+          rpcUrl: this.config.rpcUrl,
+          checkIntervalMs: this.config.feeManager.checkIntervalMs,
+        }
+      );
+    }
+
     console.log(`Diamond Address: ${this.config.diamondAddress}`);
     console.log(`RPC URL: ${this.config.rpcUrl}`);
   }
@@ -61,8 +106,9 @@ class AspanMonitoringBot {
     console.log("\nStarting Aspan Monitoring Bot...\n");
 
     // Send startup notification
+    const riskKeeperStatus = this.riskKeeper ? " + Risk Keeper" : "";
     await this.slack.send({
-      text: ":robot_face: Aspan Monitoring Bot started",
+      text: `:robot_face: Aspan Monitoring Bot started${riskKeeperStatus}`,
     });
 
     // Start all monitors
@@ -70,6 +116,18 @@ class AspanMonitoringBot {
     this.crMonitor.start();
     await this.mempoolMonitor.start();
 
+    // Start Risk Keeper if enabled
+    if (this.riskKeeper) {
+      this.riskKeeper.start();
+      console.log("Risk Keeper started");
+    }
+
+    // Start Fee Manager if enabled
+    if (this.feeManager) {
+      this.feeManager.start();
+      console.log("Fee Manager started");
+    }
+
     this.isRunning = true;
     console.log("\nAll monitors started successfully!\n");
   }
@@ -86,6 +144,16 @@ class AspanMonitoringBot {
     this.crMonitor.stop();
     this.mempoolMonitor.stop();
 
+    // Stop Risk Keeper if running
+    if (this.riskKeeper) {
+      this.riskKeeper.stop();
+    }
+
+    // Stop Fee Manager if running
+    if (this.feeManager) {
+      this.feeManager.stop();
+    }
+
     // Send shutdown notification
     await this.slack.send({
       text: ":wave: Aspan Monitoring Bot stopped",

package/src/bot/services/fee-manager.ts

@@ -0,0 +1,303 @@
+/**
+ * Fee Manager Service
+ * Automatically adjusts fee tiers based on CR zones
+ */
+
+import {
+  createWalletClient,
+  http,
+  type Address,
+  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 type { SlackService } from "./slack";
+import { SlackColors } from "./slack";
+import type { BotConfig } from "../config";
+import { withRetry } from "./rpc-client";
+
+// ============ Types ============
+
+export interface FeeManagerConfig {
+  /** Diamond contract address */
+  diamondAddress: Address;
+  /** Fee manager private key */
+  privateKey: `0x${string}`;
+  /** RPC URL */
+  rpcUrl: string;
+  /** Chain */
+  chain?: Chain;
+  /** Check interval in ms (default 1 min) */
+  checkIntervalMs?: number;
+}
+
+/**
+ * Fee tier configuration per zone
+ * Based on Aspan Risk Management Framework
+ */
+interface FeeTier {
+  minCR: bigint;           // Minimum CR for this tier (BPS)
+  apUSDMintFee: number;    // BPS
+  apUSDRedeemFee: number;  // BPS
+  xBNBMintFee: number;     // BPS
+  xBNBRedeemFee: number;   // BPS
+  apUSDMintDisabled: boolean;
+}
+
+// Zone boundaries (in BPS)
+const ZONE_A_MIN = 17000n; // > 170%
+const ZONE_B_MIN = 13000n; // 130-170%
+const ZONE_C_MIN = 11000n; // 110-130%
+// Zone D: < 110%
+
+/**
+ * Fee tiers per zone as defined in risk framework
+ * 
+ * Zone A (>170%): Healthy - promote growth
+ * Zone B (130-170%): Normal - balanced fees
+ * Zone C (110-130%): Warning - encourage rebalancing
+ * Zone D (<110%): Critical - emergency measures
+ */
+const FEE_TIERS: FeeTier[] = [
+  // Zone A: >170%
+  {
+    minCR: ZONE_A_MIN,
+    apUSDMintFee: 0,      // 0% - promote minting
+    apUSDRedeemFee: 100,  // 1%
+    xBNBMintFee: 200,     // 2%
+    xBNBRedeemFee: 0,     // 0% - promote redemption
+    apUSDMintDisabled: false,
+  },
+  // Zone B: 130-170%
+  {
+    minCR: ZONE_B_MIN,
+    apUSDMintFee: 10,     // 0.1%
+    apUSDRedeemFee: 30,   // 0.3%
+    xBNBMintFee: 100,     // 1%
+    xBNBRedeemFee: 100,   // 1%
+    apUSDMintDisabled: false,
+  },
+  // Zone C: 110-130%
+  {
+    minCR: ZONE_C_MIN,
+    apUSDMintFee: 50,     // 0.5%
+    apUSDRedeemFee: 0,    // 0% - encourage redemption
+    xBNBMintFee: 50,      // 0.5% - promote minting
+    xBNBRedeemFee: 400,   // 4% - discourage redemption
+    apUSDMintDisabled: false,
+  },
+  // Zone D: <110%
+  {
+    minCR: 0n,
+    apUSDMintFee: 0,      // N/A - disabled
+    apUSDRedeemFee: 0,    // 0% - encourage redemption
+    xBNBMintFee: 0,       // 0% - encourage minting
+    xBNBRedeemFee: 800,   // 8% - lock xBNB
+    apUSDMintDisabled: true, // Disable minting in emergency
+  },
+];
+
+// ============ Fee Manager Service ============
+
+export class FeeManagerService {
+  private readonly client: AspanReadClient;
+  private readonly walletClient: ReturnType<typeof createWalletClient>;
+  private readonly slack: SlackService;
+  private readonly config: BotConfig;
+  private readonly feeConfig: FeeManagerConfig;
+  private readonly account: Account;
+
+  private intervalId?: ReturnType<typeof setInterval>;
+  private currentZone: string = "";
+  private readonly CHECK_INTERVAL_MS: number;
+
+  constructor(
+    client: AspanReadClient,
+    slack: SlackService,
+    botConfig: BotConfig,
+    feeConfig: FeeManagerConfig
+  ) {
+    this.client = client;
+    this.slack = slack;
+    this.config = botConfig;
+    this.feeConfig = feeConfig;
+
+    this.CHECK_INTERVAL_MS = feeConfig.checkIntervalMs ?? 60 * 1000; // 1 min
+
+    // Setup account and client
+    this.account = privateKeyToAccount(feeConfig.privateKey);
+    const chain = feeConfig.chain ?? bsc;
+
+    this.walletClient = createWalletClient({
+      chain,
+      transport: http(feeConfig.rpcUrl),
+      account: this.account,
+    });
+
+    console.log(`[FeeManager] Initialized with address: ${this.account.address}`);
+  }
+
+  // ============ Lifecycle ============
+
+  start(): void {
+    console.log("[FeeManager] Starting fee manager service...");
+    console.log(`[FeeManager] Check interval: ${this.CHECK_INTERVAL_MS / 1000}s`);
+
+    // Initial check
+    this.checkAndAdjustFees();
+
+    // Schedule regular checks
+    this.intervalId = setInterval(
+      () => this.checkAndAdjustFees(),
+      this.CHECK_INTERVAL_MS
+    );
+
+    console.log("[FeeManager] Service started");
+  }
+
+  stop(): void {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = undefined;
+    }
+    console.log("[FeeManager] Service stopped");
+  }
+
+  // ============ Core Logic ============
+
+  private async checkAndAdjustFees(): Promise<void> {
+    try {
+      // Get current CR
+      const sm = await withRetry(
+        () => this.client.getStabilityMode(),
+        this.config,
+        "getStabilityMode"
+      );
+
+      const cr = sm.currentCR;
+      const newZone = this.getZone(cr);
+
+      // Check if zone changed
+      if (newZone === this.currentZone) {
+        return; // No change needed
+      }
+
+      console.log(`[FeeManager] Zone change detected: ${this.currentZone || "initial"} -> ${newZone} (CR: ${cr})`);
+
+      // Get current on-chain fee tiers
+      const tierCount = await withRetry(
+        () => this.client.getFeeTierCount(),
+        this.config,
+        "getFeeTierCount"
+      );
+      const currentTiers = [];
+      for (let i = 0n; i < tierCount; i++) {
+        const tier = await withRetry(
+          () => this.client.getFeeTier(i),
+          this.config,
+          "getFeeTier"
+        );
+        currentTiers.push(tier);
+      }
+
+      // Check if update needed
+      if (this.tiersMatch(currentTiers)) {
+        console.log("[FeeManager] Fee tiers already match target, skipping update");
+        this.currentZone = newZone;
+        return;
+      }
+
+      // Update fee tiers
+      const txHash = await this.updateFeeTiers();
+      
+      // Notify
+      await this.notifyFeeUpdate(this.currentZone, newZone, cr, txHash);
+      
+      this.currentZone = newZone;
+    } catch (error) {
+      console.error("[FeeManager] Fee check/adjust failed:", error);
+    }
+  }
+
+  private getZone(cr: bigint): string {
+    if (cr >= ZONE_A_MIN) return "A";
+    if (cr >= ZONE_B_MIN) return "B";
+    if (cr >= ZONE_C_MIN) return "C";
+    return "D";
+  }
+
+  private tiersMatch(currentTiers: Array<{
+    minCR: bigint;
+    apUSDMintFee: number;
+    apUSDRedeemFee: number;
+    xBNBMintFee: number;
+    xBNBRedeemFee: number;
+    apUSDMintDisabled: boolean;
+  }>): boolean {
+    if (currentTiers.length !== FEE_TIERS.length) return false;
+
+    for (let i = 0; i < FEE_TIERS.length; i++) {
+      const target = FEE_TIERS[i];
+      const current = currentTiers[i];
+
+      if (
+        current.minCR !== target.minCR ||
+        current.apUSDMintFee !== target.apUSDMintFee ||
+        current.apUSDRedeemFee !== target.apUSDRedeemFee ||
+        current.xBNBMintFee !== target.xBNBMintFee ||
+        current.xBNBRedeemFee !== target.xBNBRedeemFee ||
+        current.apUSDMintDisabled !== target.apUSDMintDisabled
+      ) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  private async updateFeeTiers(): Promise<Hash> {
+    console.log("[FeeManager] Updating fee tiers...");
+
+    return this.walletClient.writeContract({
+      chain: bsc,
+      account: this.account,      address: this.feeConfig.diamondAddress,
+      abi: DiamondABI,
+      functionName: "setFeeTiers",
+      args: [FEE_TIERS],
+    });
+  }
+
+  // ============ Notifications ============
+
+  private async notifyFeeUpdate(
+    fromZone: string,
+    toZone: string,
+    cr: bigint,
+    txHash: Hash
+  ): Promise<void> {
+    const zoneColors: Record<string, string> = {
+      A: SlackColors.success,
+      B: SlackColors.info,
+      C: SlackColors.warning,
+      D: SlackColors.danger,
+    };
+
+    await this.slack.send({
+      attachments: [{
+        color: zoneColors[toZone] || SlackColors.info,
+        title: `:gear: Fee Tiers Updated: Zone ${fromZone || "?"} -> ${toZone}`,
+        text: "Fee tiers automatically adjusted based on CR",
+        fields: [
+          { title: "CR", value: `${Number(cr) / 100}%`, short: true },
+          { title: "Zone", value: toZone, short: true },
+          { title: "TX", value: `<https://bscscan.com/tx/${txHash}|View>`, short: true },
+        ],
+        ts: Math.floor(Date.now() / 1000),
+      }],
+    });
+  }
+}