Monitor Vaults, Stablecoins, and RWAs on a Cadence

const API_BASE = 'https://api.webacy.com';
const headers = { 'x-api-key': process.env.WEBACY_API_KEY! };

interface Position {
  type: 'vault' | 'rwa_token' | 'rwa_vault';
  address: string;
  chain: string;
}

async function fetchVaultGraded(address: string, chain: string) {
  const res = await fetch(`${API_BASE}/v3/vaults/${address}?chain=${chain}`, { headers });
  return res.json();
}

async function fetchVaultOps(address: string, chain: string) {
  const res = await fetch(`${API_BASE}/vaults/${address}?chain=${chain}`, { headers });
  return res.json();
}

async function fetchDepegDetail(address: string, chain: string, hours = 24) {
  const res = await fetch(`${API_BASE}/rwa/${address}?chain=${chain}&hours=${hours}`, { headers });
  return res.json();
}

async function fetchRwaVaultGraded(address: string, chain: string) {
  const res = await fetch(`${API_BASE}/v3/rwa/${address}?chain=${chain}`, { headers });
  return res.json();
}

const WORSE_GRADES = ['C', 'C-', 'D', 'F'];
const SCORE_DELTA_LIMIT = 15;
const TVL_FLIGHT_LIMIT = -0.1;

async function monitorBook(positions: Position[]) {
  const alerts: { position: Position; messages: string[] }[] = [];

  for (const position of positions) {
    const messages: string[] = [];

    if (position.type === 'vault') {
      const [graded, ops] = await Promise.all([
        fetchVaultGraded(position.address, position.chain),
        fetchVaultOps(position.address, position.chain),
      ]);

      // Fail-closed: stale or missing data is unknown risk, never safe
      if (ops.stale) {
        messages.push('Operational data is stale, treat as unknown risk');
      } else {
        if (WORSE_GRADES.includes(graded.composite.grade)) {
          messages.push(`Grade: ${graded.composite.grade} (score ${graded.composite.score}/100)`);
        }
        if (ops.metadata.tvl_flight_1w <= TVL_FLIGHT_LIMIT) {
          messages.push(`TVL flight (1w): ${ops.metadata.tvl_flight_1w}`);
        }
        if (ops.exit_recommendation || ops.attention_needed) {
          messages.push(`Curator flag, exit_recommendation: ${ops.exit_recommendation}, attention_needed: ${ops.attention_needed}`);
        }
      }
    }

    if (position.type === 'rwa_token') {
      const depeg = await fetchDepegDetail(position.address, position.chain);

      if (depeg.stale) {
        messages.push('Depeg data is stale, treat as unknown risk');
      } else {
        if (['watch', 'warning', 'critical'].includes(depeg.snapshot.tier)) {
          messages.push(`Depeg tier: ${depeg.snapshot.tier} (dev ${depeg.snapshot.dev_clean})`);
        }
        if (Math.abs(depeg.token.score_delta_24h) >= SCORE_DELTA_LIMIT) {
          messages.push(`24h score delta: ${depeg.token.score_delta_24h}`);
        }
      }
    }

    if (position.type === 'rwa_vault') {
      const rwaGraded = await fetchRwaVaultGraded(position.address, position.chain);
      if (WORSE_GRADES.includes(rwaGraded.composite.grade)) {
        messages.push(`RWA vault grade: ${rwaGraded.composite.grade} (score ${rwaGraded.composite.score}/100)`);
      }
    }

    if (messages.length > 0) {
      alerts.push({ position, messages });
    }
  }

  return alerts;
}

// Example: monitor an allocated book
const alerts = await monitorBook([
  { type: 'vault', address: '0x0deFfd509197aAD5207d2A55862835b467E8128F', chain: 'eth' },
  { type: 'rwa_token', address: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', chain: 'eth' },
  { type: 'rwa_token', address: '0xdAC17F958D2ee523a2206206994597C13D831ec7', chain: 'eth' },
]);

for (const { position, messages } of alerts) {
  console.log(`[ALERT] ${position.type} ${position.address} (${position.chain})`);
  messages.forEach((m) => console.log(`  - ${m}`));
}