Frontend Applications

import { GearboxSDK } from '@gearbox-protocol/sdk';

const sdk = await GearboxSDK.attach({ client, marketConfigurators: [] });

// Find market by pool address
const market = sdk.marketRegister.findByPool(poolAddress);
const pool = market.pool;

// Display data
const RAY = 10n ** 27n;

console.log(`Underlying: ${pool.underlying.symbol}`);
console.log(`Total Supplied: ${pool.totalAssets}`);
console.log(`Available: ${pool.availableLiquidity}`);

// Calculate utilization
const borrowed = pool.totalAssets - pool.availableLiquidity;
const utilization = Number(borrowed * 10000n / pool.totalAssets) / 100;
console.log(`Utilization: ${utilization.toFixed(2)}%`);

// Convert RAY rates to percentages
const supplyAPY = Number(pool.supplyRate * 10000n / RAY) / 100;
const borrowAPR = Number(pool.baseInterestRate * 10000n / RAY) / 100;
console.log(`Supply APY: ${supplyAPY.toFixed(2)}%`);
console.log(`Borrow APR: ${borrowAPR.toFixed(2)}%`);

import {
  marketCompressorAbi,
  AP_MARKET_COMPRESSOR,
  VERSION_RANGE_310,
} from '@gearbox-protocol/sdk';

// Get compressor address
const [compressor] = sdk.addressProvider.mustGetLatest(
  AP_MARKET_COMPRESSOR,
  VERSION_RANGE_310
);

// Fetch market data with quota keeper
const marketData = await client.readContract({
  address: compressor,
  abi: marketCompressorAbi,
  functionName: 'getMarketData',
  args: [poolAddress],
});

// QuotaKeeper token data
for (const token of marketData.quotaKeeper.tokens) {
  const utilizationPct = Number(token.totalQuoted * 10000n / token.limit) / 100;

  console.log(`Token: ${token.token}`);
  console.log(`  Limit: ${token.limit}`);
  console.log(`  Quoted: ${token.totalQuoted}`);
  console.log(`  Utilization: ${utilizationPct.toFixed(2)}%`);
  console.log(`  Rate: ${token.rate}`); // RAY scaled
}

const market = sdk.marketRegister.findByCreditManager(cmAddress);

for (const cm of market.creditManagers) {
  console.log(`Credit Manager: ${cm.address}`);
  console.log(`Credit Facade: ${cm.creditFacade}`);

  // Debt limits
  console.log(`Min Debt: ${cm.minDebt}`);
  console.log(`Max Debt: ${cm.maxDebt}`);

  // Collateral configuration
  console.log('Allowed Collaterals:');
  for (const token of cm.collateralTokens) {
    // LT is in basis points (10000 = 100%)
    const ltPct = Number(token.liquidationThreshold) / 100;
    console.log(`  ${token.symbol}: LT ${ltPct.toFixed(1)}%`);
  }
}

import { createCreditAccountService } from '@gearbox-protocol/sdk';

const service = createCreditAccountService(sdk, 310);

// Get user's accounts
const accounts = await service.getCreditAccounts(
  {
    creditManager: cmAddress,
    owner: userAddress,
  },
  sdk.currentBlock
);

for (const account of accounts) {
  // Health factor: 10000 = 1.0
  const hf = Number(account.healthFactor) / 10000;

  console.log(`Account: ${account.addr}`);
  console.log(`Health Factor: ${hf.toFixed(4)}`);
  console.log(`Liquidatable: ${account.isLiquidatable}`);

  // Debt breakdown
  console.log(`Total Debt: ${account.debt}`);
  console.log(`Accrued Interest: ${account.cumulativeQuotaInterest}`);
  console.log(`Quota Fees: ${account.quotaFees}`);

  // Token positions
  console.log('Positions:');
  for (const token of account.tokens) {
    if (token.balance > 0n) {
      console.log(`  ${token.symbol}:`);
      console.log(`    Balance: ${token.balance}`);
      console.log(`    Value (underlying): ${token.balanceInUnderlying}`);
      console.log(`    LT: ${token.lt / 100}%`);
    }
  }
}

// Total debt = principal + base interest + quota interest + quota fees
const principal = account.borrowedAmount;
const quotaInterest = account.cumulativeQuotaInterest;
const quotaFees = account.quotaFees;
const baseInterest = account.debt - principal - quotaInterest - quotaFees;

