Monitoring

const reserve = await program.account.reserve.fetch(reservePubkey);
const totalSupply = reserve.liquidity.totalSupply; // Available + borrowed - fees
const borrowed = reserve.liquidity.borrowedAmountSf;
const utilizationRate = borrowed / totalSupply;

const totalDeposits = reserve.liquidity.totalAvailableAmount;
const totalBorrowed = Fraction.fromBits(reserve.liquidity.borrowedAmountSf);

console.log(`Deposits: ${totalDeposits}`);
console.log(`Borrowed: ${totalBorrowed.toString()}`);

const utilizationRate = reserve.liquidity.utilizationRate();
const borrowRate = reserve.config.borrowRateCurve.getBorrowRate(utilizationRate);

console.log(`Current APR: ${borrowRate * 100}%`);

// Total available for borrowing/withdrawals
const totalAvailable = reserve.liquidity.totalAvailableAmount;

// Available excluding queued withdrawals
const freelyAvailable = reserve.freelyAvailableLiquidityAmount();

console.log(`Total available: ${totalAvailable}`);
console.log(`Freely available: ${freelyAvailable}`);

const protocolFees = Fraction.fromBits(
  reserve.liquidity.accumulatedProtocolFeesSf
);
const redeemableAmount = reserve.calculateRedeemFees();

console.log(`Accumulated fees: ${protocolFees.toString()}`);
console.log(`Redeemable now: ${redeemableAmount}`);

// Fetch all obligations for a market
const obligations = await program.account.obligation.all([
  {
    memcmp: {
      offset: 8 + 8, // Skip discriminator and version
      bytes: lendingMarket.toBase58(),
    },
  },
]);

// Calculate health for each
for (const obligation of obligations) {
  const health = calculateObligationHealth(obligation);
  
  if (health.ltv > health.liquidationThreshold) {
    console.log(`Unhealthy obligation: ${obligation.publicKey}`);
    console.log(`LTV: ${health.ltv}%, Threshold: ${health.liquidationThreshold}%`);
  }
}

let totalBorrowedValue = 0;

for (const obligation of obligations) {
  for (const borrow of obligation.borrows) {
    const reserve = await program.account.reserve.fetch(borrow.borrowReserve);
    const price = Fraction.fromBits(reserve.liquidity.marketPriceSf);
    const amount = Fraction.fromBits(borrow.borrowedAmountSf);
    
    totalBorrowedValue += (amount * price).toNumber();
  }
}

console.log(`Total borrowed: $${totalBorrowedValue}`);

const market = await program.account.lendingMarket.fetch(marketPubkey);
const globalLimit = market.globalAllowedBorrowValue;
const currentBorrowed = calculateTotalBorrowedValue(); // From above

const utilizationPct = (currentBorrowed / globalLimit) * 100;

console.log(`Global limit utilization: ${utilizationPct}%`);

const isEmergency = market.emergencyMode !== 0;
const isBorrowDisabled = market.borrowDisabled !== 0;

console.log(`Emergency mode: ${isEmergency}`);
console.log(`Borrowing disabled: ${isBorrowDisabled}`);

await program.methods
  .refreshReserve()
  .accounts({
    reserve: reservePubkey,
    lendingMarket: marketPubkey,
    pythOracle: pythPriceAccount,
    switchboardPriceOracle: null,
    switchboardTwapOracle: null,
    scopePrices: scopePriceAccount,
  })
  .rpc();

// Collect all reserve accounts for deposits and borrows
const depositReserves = obligation.deposits.map(d => d.depositReserve);
const borrowReserves = obligation.borrows.map(b => b.borrowReserve);

// Optional: referrer token states if obligation has referrer
const referrerStates = obligation.hasReferrer 
  ? obligation.borrows.map(b => getReferrerStateForReserve(b.borrowReserve))
  : [];

await program.methods
  .refreshObligation()
  .accounts({
    lendingMarket: marketPubkey,
    obligation: obligationPubkey,
  })
  .remainingAccounts([
    ...depositReserves.map(pk => ({ pubkey: pk, isSigner: false, isWritable: false })),
    ...borrowReserves.map(pk => ({ pubkey: pk, isSigner: false, isWritable: false })),
    ...referrerStates.map(pk => ({ pubkey: pk, isSigner: false, isWritable: false })),
  ])
  .rpc();

await program.methods
  .refreshReservesBatch()
  .accounts({ lendingMarket: marketPubkey })
  .remainingAccounts([
    { pubkey: reserve1, isSigner: false, isWritable: true },
    { pubkey: reserve1PriceOracle, isSigner: false, isWritable: false },
    { pubkey: reserve2, isSigner: false, isWritable: true },
    { pubkey: reserve2PriceOracle, isSigner: false, isWritable: false },
    // ... more reserves
  ])
  .rpc();

const reserve = await program.account.reserve.fetch(reservePubkey);
const priceAge = currentTimestamp - reserve.liquidity.marketPriceLastUpdatedTs;
const maxAge = reserve.config.tokenInfo.maxAge; // In seconds

if (priceAge > maxAge) {
  console.warn(`Price is stale! Age: ${priceAge}s, Max: ${maxAge}s`);
}

const pythPrice = await getPythPrice(reserve.config.tokenInfo.pythPrice);
const scopePrice = await getScopePrice(reserve.config.tokenInfo.scopePriceFeed);

const divergence = Math.abs(pythPrice - scopePrice) / pythPrice;
const maxDivergence = reserve.config.tokenInfo.maxTwapDivergenceBps / 10000;

if (divergence > maxDivergence) {
  console.error(`Price divergence detected: ${divergence * 100}%`);
}

try {
  await program.methods.refreshReserve().rpc();
} catch (error) {
  if (error.message.includes('InvalidOracleConfig')) {
    console.error('Oracle configuration invalid');
    // Alert admin
  } else if (error.message.includes('StalePrice')) {
    console.error('Price too old');
    // Try to refresh price feed
  }
}

const connection = new Connection(rpcUrl);

// Get single account
const accountInfo = await connection.getAccountInfo(reservePubkey);
const reserve = program.coder.accounts.decode('Reserve', accountInfo.data);

// Get multiple accounts
const reserves = await program.account.reserve.all();

// Get filtered accounts
const marketReserves = await program.account.reserve.all([
  {
    memcmp: {
      offset: 8 + 8 + 8 + 16, // Skip to lendingMarket field
      bytes: lendingMarket.toBase58(),
    },
  },
]);

// More efficient for large-scale queries
const accounts = await connection.getProgramAccounts(
  program.programId,
  {
    filters: [
      { dataSize: RESERVE_SIZE },
      {
        memcmp: {
          offset: 8 + 8 + 8 + 16,
          bytes: lendingMarket.toBase58(),
        },
      },
    ],
  }
);

const subscriptionId = connection.onAccountChange(
  reservePubkey,
  (accountInfo) => {
    const reserve = program.coder.accounts.decode('Reserve', accountInfo.data);
    console.log('Reserve updated:', reserve);
    
    // Check metrics and alert
    checkReserveHealth(reserve);
  },
  'confirmed'
);

// Later: unsubscribe
connection.removeAccountChangeListener(subscriptionId);