How I built previewLeverage — a read-only preview engine that calculates leveraged lending position metrics across Suilend, Navi, and Scallop, without executing any on-chain transaction.

Team: curg-13 | SDK: defidash-sdk

Why Preview Before Leverage?

In DeFi lending, leverage means borrowing against your collateral to amplify your position. A 2x leverage on $100 of SUI gives you $200 total exposure — potentially doubling your returns, but also your risk.

Before users click “Confirm”, they need to know:

• How much will be borrowed via flash loan?
• What’s the liquidation price?
• What’s the expected annual return (Net APY)?
• How far can the price drop before liquidation?

That’s what previewLeverage computes — entirely off-chain, using real-time protocol data.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

const preview = await sdk.previewLeverage({
  protocol: LendingProtocol.Suilend,
  depositAsset: 'SUI',
  depositValueUsd: 100,
  multiplier: 2.0,
});

// preview.netApy          → 2.33%
// preview.liquidationPrice → $0.63
// preview.priceDropBuffer  → 33%

Glossary: Lending Protocol Concepts

If you’re a developer without DeFi background, here’s what you need to know. I’m also studying these concepts in depth — check the Lending Protocol Study series for worked examples:

• Day 1: DeFi 렌딩의 핵심 개념과 아키텍처 — Pool-based 중개, Share-Based Accounting, Scaled Balance 패턴
• Day 2: Compound V2 Deep Dive와 Aave V3 아키텍처 — Fresh 패턴, Mantissa 연산, 비트맵 스토리지 최적화

LTV (Loan-to-Value)

LTV is the maximum percentage of your collateral’s value that you can borrow.

If SUI has a 70% LTV on Suilend, depositing $100 of SUI lets you borrow up to $70 of USDC. Each protocol sets different LTV ratios per asset — riskier assets get lower LTV.

For more details on how Health Factor works with LTV, see Lending Protocol Study Day 1 — the “Share-Based Accounting” section explains why each protocol tracks collateral differently.

Liquidation Threshold (LT)

Liquidation Threshold is the LTV level at which your position gets liquidated. It’s always higher than the borrow LTV, creating a safety buffer.

1
2
3

Borrow LTV: 70%  →  You can borrow up to 70%
Liq. Threshold: 75%  →  Liquidation triggers at 75%
Safety buffer: 5%

When the market price drops and your position’s actual LTV exceeds the liquidation threshold, a liquidator can repay part of your debt and claim your collateral at a discount.

Liquidation mechanics are a deep topic — the Lending Protocol Study series covers Compound V2’s liquidateBorrowFresh() and Aave V3’s architecture in detail.

Max Multiplier

Derived directly from LTV:

With 70% LTV → max 3.33x leverage. With 85% LTV → max 6.67x. This is a hard protocol limit — you physically cannot borrow more than what the collateral factor allows.

Flash Loan

A flash loan is an uncollateralized loan that must be borrowed and repaid within a single atomic transaction. If you don’t repay, the entire transaction reverts as if it never happened.

In our leverage strategy, the flow is:

1. Flash loan USDC from Scallop
2. Swap USDC → deposit asset (e.g., SUI)
3. Deposit all collateral to lending protocol
4. Borrow USDC from protocol (using deposited collateral)
5. Repay flash loan

All 5 steps happen in one Sui Programmable Transaction Block (PTB). If step 5 fails, everything reverts.

For more on why Sui’s PTB model is ideal for this — see DefiDash Journal Day 1 where we compare PTB-based atomic leverage vs EVM Flash Loan patterns.

Supply APY & Borrow APY

• Supply APY: What you earn by depositing assets. Composed of base interest + reward tokens (e.g., sSUI, DEEP).
• Borrow APY: What you pay for borrowing. Some protocols give borrowing incentives (rebates).
• Net APY: The leveraged return on your equity.

With 2x leverage: if supply APY > borrow APY, your returns are amplified. If not, you’re paying more than you earn (negative Net APY).

The interest rate models behind these APYs (JumpRateModel, utilization curves) are covered in Lending Protocol Study Day 1 and Day 2. Especially the Mantissa-based fixed-point arithmetic in Day 2 is directly relevant to how we parse on-chain rate data.

Liquidation Price

The asset price at which your position hits the liquidation threshold:

For a $100 SUI position at 2x leverage on Suilend (LT = 75%):

• Debt = $100, Total collateral = ~52.6 SUI (at $3.80)
• Liquidation Price = $100 / (52.6 × 0.75) ≈ $2.53
• That’s a ~33% price drop buffer from current price

How It’s Built

Architecture

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

