Capital-Efficient Lending

Reduce collateral requirements based on creditworthiness while maintaining safety

Capital-efficient lending uses credit scores and reports to lower collateral requirements for qualified borrowers—while still remaining over-collateralized. This approach unlocks significant value for borrowers and lenders alike, serving as a practical stepping stone toward full under-collateralized lending.

The Problem with Fixed Collateral Ratios

Most DeFi lending protocols use fixed collateral requirements regardless of borrower creditworthiness:

Protocol	Typical Collateral Ratio	Borrowing Power
Aave	150-200%	Borrow $50-66 per$100 deposited
Compound	150-175%	Borrow $57-66 per$100 deposited
MakerDAO	150-170%	Borrow $58-66 per$100 deposited

The issue: A first-time DeFi user with no history receives the same terms as a veteran with years of successful repayments. This one-size-fits-all approach:

• Penalizes responsible borrowers
• Limits capital efficiency for qualified users
• Provides no incentive to build good credit behavior
• Leaves value on the table for lenders

---

The Solution: Risk-Adjusted Collateral

By integrating credit scoring, protocols can offer tiered collateral requirements that reward creditworthy borrowers while maintaining protocol safety:

Capital-Efficient Tiers (Over-Collateralized)

Tier	Min Score	Collateral	vs Standard (150%)	Identity Required
Excellent	920+	110%	-40 points	No
Very Good	840+	120%	-30 points	No
Good	750+	130%	-20 points	No
Fair	640+	140%	-10 points	No
Building	Below 640	150%	Standard	No

Even at reduced collateral ratios, loans remain over-collateralized (above 100%)—the protocol is always protected. The difference is that trusted borrowers aren’t unnecessarily penalized.

Ready for even better terms? Users with scores 750+ and verified identity may qualify for Under-Collateralized Lending with collateral below 100%.

---

Benefits

For Borrowers

Credit Tier	Standard Terms	With Credit Scoring	Improvement
Excellent	Borrow $66 per$100	Borrow $90 per$100	+36% capital efficiency
Very Good	Borrow $66 per$100	Borrow $80 per$100	+21% capital efficiency
Good	Borrow $66 per$100	Borrow $71 per$100	+8% capital efficiency

For Lenders & Protocols

• Increased utilization: Better terms attract more borrowing activity
• Competitive advantage: Differentiate from protocols with fixed ratios
• User retention: Borrowers stay where they’re rewarded for good behavior
• Maintained safety: All loans remain over-collateralized

---

Implementation

Basic Collateral Adjustment

async function getCollateralRequirement(borrowerAddress, asset) {
  // Fetch credit score
  const response = await fetch(
    `https://api.credprotocol.com/api/v2/score/address/${borrowerAddress}`,
    { headers: { 'Authorization': `Bearer ${API_KEY}` } }
  );

  const { score, range } = await response.json();

  // Base collateral ratio for the asset (e.g., 150% for ETH)
  const baseRatio = getAssetBaseRatio(asset);

  // Credit-based discount
  const discount = getCollateralDiscount(score);

  // Calculate adjusted ratio (never below safety minimum)
  const adjustedRatio = Math.max(
    baseRatio - discount,
    getMinimumSafeRatio(asset)
  );

  return {
    baseRatio,
    adjustedRatio,
    discount,
    creditScore: score,
    creditRange: range,
  };
}

function getCollateralDiscount(score) {
  // Discount in percentage points based on credit score
  if (score >= 920) return 0.40;  // 40 percentage points off (150% → 110%)
  if (score >= 840) return 0.30;  // 30 points off (150% → 120%)
  if (score >= 750) return 0.20;  // 20 points off (150% → 130%)
  if (score >= 640) return 0.10;  // 10 points off (150% → 140%)
  return 0;                        // No discount
}

function getMinimumSafeRatio(asset) {
  // Minimum collateral ratio regardless of credit score
  // Based on asset volatility
  const minimums = {
    'ETH': 1.10,
    'WBTC': 1.10,
    'stablecoins': 1.05,
    'default': 1.15,
  };
  return minimums[asset] || minimums.default;
}

Enhanced Risk Assessment

For more sophisticated implementations, incorporate the full credit report:

async function calculateRiskAdjustedTerms(borrowerAddress, loanRequest) {
  // Fetch comprehensive credit data
  const [scoreRes, reportRes] = 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, factors } = await scoreRes.json();
  const { report } = await reportRes.json();

  // Start with base collateral ratio
  let collateralRatio = 1.50;

  // Apply credit score adjustment
  collateralRatio -= getCollateralDiscount(score);

  // Additional adjustments based on report data

  // Reward strong repayment history
  if (report.summary.count_repayments >= 10 && report.summary.count_liquidations === 0) {
    collateralRatio -= 0.05;
  }

  // Reward identity verification
  if (report.summary.count_identity_attestations >= 2) {
    collateralRatio -= 0.05;
  }

  // Penalize recent liquidations
  if (report.summary.count_liquidations > 0) {
    collateralRatio += 0.10;
  }

  // Adjust for loan size relative to net worth
  const loanToNetWorth = loanRequest.amount / report.summary.net_worth_usd;
  if (loanToNetWorth > 0.5) {
    collateralRatio += 0.10;  // Higher ratio for large loans relative to net worth
  }

  // Ensure minimum safety
  collateralRatio = Math.max(collateralRatio, 1.10);

  return {
    collateralRatio,
    requiredCollateral: loanRequest.amount * collateralRatio,
    maxBorrow: loanRequest.collateralValue / collateralRatio,
    creditScore: score,
    factors: {
      repaymentBonus: report.summary.count_repayments >= 10,
      identityBonus: report.summary.count_identity_attestations >= 2,
      liquidationPenalty: report.summary.count_liquidations > 0,
      largeLoanPenalty: loanToNetWorth > 0.5,
    },
  };
}

