# Price Impact

### Quick Start

```typescript
// 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

```typescript
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

```typescript
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:

```typescript
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:

```typescript
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

```typescript
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

```typescript
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

```typescript
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

```typescript
// 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


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.ferra.ag/integration/clmm/typescript-sdk/price-impact.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.