Under-Collateralized Lending

async function assessLoanRisk(borrowerAddress, requestedAmount) {
  // Get comprehensive credit data
  const [scoreResponse, reportResponse] = await Promise.all([
    fetch(`https://api.credprotocol.com/api/v2/score/address/${borrowerAddress}?include_factors=true`, {
      headers: { 'Authorization': `Bearer ${API_KEY}` }
    }),
    fetch(`https://api.credprotocol.com/api/v2/report/address/${borrowerAddress}`, {
      headers: { 'Authorization': `Bearer ${API_KEY}` }
    })
  ]);

  const { score, range, factors } = await scoreResponse.json();
  const { report } = await reportResponse.json();

  // Assess borrower profile
  const riskAssessment = {
    creditScore: score,
    creditRange: range,

    // Historical behavior
    hasLiquidations: report.summary.count_liquidations > 0,
    hasDefaults: report.summary.count_defaults > 0,
    repaymentCount: report.summary.count_repayments,

    // Financial position
    netWorth: report.summary.net_worth_usd,
    totalAssets: report.summary.total_asset_usd,
    currentDebt: report.summary.total_debt_usd,

    // Identity verification
    identityAttestations: report.summary.list_identity_attestations,
    isVerified: report.summary.count_identity_attestations > 0,

    // Calculate risk metrics
    debtToAssetRatio: report.summary.total_debt_usd / report.summary.total_asset_usd,
    requestedToNetWorth: requestedAmount / report.summary.net_worth_usd,
  };

  return riskAssessment;
}

function calculateCollateralRequirement(score, loanAmount, riskAssessment) {
  // Base collateral ratios by credit tier (under-collateralized product)
  // Note: Only excellent/very_good tiers qualify for under-collateralized loans
  const baseRatios = {
    excellent: 0.50,   // 50% collateral (2x leverage)
    very_good: 0.75,   // 75% collateral (1.33x leverage)
    good: 0.90,        // 90% collateral (1.1x leverage) - barely under-collateralized
    fair: null,        // Not eligible for under-collateralized
    low: null,         // Not eligible for under-collateralized
  };

  // Check eligibility
  if (!baseRatios[riskAssessment.creditRange]) {
    return {
      eligible: false,
      reason: 'Credit score too low for under-collateralized lending',
      suggestion: 'See Capital-Efficient Lending for over-collateralized options with reduced requirements',
      alternativeProduct: 'capital-efficient',
    };
  }

  // Identity verification required for under-collateralized loans
  if (!riskAssessment.isVerified) {
    return {
      eligible: false,
      reason: 'Identity verification required for under-collateralized loans',
      suggestion: 'Add ENS, Gitcoin Passport, or other identity attestations',
    };
  }

  let collateralRatio = baseRatios[riskAssessment.creditRange];

  // Adjust for risk factors
  if (riskAssessment.hasLiquidations) collateralRatio += 0.15;
  if (riskAssessment.hasDefaults) return { eligible: false, reason: 'Previous defaults disqualify from under-collateralized lending' };

  // Adjust for loan size relative to net worth
  if (riskAssessment.requestedToNetWorth > 0.5) collateralRatio += 0.10;

  // Reward strong repayment history
  if (riskAssessment.repaymentCount >= 10) collateralRatio -= 0.05;

  // Ensure minimum collateral (never below 30%)
  collateralRatio = Math.max(0.30, collateralRatio);

  return {
    eligible: true,
    ratio: collateralRatio,
    requiredCollateral: loanAmount * collateralRatio,
    leverage: 1 / collateralRatio,
  };
}

function determineLoanEligibility(riskAssessment) {
  const { creditScore, netWorth, isVerified, hasDefaults } = riskAssessment;

  // Disqualifying factors for under-collateralized lending
  if (hasDefaults) {
    return {
      eligible: false,
      reason: 'Previous defaults disqualify from under-collateralized lending',
      suggestion: 'Build positive repayment history, then try Capital-Efficient Lending first',
      alternativeProduct: 'capital-efficient',
    };
  }

  if (!isVerified) {
    return {
      eligible: false,
      reason: 'Identity verification required for under-collateralized loans',
      suggestion: 'Add ENS, Gitcoin Passport, or other identity attestations',
    };
  }

  // Under-collateralized tier definitions (all require identity verification)
  const tiers = [
    {
      name: 'Excellent',
      minScore: 920,
      maxLoanToNetWorth: 2.0,    // Can borrow 2x net worth
      collateralRatio: 0.50,     // 50% collateral
      leverage: 2.0,
      features: ['Lowest collateral', 'Highest limits', 'Best rates'],
    },
    {
      name: 'Very Good',
      minScore: 840,
      maxLoanToNetWorth: 1.5,
      collateralRatio: 0.75,     // 75% collateral
      leverage: 1.33,
      features: ['Low collateral', 'High limits', 'Competitive rates'],
    },
    {
      name: 'Good',
      minScore: 750,
      maxLoanToNetWorth: 1.2,
      collateralRatio: 0.90,     // 90% collateral
      leverage: 1.1,
      features: ['Reduced collateral', 'Standard limits'],
    },
  ];

  // Find eligible tier
  for (const tier of tiers) {
    if (creditScore >= tier.minScore) {
      return {
        eligible: true,
        product: 'under-collateralized',
        tier: tier.name,
        maxLoan: netWorth * tier.maxLoanToNetWorth,
        collateralRatio: tier.collateralRatio,
        leverage: tier.leverage,
        features: tier.features,
      };
    }
  }

  // Not eligible for under-collateralized, suggest alternative
  return {
    eligible: false,
    reason: 'Credit score below 750 required for under-collateralized lending',
    suggestion: 'Try Capital-Efficient Lending for better terms than standard DeFi',
    alternativeProduct: 'capital-efficient',
    currentScore: creditScore,
    requiredScore: 750,
  };
}

async function monitorLoanHealth(loanId) {
  const loan = await getLoan(loanId);
  const currentScore = await getCredScore(loan.borrower);
  const currentReport = await getCredReport(loan.borrower);

  const healthMetrics = {
    // Score degradation
    scoreChange: currentScore.score - loan.originalScore,
    scoreDegraded: currentScore.score < loan.originalScore - 50,

    // Position health
    currentCollateralRatio: loan.collateralValue / loan.outstandingAmount,
    belowMinimum: loan.collateralValue / loan.outstandingAmount < loan.requiredRatio,

    // Borrower financial health
    netWorthChange: currentReport.summary.net_worth_usd - loan.originalNetWorth,
    debtIncreased: currentReport.summary.total_debt_usd > loan.originalDebt * 1.5,
  };

  // Trigger alerts or actions
  if (healthMetrics.scoreDegraded || healthMetrics.belowMinimum) {
    await triggerMarginCall(loanId, healthMetrics);
  }

  return healthMetrics;
}