---

User Experience

Displaying Terms to Borrowers

function renderBorrowingTerms(terms, baseTerms) {
  const improvement = ((baseTerms.maxBorrow - terms.maxBorrow) / baseTerms.maxBorrow * -100).toFixed(0);

  return {
    headline: terms.collateralRatio < baseTerms.collateralRatio
      ? `Your credit score qualifies you for better terms!`
      : `Build your credit history to unlock better rates`,

    comparison: {
      standard: {
        label: 'Standard Terms',
        collateralRatio: `${(baseTerms.collateralRatio * 100).toFixed(0)}%`,
        maxBorrow: formatCurrency(baseTerms.maxBorrow),
      },
      yours: {
        label: 'Your Terms',
        collateralRatio: `${(terms.collateralRatio * 100).toFixed(0)}%`,
        maxBorrow: formatCurrency(terms.maxBorrow),
        highlight: terms.collateralRatio < baseTerms.collateralRatio,
      },
    },

    improvement: terms.collateralRatio < baseTerms.collateralRatio
      ? `+${Math.abs(improvement)}% more borrowing power`
      : null,

    factors: terms.factors,
  };
}

Incentivizing Credit Building

Show users how improving their score translates to better terms:

function showImprovementPath(currentScore, currentRatio) {
  const tiers = [
    { minScore: 920, ratio: 1.10, label: 'Excellent' },
    { minScore: 840, ratio: 1.20, label: 'Very Good' },
    { minScore: 750, ratio: 1.30, label: 'Good' },
    { minScore: 640, ratio: 1.40, label: 'Fair' },
  ];

  const currentTier = tiers.find(t => currentScore >= t.minScore) || { label: 'Building' };
  const nextTier = tiers.find(t => t.minScore > currentScore);

  return {
    current: {
      tier: currentTier.label,
      ratio: currentRatio,
      score: currentScore,
    },
    next: nextTier ? {
      tier: nextTier.label,
      ratio: nextTier.ratio,
      scoreNeeded: nextTier.minScore,
      pointsAway: nextTier.minScore - currentScore,
      benefitDescription: `Unlock ${((currentRatio - nextTier.ratio) * 100).toFixed(0)}% lower collateral requirements`,
    } : null,
    tips: [
      'Make consistent loan repayments',
      'Maintain healthy collateral ratios',
      'Add identity attestations (ENS, Gitcoin Passport)',
      'Avoid liquidations',
    ],
  };
}

---

Safety Considerations

Capital-efficient lending must balance improved terms with protocol safety:

Maintain minimum collateral floors

Never reduce collateral below asset-specific minimums. Even the most creditworthy borrowers should maintain at least 105-110% collateral to account for rapid price movements.

Account for asset volatility

Apply different minimum ratios based on asset volatility. Stablecoins can have lower floors than volatile assets like ETH or WBTC.

Monitor positions actively

Reduced collateral means less buffer before liquidation. Implement robust monitoring and alert systems.

Cache scores appropriately

Credit scores are cached for 5 minutes. For collateral calculations, this is usually sufficient, but consider the trade-off between freshness and API costs.

Handle score unavailability gracefully

If the credit API is unavailable, fall back to standard collateral requirements rather than denying service.

Fallback Strategy

async function getCollateralRequirementWithFallback(borrowerAddress, asset) {
  try {
    const terms = await getCollateralRequirement(borrowerAddress, asset);
    return terms;
  } catch (error) {
    console.error('Credit score unavailable, using standard terms:', error);

    // Fall back to standard collateral requirements
    return {
      baseRatio: getAssetBaseRatio(asset),
      adjustedRatio: getAssetBaseRatio(asset),
      discount: 0,
      creditScore: null,
      creditRange: null,
      fallback: true,
    };
  }
}

---

The Path Forward

Capital-efficient lending is a stepping stone toward full under-collateralized lending:

1. Today: Fixed Over-Collateralization

   150%+ collateral for everyone, regardless of creditworthiness

2. Next: Risk-Adjusted Over-Collateralization

   110-150% collateral based on credit score—you are here

3. Future: Under-Collateralized Lending

   50-100% collateral for highly qualified borrowers with verified identity

4. Vision: Reputation-Based Lending

   Unsecured loans based on on-chain reputation and credit history

By implementing capital-efficient lending today, protocols can:

• Build infrastructure for credit-based risk assessment
• Establish user credit histories
• Create incentives for good financial behavior
• Prepare for the transition to under-collateralized products

---

Related

Under-Collateralized Lending

The next step: lending with less than 100% collateral

Qualifying Access

Gate access to lending products by credit tier

Get Credit Score

API reference for fetching credit scores

Get Credit Report

Detailed borrower financial profiles