Aggregator on Jeongseup Blog

Building a Leverage Position Preview for DeFi on Sui

Fri, 27 Feb 2026 00:00:00 +0000

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.

$$\text{LTV} = \frac{\text{Borrowed Value}}{\text{Collateral Value}}$$

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.

Protocol	SUI LTV	XBTC LTV
Suilend	70%	60%
Navi	75%	67%
Scallop	85%	75%

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:

$$\text{Max Multiplier} = \frac{1}{1 - \text{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:

Flash loan USDC from Scallop
Swap USDC → deposit asset (e.g., SUI)
Deposit all collateral to lending protocol
Borrow USDC from protocol (using deposited collateral)
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.

$$\text{Net APY} = \frac{\text{Total Position} \times \text{Supply APY} - \text{Debt} \times \text{Borrow APY}}{\text{Initial 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:

$$\text{Liquidation Price} = \frac{\text{Total Debt}}{\text{Total Collateral Amount} \times \text{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

Data	Source	Notes
Asset price	7k Protocol `getTokenPrice`	Real-time DEX aggregated price
LTV / LT	Protocol on-chain state	Suilend `RateLimiterConfig`, Navi `ReserveData`, Scallop `risk_models`
Supply/Borrow APY	Protocol SDK + on-chain query	Includes reward token APY
Flash loan fee	Scallop `FLASHLOAN_FEES_TABLE`	Currently 0% for USDC
Swap slippage	7k Protocol `quote()`	Real-time DEX routing

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

	Suilend	Navi	Scallop
Asset LTV	70%	75%	85%
Liq. Threshold	75%	70%	90%
Max Multiplier	3.33x	4.00x	6.67x
Liq. Price	$0.63	$0.68	$0.53
Price Drop Buffer	33%	29%	44%
Supply APY	2.89%	2.97%	2.98%
Borrow Net APY	3.45%	4.57%	5.80%
Net APY	2.33%	1.37%	0.15%

XBTC 2x Leverage

	Suilend	Navi	Scallop
Asset LTV	60%	67%	75%
Supply APY	3.78%	6.73%	0.00%
Net APY	4.10%	8.88%	-5.80%

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

DefiDash Technical Journal Day 1: 프로젝트 킥오프와 Sui 렌딩 생태계 분석

Fri, 27 Feb 2026 00:00:00 +0000

DefiDash 개발 과정을 기록하는 테크니컬 저널 시리즈. Day 1에서는 프로젝트의 동기와 목표, Sui 생태계의 렌딩 프로토콜 현황, 그리고 레버리지 렌딩 어그리게이터의 아키텍처 설계를 다룬다.

Team: curg-13

왜 DefiDash인가

DeFi 렌딩 시장은 이미 성숙해있다. Ethereum에는 Aave, Compound, MakerDAO가 있고, 다른 체인에도 포크된 프로토콜들이 넘쳐난다. 그런데 Sui 생태계는 다르다.

Sui는 Move 기반의 Object-centric 모델을 사용한다. EVM의 Account-based 모델과 근본적으로 다른 패러다임이다. 이 차이는 DeFi 프로토콜 설계에도 영향을 미친다:

Object Ownership: 자산이 계정이 아닌 오브젝트로 관리된다
Parallel Execution: 독립적인 오브젝트 간 트랜잭션은 병렬 실행 가능
PTB (Programmable Transaction Blocks): 하나의 트랜잭션에서 여러 DeFi 연산을 원자적으로 실행

특히 PTB는 레버리지 렌딩에 결정적이다. EVM에서는 Flash Loan으로 여러 트랜잭션을 하나로 묶지만, Sui에서는 PTB로 네이티브하게 복합 연산이 가능하다.

문제는 Sui의 렌딩 프로토콜들이 아직 파편화되어 있다는 것이다. 각 프로토콜마다 다른 인터페이스, 다른 이자율 모델, 다른 담보 비율. 일반 사용자가 최적의 레버리지 전략을 찾는 것은 사실상 불가능하다.

DefiDash는 이 문제를 해결한다. Sui 생태계의 렌딩 프로토콜들을 하나의 인터페이스로 어그리게이트하여, 사용자에게 최적의 레버리지 전략을 제공한다.

프로젝트 구조

curg-13 팀으로 3개의 레포지토리를 구성했다.

1
2
3
4


curg-13/
├── defidash-sdk # 핵심 SDK - 프로토콜 통합 레이어
├── defidash-frontend # 사용자 facing DApp
└── defidash-website # 랜딩 페이지 & 문서

defidash-sdk

프로토콜 어그리게이션의 핵심이다. 각 렌딩 프로토콜의 인터페이스를 추상화하고, 통합된 API를 제공한다.

주요 책임:

각 프로토콜의 온체인 데이터 조회 (이자율, 담보 비율, 유동성)
레버리지 포지션 시뮬레이션
PTB 구성 및 트랜잭션 빌딩
최적 경로 계산 (어떤 프로토콜 조합이 가장 유리한지)

defidash-frontend

일반 사용자를 위한 DApp이다. 복잡한 레버리지 전략을 직관적인 UI로 제공한다.

핵심 UX 목표:

원클릭 레버리지 포지션 오픈/클로즈
실시간 Health Factor 모니터링
프로토콜 간 이자율 비교 대시보드

defidash-website

프로젝트 소개와 문서를 담는 마케팅 사이트다.

Sui 렌딩 생태계 현황

현재 Sui에서 활동 중인 주요 렌딩 프로토콜들을 정리했다.

Protocol	Type	Key Feature
Scallop	Pool-based	Sui 최초의 렌딩 프로토콜, sCoin 모델
NAVI Protocol	Pool-based	Dynamic interest rate, Flash Loan 지원
Suilend	Pool-based	Solend 팀의 Sui 버전, Obligation 기반
Bucket Protocol	CDP-based	BUCK 스테이블코인 발행

EVM 생태계와 비교하면 아직 초기 단계지만, 각 프로토콜이 Sui의 특성을 살린 독자적인 설계를 가지고 있다. 이 차이점이 곧 어그리게이션의 가치다.

아키텍처 설계: 어그리게이션 레이어

레버리지 렌딩 어그리게이터의 핵심은 Protocol Adapter Pattern이다.

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


사용자 → DefiDash Frontend
 ↓
 DefiDash SDK
 ↓
 ┌─────────┼─────────┐
 ↓ ↓ ↓
 Scallop NAVI Suilend ← Protocol Adapters
 Adapter Adapter Adapter
 ↓ ↓ ↓
 └─────────┼─────────┘
 ↓
 Sui Network

각 프로토콜 Adapter는 동일한 인터페이스를 구현한다:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


interface LendingProtocolAdapter {
 // 프로토콜 상태 조회
 getMarkets(): Promise<Market[]>;
 getInterestRates(market: string): Promise<InterestRate>;
 getUserPosition(address: string): Promise<Position>;

 // 트랜잭션 빌딩
 buildSupplyTx(params: SupplyParams): TransactionBlock;
 buildBorrowTx(params: BorrowParams): TransactionBlock;
 buildLeverageTx(params: LeverageParams): TransactionBlock;
}

이 패턴의 장점은 새로운 프로토콜 추가가 Adapter 하나만 구현하면 된다는 것이다. SDK의 코어 로직이나 프론트엔드를 수정할 필요 없다.

레버리지 렌딩의 원리

일반 사용자를 위해 레버리지 렌딩이 어떻게 작동하는지 정리한다.

기본 개념

담보 예치: 1,000 USDC를 렌딩 프로토콜에 담보로 예치
대출: 담보 대비 700 SUI를 대출 (LTV 70%)
재예치: 대출받은 SUI를 다시 담보로 예치
반복: 이 과정을 반복하면 실효 레버리지가 증가

1
2
3
4
5
6


초기 자본: 1,000 USDC
1차 대출: 700 SUI → 재예치
2차 대출: 490 SUI → 재예치
3차 대출: 343 SUI → 재예치
...
실효 노출: ~3,333 USDC 상당 (약 3.3x 레버리지)

Sui PTB의 이점

EVM에서는 이 과정을 Flash Loan + 여러 컨트랙트 호출로 구현해야 한다. 가스비도 높고 실패 리스크도 있다.

Sui의 PTB에서는 하나의 트랜잭션 블록 안에서 모든 단계를 원자적으로 실행할 수 있다:

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


const txb = new TransactionBlock();

// 1. 담보 예치
const receipt = txb.moveCall({ target: `${PROTOCOL}::deposit`, arguments: [...] });

// 2. 대출
const borrowed = txb.moveCall({ target: `${PROTOCOL}::borrow`, arguments: [...] });

// 3. 재예치 (대출 결과를 바로 사용)
txb.moveCall({ target: `${PROTOCOL}::deposit`, arguments: [borrowed, ...] });

// 하나의 트랜잭션으로 실행
await client.signAndExecuteTransactionBlock({ transactionBlock: txb });

Flash Loan 없이도 원자적 레버리지가 가능하다. 이것이 Sui에서 렌딩 어그리게이터를 만드는 핵심 이유다.

Day 1 정리

항목	결정 사항
프로젝트명	DefiDash
팀	curg-13
타겟 체인	Sui
핵심 기술	PTB 기반 레버리지 렌딩 어그리게이션
SDK 언어	TypeScript
아키텍처	Protocol Adapter Pattern
첫 통합 대상	Scallop, NAVI, Suilend

Next: Day 2

다음 저널에서는 실제 SDK 개발을 시작한다.

Sui 렌딩 프로토콜 온체인 데이터 구조 분석
Protocol Adapter 구현 (Scallop부터)
PTB 기반 레버리지 트랜잭션 빌딩

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