previewLeverage(params)
  │
  ├─ 1. Resolve coin type ('SUI' → '0x2::sui::SUI')
  ├─ 2. Fetch risk params from protocol adapter
  │     └─ getAssetRiskParams(coinType) → { ltv, liquidationThreshold, maxMultiplier }
  ├─ 3. Validate multiplier ≤ maxMultiplier
  ├─ 4. Fetch current price from 7k Protocol aggregator
  │
  ├─ 5. Position calculation
  │     ├─ flashLoanUsdc = equity × (multiplier − 1) × 1.02 buffer
  │     ├─ totalPositionUsd = equity × multiplier
  │     └─ ltvPercent = debt / totalPosition × 100
  │
  ├─ 6. Liquidation calculation
  │     ├─ liquidationPrice = debt / (collateralAmount × LT)
  │     └─ priceDropBuffer = (1 − liqPrice / currentPrice) × 100
  │
  ├─ 7. APY calculation
  │     ├─ Supply APY: base + reward (per protocol adapter)
  │     ├─ Borrow APY: gross − rebate (per protocol adapter)
  │     └─ Net APY = (position × supplyAPY − debt × borrowAPY) / equity
  │
  └─ 8. Swap slippage estimation via 7k DEX aggregator quote

Multi-Protocol Adapter Pattern

Each lending protocol (Suilend, Navi, Scallop) implements the ILendingProtocol interface, and the preview engine queries them through a unified API:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

interface ILendingProtocol {
  getAssetRiskParams(coinType: string): Promise<{
    ltv: number;
    liquidationThreshold: number;
    maxMultiplier: number;
  }>;
  getAssetApy(coinType: string): Promise<{
    supplyApy: number;
    rewardApy: number;
    borrowApy: number;
  }>;
  // ... deposit, borrow, withdraw, etc.
}

The same previewLeverage call works across all three protocols — just change the protocol parameter:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// Compare leverage across protocols
for (const protocol of ['suilend', 'navi', 'scallop']) {
  const preview = await sdk.previewLeverage({
    protocol,
    depositAsset: 'SUI',
    depositValueUsd: 100,
    multiplier: 2.0,
  });
  console.log(`${protocol}: Net APY ${(preview.netApy * 100).toFixed(2)}%`);
}

This adapter pattern follows the same principle as Aave V3’s modular architecture — separation of concerns with a thin routing layer. The Day 2 study covers how Aave V3 uses delegatecall + Library pattern to achieve a similar pluggable design.

Data Sources

Challenges & Bugs Fixed

Reward APY showing 3700% instead of 1.46%

Suilend stores reward coin types without the 0x prefix internally (e.g., deeb7a4...::deep::DEEP). When we passed this to the 7k price API, it returned 0. The fallback code then used the deposit asset’s price ($67,987 for LBTC) as a proxy for the reward token (DEEP at $0.027), inflating the reward APY to 3700%.

Fix: normalize the coin type with 0x prefix before price lookup, and skip the reward if price is still unavailable.

1
2
3
4
5
6
7
8

// Before (broken)
const rewardPrice = await getTokenPrice(rewardCoinType); // returns 0
// Fallback: uses LBTC price → 3700% APY

// After (fixed)
const normalizedReward = normalizeCoinType(rewardCoinType);
const fetchedPrice = await getTokenPrice(normalizedReward);
if (fetchedPrice <= 0) continue; // skip this reward

Scallop risk params not accessible via SDK

Scallop’s TypeScript SDK doesn’t expose risk_models data. We had to query the on-chain risk_models dynamic fields directly using suiClient.getDynamicFieldObject() to extract LTV and liquidation threshold values.

Verified Results (2026-02-26, Mainnet)

SUI 2x Leverage

XBTC 2x Leverage

The negative Net APY on Scallop XBTC means borrowing costs exceed supply earnings — leverage actually loses money in that case.

What’s Next

• leverage() — Actually execute the leveraged position on-chain
• deleverage() — Close/reduce a leveraged position (flash loan → repay debt → withdraw → swap → repay)
• previewDeleverage() — Preview the unwinding process
• Cross-protocol position comparison dashboard

Links

• DefiDash SDK Repository
• Lending Protocol Study Day 1 — Core lending concepts (LTV, Health Factor, Share-Based Accounting)
• Lending Protocol Study Day 2 — Compound V2 internals, Aave V3 architecture
• Sui PTB Documentation — Programmable Transaction Blocks
• Suilend | Navi Protocol | Scallop — The three protocols supported

DefiDash의 전체 코드는 curg-13 조직에서 확인할 수 있다.