Pricing Methodology

The pricing engine uses on-demand Monte Carlo simulation to compute risk-adjusted LTV and APR for each quote request.

Overview

The pricing engine answers three questions for every loan request:

1. How much can they borrow? - LTV and maximum loan amount

2. At what cost? - APR

3. What is the risk? - Probability of loss, expected PnL, VaR

Unlike pool-based protocols that use utilization curves or pre-calibrated LTV tables, the pricing engine simulates thousands of price paths for every quote. This provides position-specific pricing with transparent risk metrics.

Monte Carlo simulation

Price simulation model

Price paths are simulated using Geometric Brownian Motion with Student-t innovations:

S_{t+1} = S_t × exp(-σ²/2 × Δt + σ × √Δt × Z)

Where:

• S_t = price at time t

• σ = annualized volatility (with buffer applied)

• Δt = time step in years

• Z = Student-t random variable (df=5)

Student-t distribution with 5 degrees of freedom captures the fat tails observed empirically in crypto price movements. Normal distribution underestimates tail risk.

Simulation parameters

Parameter	Default	Description
n_paths	10,000	Number of simulated price paths
time_steps	100	Steps per path
volatility_buffer	1.1-1.2	Multiply observed volatility

The volatility buffer provides margin against volatility estimation error.

LTV optimization

Binary search

The engine finds the highest LTV satisfying policy constraints via binary search:

Iteration 1: LTV=57.5% → P(loss)=0.9% ✓
Iteration 2: LTV=68.8% → P(loss)=2.5% ✗
Iteration 3: LTV=63.1% → P(loss)=1.6% ✓
Iteration 4: LTV=65.9% → P(loss)=2.1% ✗
Iteration 5: LTV=64.5% → P(loss)=1.8% ✓

Best LTV: 64.5%

Each iteration runs the full Monte Carlo simulation at the candidate LTV and checks if policy constraints are satisfied.

Policy constraints

The search finds the highest LTV where:

1. P(loss) ≤ max_loss_probability (e.g., 2%)

2. E[PnL] ≥ -max_expected_shortfall (e.g., -30% of loan)

Liquidation modeling

Health factor

For each simulated path, the engine checks if the loan becomes undercollateralized:

Health Factor = Collateral Value / Loan Value
HF < 1.0 → Liquidation triggered

Liquidation delay

Liquidation does not execute instantly when triggered. The engine models the delay between trigger and execution:

Timeline:
─────────────────────────────────────────────────────►
     │                    │                      │
   Price                 HF < 1               Liquidation
   drops                (trigger)              executes
                         └────── DELAY ────────┘

During this delay, a 2-sigma adverse price shock is applied:

P_execution = P_trigger × (1 - 2σ√τ)

Where τ is the delay duration in years.

Slippage calculation

Slippage is calculated by walking through actual Uniswap V3 tick data:

def calculate_slippage(collateral_amount, current_price, tick_liquidity, stress_factor):
    remaining = collateral_amount
    total_received = 0
    current_tick = price_to_tick(current_price)

    while remaining > 0 and current_tick in tick_liquidity:
        tick_liq = tick_liquidity[current_tick] / stress_factor
        sellable = min(remaining, tick_liq)
        tick_price = tick_to_price(current_tick)

        total_received += sellable * tick_price
        remaining -= sellable
        current_tick -= 1  # Move to worse price

    fair_value = collateral_amount * current_price
    slippage = 1 - (total_received / fair_value)
    return slippage

The stress_factor (default: 2.0) accounts for liquidity evaporation during market stress.

Risk metrics

Every simulation produces:

Metric	Formula	Description
P(Loss)	count(loss) / n_paths	Probability of losing money
P(Profit)	1 - P(Loss)	Probability of making money
E[PnL]	mean(all_outcomes)	Expected profit/loss
E[Loss|Loss]	mean(losses)	Average loss when loss occurs
VaR 99%	percentile(outcomes, 1)	Worst 1% outcome

APR calculation

Mode A: Competitive pricing

When a reference money market exists (ETH, WBTC on Aave):

APR = max(floor, reference_rate × 0.95)

Where floor = funding_cost + risk_premium + margin

This ensures competitive rates while maintaining a minimum based on actual costs.

Mode B: Synthetic pricing

When no reference market exists (governance tokens, long-tail assets):

APR = Base Rate + Risk Premium + Liquidity Charge + Margin

Where:
  Base Rate      = Cost of capital (~4-5%)
  Risk Premium   = Black-Scholes put premium
  Liquidity Charge = Slippage cost amortized
  Margin         = Profit (~1-2%)

Black-Scholes risk premium

The risk premium represents the cost of insuring against collateral dropping below the liquidation price:

def bs_put_premium(S, K, sigma, T):
    """European put price (risk-free rate = 0)"""
    d1 = (log(S/K) + 0.5 * sigma**2 * T) / (sigma * sqrt(T))
    d2 = d1 - sigma * sqrt(T)
    return K * norm.cdf(-d2) - S * norm.cdf(-d1)

Inventory adjustment

APR increases when lending capital is scarce:

adjustment = 0.10 × utilization²

This can add up to 10% premium at full utilization.

Policy parameters

Parameter	Default	Description
max_loss_probability	0.02	Maximum acceptable P(loss)
max_expected_shortfall	0.30	Maximum E[Loss] as fraction of loan
liquidation_delay_seconds	24	Time between trigger and execution
volatility_buffer	1.1	Multiply observed volatility
liquidity_stress_factor	2.0	Divide tick liquidity by this

Data sources

The pricing engine requires current market data:

Data	Source	Update frequency
Spot prices	Uniswap V3	Real-time
Tick liquidity	Uniswap V3	Hourly
Realized volatility	Computed from prices	Hourly
Reference rates	Aave V3	Hourly

Data freshness affects quote accuracy. Stale data can result in mispriced risk.

Performance

Operation	Time
Market data fetch	~100ms
Monte Carlo (10k paths)	~500ms
LTV optimization (15 iterations)	~7s
Total quote time	~8 seconds

For OTC lending, this latency is acceptable. The tradeoff provides significantly better accuracy and transparency compared to static curves.