function getHealthStatus(hf: number): string {
  if (hf < 1.0) return 'LIQUIDATABLE';
  if (hf < 1.05) return 'CRITICAL';
  if (hf < 1.1) return 'WARNING';
  return 'HEALTHY';
}

const status = getHealthStatus(Number(account.healthFactor) / 10000);

import {
  priceFeedCompressorAbi,
  AP_PRICE_FEED_COMPRESSOR,
  VERSION_RANGE_310,
} from '@gearbox-protocol/sdk';

// Get price feed compressor
const [priceFeedCompressor] = sdk.addressProvider.mustGetLatest(
  AP_PRICE_FEED_COMPRESSOR,
  VERSION_RANGE_310
);

// Get all price feeds for a price oracle
const feeds = await client.readContract({
  address: priceFeedCompressor,
  abi: priceFeedCompressorAbi,
  functionName: 'getUpdatablePriceFeeds',
  args: [priceOracleAddress],
});

for (const feed of feeds) {
  console.log(`Token: ${feed.token}`);
  console.log(`  Feed: ${feed.priceFeed}`);
  console.log(`  Needs Update: ${feed.needsUpdate}`);
}

// Before addCollateral: Check token is allowed
const isAllowed = market.creditManagers[0].collateralTokens
  .some(t => t.address === tokenAddress);

// Before increaseDebt: Check against max debt
const newDebt = account.debt + borrowAmount;
const isWithinLimit = newDebt <= cm.maxDebt;

// Before updateQuota: Check quota capacity
const quotaToken = marketData.quotaKeeper.tokens
  .find(t => t.token === tokenAddress);
const hasCapacity = quotaToken && quotaToken.totalQuoted < quotaToken.limit;

// Before any operation: Estimate health factor impact
// (Use simulation or calculate locally)

const POLL_INTERVAL = 5000; // 5 seconds

async function pollMarketData() {
  const marketData = await client.readContract({
    address: compressor,
    abi: marketCompressorAbi,
    functionName: 'getMarketData',
    args: [poolAddress],
  });

  // Update UI state
  setPoolData(marketData.pool);
  setQuotaData(marketData.quotaKeeper);
}

// Start polling
setInterval(pollMarketData, POLL_INTERVAL);

import { parseAbiItem } from 'viem';

// Watch for credit account state changes
const unwatch = client.watchContractEvent({
  address: creditManagerAddress,
  abi: creditManagerAbi,
  eventName: 'ExecuteOrder',
  onLogs: (logs) => {
    // Refresh account data for affected accounts
    for (const log of logs) {
      refreshAccountData(log.args.creditAccount);
    }
  },
});

// Cleanup on unmount
return () => unwatch();

import { GearboxSDK, createCreditAccountService, marketCompressorAbi } from '@gearbox-protocol/sdk';
import { createPublicClient, http } from 'viem';
import { mainnet } from 'viem/chains';

interface DashboardData {
  pool: {
    underlying: string;
    totalAssets: bigint;
    availableLiquidity: bigint;
    supplyAPY: number;
    borrowAPR: number;
  };
  userAccounts: Array<{
    address: string;
    healthFactor: number;
    debt: bigint;
    isLiquidatable: boolean;
  }>;
}

async function fetchDashboardData(
  poolAddress: `0x${string}`,
  cmAddress: `0x${string}`,
  userAddress: `0x${string}`
): Promise<DashboardData> {
  const client = createPublicClient({
    chain: mainnet,
    transport: http(),
  });

  const sdk = await GearboxSDK.attach({
    client,
    marketConfigurators: [],
  });

  const RAY = 10n ** 27n;

  // Pool data
  const market = sdk.marketRegister.findByPool(poolAddress);
  const pool = market.pool;

  // User accounts
  const service = createCreditAccountService(sdk, 310);
  const accounts = await service.getCreditAccounts(
    { creditManager: cmAddress, owner: userAddress },
    sdk.currentBlock
  );

  return {
    pool: {
      underlying: pool.underlying.symbol,
      totalAssets: pool.totalAssets,
      availableLiquidity: pool.availableLiquidity,
      supplyAPY: Number(pool.supplyRate * 10000n / RAY) / 100,
      borrowAPR: Number(pool.baseInterestRate * 10000n / RAY) / 100,
    },
    userAccounts: accounts.map(a => ({
      address: a.addr,
      healthFactor: Number(a.healthFactor) / 10000,
      debt: a.debt,
      isLiquidatable: a.isLiquidatable,
    })),
  };
}