Price Impact
Calculate and manage price impact for swaps in CLMM pools.
Quick Start
// Calculate price impact before swap
const pool = await sdk.Pool.getPool(poolId)
const ticks = await sdk.Pool.fetchTicks({
pool_id: poolId,
coinTypeA: pool.coinTypeA,
coinTypeB: pool.coinTypeB
})
const result = sdk.Swap.calculateRates({
currentPool: pool,
coinTypeA: pool.coinTypeA,
coinTypeB: pool.coinTypeB,
decimalsA: 9,
decimalsB: 6,
a2b: true,
byAmountIn: true,
amount: new BN('1000000000'), // 1 SUI
swapTicks: ticks
})
console.log(`Price Impact: ${result.priceImpactPct.toFixed(2)}%`)Understanding Price Impact
Price impact occurs when your trade moves the pool price:
Small trades: Minimal impact (<0.1%)
Medium trades: Noticeable impact (0.1-1%)
Large trades: Significant impact (>1%)
Calculate Methods
Method 1: Local Calculation
async function calculatePriceImpact(
poolId: string,
amount: string,
a2b: boolean,
byAmountIn: boolean
) {
// 1. Get pool and ticks
const pool = await sdk.Pool.getPool(poolId)
const ticks = await sdk.Pool.fetchTicks({
pool_id: poolId,
coinTypeA: pool.coinTypeA,
coinTypeB: pool.coinTypeB
})
// 2. Calculate swap result
const result = sdk.Swap.calculateRates({
currentPool: pool,
coinTypeA: pool.coinTypeA,
coinTypeB: pool.coinTypeB,
decimalsA: 9,
decimalsB: 6,
a2b,
byAmountIn,
amount: new BN(amount),
swapTicks: ticks
})
return {
priceImpact: result.priceImpactPct,
currentPrice: TickMath.sqrtPriceX64ToPrice(
pool.current_sqrt_price, 9, 6
),
endPrice: TickMath.sqrtPriceX64ToPrice(
result.estimatedEndSqrtPrice, 9, 6
),
isExceed: result.isExceed
}
}Method 2: From PreSwap
async function getImpactFromPreSwap(
pool: Pool,
amount: string,
a2b: boolean
) {
// Get current price
const currentPrice = TickMath.sqrtPriceX64ToPrice(
pool.current_sqrt_price,
9, 6
)
// Simulate swap
const preSwap = await sdk.Swap.preswap({
pool,
coinTypeA: pool.coinTypeA,
coinTypeB: pool.coinTypeB,
decimalsA: 9,
decimalsB: 6,
a2b,
byAmountIn: true,
amount,
currentSqrtPrice: pool.current_sqrt_price
})
// Calculate end price
const endPrice = TickMath.sqrtPriceX64ToPrice(
new BN(preSwap.estimatedEndSqrtPrice),
9, 6
)
// Price impact = |endPrice - currentPrice| / currentPrice * 100
const impact = Math.abs(
endPrice.minus(currentPrice).div(currentPrice).mul(100).toNumber()
)
return {
impact,
currentPrice: currentPrice.toNumber(),
endPrice: endPrice.toNumber()
}
}Router Price Impact
Calculate impact across multiple pools:
async function calculateRouterImpact(splitPaths: SplitPath[]) {
// Use SDK's built-in method
const totalImpact = sdk.Swap.calculateSwapPriceImpact(splitPaths)
console.log(`Total route impact: ${totalImpact}%`)
// Or calculate manually for each path
let weightedImpact = 0
splitPaths.forEach(path => {
const pathWeight = path.percent / 100
let pathImpact = 0
if (path.basePaths.length === 1) {
// Single hop
const exchangeRate = path.outputAmount / path.inputAmount
const marketPrice = path.basePaths[0].currentPrice
pathImpact = calculateSingleImpact(exchangeRate, marketPrice)
} else {
// Multi-hop
const totalExchangeRate = path.outputAmount / path.inputAmount
const marketPrice = path.basePaths.reduce(
(acc, bp) => acc.mul(bp.currentPrice),
new Decimal(1)
)
pathImpact = calculateSingleImpact(totalExchangeRate, marketPrice)
}
weightedImpact += pathImpact * pathWeight
})
return weightedImpact
}Impact Thresholds
Set appropriate warnings based on impact:
function getPriceImpactSeverity(impactPercent: number) {
if (impactPercent < 0.1) return { level: 'low', color: 'green' }
if (impactPercent < 0.5) return { level: 'medium', color: 'yellow' }
if (impactPercent < 1.0) return { level: 'high', color: 'orange' }
return { level: 'severe', color: 'red' }
}
// Usage
const impact = await calculatePriceImpact(poolId, amount, true, true)
const severity = getPriceImpactSeverity(impact.priceImpact)
if (severity.level === 'severe') {
console.warn('⚠️ High price impact! Consider reducing trade size.')
}Minimize Price Impact
1. Split Large Trades
async function splitTradeForBetterPrice(
totalAmount: BN,
maxImpactPercent: number
) {
const chunks = []
let remainingAmount = totalAmount
while (remainingAmount.gt(new BN(0))) {
// Find chunk size with acceptable impact
const chunkSize = await findMaxAmountForImpact(
poolId,
maxImpactPercent
)
if (chunkSize.gte(remainingAmount)) {
chunks.push(remainingAmount)
break
}
chunks.push(chunkSize)
remainingAmount = remainingAmount.sub(chunkSize)
}
return chunks
}2. Use Multiple Pools
async function findLowImpactRoute(
amount: BN,
fromCoin: string,
toCoin: string
) {
// Router automatically minimizes impact
const bestRoute = await sdk.Router.getBestInternalRouter(
fromCoin,
toCoin,
amount,
true,
0.005, // 0.5% slippage
''
)
// Check if multi-hop has lower impact
if (bestRoute.paths[0].poolAddress.length > 1) {
console.log('Using multi-hop route for lower impact')
}
return bestRoute
}Complete Example
async function executeSwapWithImpactCheck(
poolId: string,
amount: string,
maxImpactPercent: number
) {
// 1. Calculate impact
const impact = await calculatePriceImpact(
poolId,
amount,
true,
true
)
console.log(`Price Impact: ${impact.priceImpact.toFixed(3)}%`)
console.log(`Price: ${impact.currentPrice} → ${impact.endPrice}`)
// 2. Check threshold
if (impact.priceImpact > maxImpactPercent) {
throw new Error(
`Price impact ${impact.priceImpact}% exceeds max ${maxImpactPercent}%`
)
}
// 3. Warn user
const severity = getPriceImpactSeverity(impact.priceImpact)
if (severity.level !== 'low') {
console.warn(`${severity.level.toUpperCase()} price impact detected`)
}
// 4. Execute swap with slippage
const slippage = Math.max(0.5, impact.priceImpact * 1.5)
const swapParams = {
pool_id: poolId,
coinTypeA: pool.coinTypeA,
coinTypeB: pool.coinTypeB,
a2b: true,
by_amount_in: true,
amount,
amount_limit: calculateMinOutput(amount, slippage)
}
const tx = await sdk.Swap.createSwapTransactionPayload(swapParams)
return tx
}Price Impact Formula
// Basic formula
priceImpact = |endPrice - startPrice| / startPrice * 100
// For CLMM
function calculateCLMMImpact(
startSqrtPrice: BN,
endSqrtPrice: BN,
decimalsA: number,
decimalsB: number
): number {
const startPrice = TickMath.sqrtPriceX64ToPrice(
startSqrtPrice, decimalsA, decimalsB
)
const endPrice = TickMath.sqrtPriceX64ToPrice(
endSqrtPrice, decimalsA, decimalsB
)
return Math.abs(
endPrice.minus(startPrice)
.div(startPrice)
.mul(100)
.toNumber()
)
}Important Notes
Price impact increases with trade size
Impact is higher in low liquidity pools
Concentrated liquidity affects impact differently
Always set appropriate slippage tolerance
Consider splitting large trades
Monitor impact in real-time for better UX
Last updated