> ## Documentation Index
> Fetch the complete documentation index at: https://docs.onebalance.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Slippage Tolerance Examples

> Working code examples for implementing slippage tolerance across different OneBalance operations and asset types.

Practical examples of implementing slippage tolerance in various scenarios. Each example includes complete, runnable code that you can adapt for your specific use case.

## Basic Slippage Implementation

### Stablecoin Swap (Low Slippage)

Use minimal slippage for stable asset pairs:

<CodeGroup>
  ```typescript TypeScript theme={null}
  const stablecoinSwap = await getQuote({
    from: {
      account: {
        sessionAddress: "0x1cBFbFd62a276BF6D79d504eA4CA75a7baDcf5b1",
        adminAddress: "0xc162a3cE45ad151eeCd0a5532D6E489D034aB3B8",
        accountAddress: "0xE20295ec513DEf805D9c3083b0C8EaB64692D764"
      },
      asset: { assetId: "ob:usdc" },
      amount: "1000000" // 1 USDC
    },
    to: {
      asset: { assetId: "ob:usdt" }
    },
    slippageTolerance: 10 // 0.1% for stablecoins
  });
  ```

  ```bash cURL theme={null}
  curl --request POST \
    --url https://be.onebalance.io/api/v1/quote \
    --header 'Content-Type: application/json' \
    --header 'x-api-key: 42bb629272001ee1163ca0dbbbc07bcbb0ef57a57baf16c4b1d4672db4562c11' \
    --data '{
      "from": {
        "account": {
          "sessionAddress": "0x1cBFbFd62a276BF6D79d504eA4CA75a7baDcf5b1",
          "adminAddress": "0xc162a3cE45ad151eeCd0a5532D6E489D034aB3B8",
          "accountAddress": "0xE20295ec513DEf805D9c3083b0C8EaB64692D764"
        },
        "asset": { "assetId": "ob:usdc" },
        "amount": "1000000"
      },
      "to": {
        "asset": { "assetId": "ob:usdt" }
      },
      "slippageTolerance": 10
    }'
  ```
</CodeGroup>

### Major Token Swap (Medium Slippage)

Standard slippage for major cryptocurrency pairs:

<CodeGroup>
  ```typescript TypeScript theme={null}
  const ethToUsdcSwap = await getQuote({
    from: {
      account: {
        sessionAddress: "0x1cBFbFd62a276BF6D79d504eA4CA75a7baDcf5b1",
        adminAddress: "0xc162a3cE45ad151eeCd0a5532D6E489D034aB3B8",
        accountAddress: "0xE20295ec513DEf805D9c3083b0C8EaB64692D764"
      },
      asset: { assetId: "ob:eth" },
      amount: "100000000000000" // 1 ETH
    },
    to: {
      asset: { assetId: "ob:usdc" }
    },
    slippageTolerance: 100 // 1% for major tokens
  });
  ```

  ```bash cURL theme={null}
  curl --request POST \
    --url https://be.onebalance.io/api/v1/quote \
    --header 'Content-Type: application/json' \
    --header 'x-api-key: 42bb629272001ee1163ca0dbbbc07bcbb0ef57a57baf16c4b1d4672db4562c11' \
    --data '{
      "from": {
        "account": {
          "sessionAddress": "0x1cBFbFd62a276BF6D79d504eA4CA75a7baDcf5b1",
          "adminAddress": "0xc162a3cE45ad151eeCd0a5532D6E489D034aB3B8", 
          "accountAddress": "0xE20295ec513DEf805D9c3083b0C8EaB64692D764"
        },
        "asset": { "assetId": "ob:eth" },
        "amount": "100000000000000"
      },
      "to": {
        "asset": { "assetId": "ob:usdc" }
      },
      "slippageTolerance": 100
    }'
  ```
</CodeGroup>

### Volatile Token Swap (High Slippage)

Higher slippage tolerance for volatile or newer tokens:

<CodeGroup>
  ```typescript TypeScript theme={null}
  const volatileTokenSwap = await getQuote({
    from: {
      account: {
        sessionAddress: "0x1cBFbFd62a276BF6D79d504eA4CA75a7baDcf5b1",
        adminAddress: "0xc162a3cE45ad151eeCd0a5532D6E489D034aB3B8",
        accountAddress: "0xE20295ec513DEf805D9c3083b0C8EaB64692D764"
      },
      asset: { assetId: "eip155:1/erc20:0x1234567890123456789012345678901234567890" },
      amount: "100000000000000" // 1000 tokens
    },
    to: {
      asset: { assetId: "ob:eth" }
    },
    slippageTolerance: 300 // 3% for volatile tokens
  });
  ```

  ```bash cURL theme={null}
  curl --request POST \
    --url https://be.onebalance.io/api/v1/quote \
    --header 'Content-Type: application/json' \
    --header 'x-api-key: 42bb629272001ee1163ca0dbbbc07bcbb0ef57a57baf16c4b1d4672db4562c11' \
    --data '{
      "from": {
        "account": {
          "sessionAddress": "0x1cBFbFd62a276BF6D79d504eA4CA75a7baDcf5b1",
          "adminAddress": "0xc162a3cE45ad151eeCd0a5532D6E489D034aB3B8",
          "accountAddress": "0xE20295ec513DEf805D9c3083b0C8EaB64692D764"
        },
        "asset": { "assetId": "eip155:1/erc20:0x1234567890123456789012345678901234567890" },
        "amount": "100000000000000"
      },
      "to": {
        "asset": { "assetId": "ob:eth" }
      },
      "slippageTolerance": 300
    }'
  ```
</CodeGroup>

## Contract Call Examples

### DeFi Protocol Interaction

Smart contract calls with slippage tolerance for DEX operations:

<CodeGroup>
  ```typescript TypeScript theme={null}
  const uniswapSwapWithSlippage = await prepareCallQuote({
    account: {
      sessionAddress: "0x1cBFbFd62a276BF6D79d504eA4CA75a7baDcf5b1",
      adminAddress: "0xc162a3cE45ad151eeCd0a5532D6E489D034aB3B8",
      accountAddress: "0xE20295ec513DEf805D9c3083b0C8EaB64692D764"
    },
    targetChain: "eip155:8453", // Base
    calls: [{
      to: "0x2626664c2603336E57B271c5C0b26F421741e481", // Uniswap V3 Router
      data: "0x414bf389000000000000000000000000833589fcd6edb6e08f4c7c32d4f71b54bda029130000000000000000000000004200000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000bb8000000000000000000000000e20295ec513def805d9c3083b0c8eab64692d764000000000000000000000000000000000000000000000000000000006748d28800000000000000000000000000000000000000000000000000000000000f42400000000000000000000000000000000000000000000000000de0b6b3a76400000000000000000000000000000000000000000000000000000000000000000000",
      value: "0x0"
    }],
    allowanceRequirements: [{
      assetType: "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
      amount: "1000000",
      spender: "0x2626664c2603336E57B271c5C0b26F421741e481"
    }],
    tokensRequired: [{
      assetType: "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
      amount: "1000000"
    }],
    slippageTolerance: 100 // 1% slippage for DEX operations
  });
  ```

  ```bash cURL theme={null}
  curl --request POST \
    --url https://be.onebalance.io/api/quotes/prepare-call-quote \
    --header 'Content-Type: application/json' \
    --header 'x-api-key: 42bb629272001ee1163ca0dbbbc07bcbb0ef57a57baf16c4b1d4672db4562c11' \
    --data '{
      "account": {
        "sessionAddress": "0x1cBFbFd62a276BF6D79d504eA4CA75a7baDcf5b1",
        "adminAddress": "0xc162a3cE45ad151eeCd0a5532D6E489D034aB3B8",
        "accountAddress": "0xE20295ec513DEf805D9c3083b0C8EaB64692D764"
      },
      "targetChain": "eip155:8453",
      "calls": [{
        "to": "0x2626664c2603336E57B271c5C0b26F421741e481",
        "data": "0x414bf389000000000000000000000000833589fcd6edb6e08f4c7c32d4f71b54bda029130000000000000000000000004200000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000bb8000000000000000000000000e20295ec513def805d9c3083b0c8eab64692d764000000000000000000000000000000000000000000000000000000006748d28800000000000000000000000000000000000000000000000000000000000f42400000000000000000000000000000000000000000000000000de0b6b3a76400000000000000000000000000000000000000000000000000000000000000000000",
        "value": "0x0"
      }],
      "allowanceRequirements": [{
        "assetType": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
        "amount": "1000000",
        "spender": "0x2626664c2603336E57B271c5C0b26F421741e481"
      }],
      "tokensRequired": [{
        "assetType": "eip155:8453/erc20:0x833589fcd6edb6e08f4c7c32d4f71b54bda02913", 
        "amount": "1000000"
      }],
      "slippageTolerance": 100
    }'
  ```
</CodeGroup>

## Advanced Implementation Patterns

### Adaptive Slippage Based on Market Conditions

```typescript Market-Adaptive Slippage theme={null}
interface MarketConditions {
  volatility: 'low' | 'medium' | 'high';
  liquidityDepth: 'shallow' | 'medium' | 'deep';
  networkCongestion: 'low' | 'medium' | 'high';
}

function calculateAdaptiveSlippage(
  baseSlippage: number,
  conditions: MarketConditions
): number {
  let multiplier = 1;

  // Adjust for volatility
  switch (conditions.volatility) {
    case 'high':
      multiplier *= 2;
      break;
    case 'medium':
      multiplier *= 1.5;
      break;
    case 'low':
      multiplier *= 1;
      break;
  }

  // Adjust for liquidity
  switch (conditions.liquidityDepth) {
    case 'shallow':
      multiplier *= 1.8;
      break;
    case 'medium':
      multiplier *= 1.3;
      break;
    case 'deep':
      multiplier *= 1;
      break;
  }

  // Adjust for network congestion
  switch (conditions.networkCongestion) {
    case 'high':
      multiplier *= 1.2;
      break;
    case 'medium':
      multiplier *= 1.1;
      break;
    case 'low':
      multiplier *= 1;
      break;
  }

  // Cap at 10% (1000 basis points)
  return Math.min(Math.round(baseSlippage * multiplier), 1000);
}

// Usage example
const marketConditions: MarketConditions = {
  volatility: 'high',
  liquidityDepth: 'medium', 
  networkCongestion: 'low'
};

const adaptiveSlippage = calculateAdaptiveSlippage(100, marketConditions);

const quote = await getQuote({
  from: { 
    account: yourAccount,
    asset: { assetId: "ob:eth" },
    amount: "100000000000000"
  },
  to: { asset: { assetId: "ob:usdc" } },
  slippageTolerance: adaptiveSlippage // Dynamically calculated
});
```

### Retry Logic with Progressive Slippage

```typescript Progressive Retry theme={null}
async function executeWithProgressiveSlippage(
  baseRequest: QuoteRequest,
  options?: {
    maxRetries?: number;
    baseSlippage?: number;
    maxSlippage?: number;
  }
) {
  const {
    maxRetries = 3,
    baseSlippage = 50, // 0.5%
    maxSlippage = 500  // 5%
  } = options || {};

  // Generate progressive slippage values
  const slippageSteps = [];
  for (let i = 0; i < maxRetries; i++) {
    const step = baseSlippage * Math.pow(2, i); // 50, 100, 200, 400...
    slippageSteps.push(Math.min(step, maxSlippage));
  }

  let lastError;
  
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    const currentSlippage = slippageSteps[attempt];
    
    try {
      console.log(`Attempt ${attempt + 1}: Using ${currentSlippage / 100}% slippage`);
      
      const quote = await getQuote({
        ...baseRequest,
        slippageTolerance: currentSlippage
      });
      
      const result = await executeQuote(quote);
      console.log(`Success on attempt ${attempt + 1}`);
      return result;
      
    } catch (error: any) {
      lastError = error;
      
      if (error.code === 'QUOTE_REFUNDED' && attempt < maxRetries - 1) {
        console.log(`Attempt ${attempt + 1} failed, retrying with higher slippage...`);
        // Wait before retry to avoid rate limiting
        await new Promise(resolve => setTimeout(resolve, 1000 * (attempt + 1)));
        continue;
      }
      
      // Final attempt failed or non-retryable error
      break;
    }
  }
  
  throw new Error(`All ${maxRetries} attempts failed. Last error: ${lastError?.message}`);
}

// Usage
try {
  const result = await executeWithProgressiveSlippage({
    from: {
      account: yourAccount,
      asset: { assetId: "ob:eth" },
      amount: "100000000000000"
    },
    to: { asset: { assetId: "ob:usdc" } }
  }, {
    maxRetries: 4,
    baseSlippage: 75,  // Start at 0.75%
    maxSlippage: 400   // Cap at 4%
  });
  
  console.log('Transaction successful:', result);
} catch (error) {
  console.error('All retry attempts failed:', error);
}
```

### User-Configurable Slippage Settings

```typescript User Settings theme={null}
interface SlippagePreferences {
  mode: 'conservative' | 'balanced' | 'aggressive' | 'custom';
  customValue?: number;
  autoRetry?: boolean;
  maxRetries?: number;
}

class SlippageManager {
  private presets = {
    conservative: { 
      stablecoin: 5,   // 0.05%
      major: 50,       // 0.5%
      volatile: 150    // 1.5%
    },
    balanced: {
      stablecoin: 10,  // 0.1%
      major: 100,      // 1%
      volatile: 300    // 3%
    },
    aggressive: {
      stablecoin: 25,  // 0.25%
      major: 200,      // 2%
      volatile: 500    // 5%
    }
  };

  getSlippageForAssets(
    fromAsset: string, 
    toAsset: string, 
    preferences: SlippagePreferences
  ): number {
    if (preferences.mode === 'custom' && preferences.customValue) {
      return preferences.customValue;
    }

    const assetType = this.categorizeAssetPair(fromAsset, toAsset);
    const preset = this.presets[preferences.mode as keyof typeof this.presets];
    
    return preset?.[assetType] || this.presets.balanced[assetType];
  }

  private categorizeAssetPair(fromAsset: string, toAsset: string): 'stablecoin' | 'major' | 'volatile' {
    const stablecoins = ['usdc', 'usdt', 'dai', 'busd'];
    const majorTokens = ['eth', 'btc', 'bnb', 'matic', 'avax'];

    const isStablecoin = (asset: string) => 
      stablecoins.some(stable => asset.toLowerCase().includes(stable));
    
    const isMajor = (asset: string) =>
      majorTokens.some(major => asset.toLowerCase().includes(major)) || isStablecoin(asset);

    if (isStablecoin(fromAsset) && isStablecoin(toAsset)) {
      return 'stablecoin';
    }
    
    if (isMajor(fromAsset) && isMajor(toAsset)) {
      return 'major';
    }
    
    return 'volatile';
  }

  async executeWithUserPreferences(
    request: QuoteRequest,
    preferences: SlippagePreferences
  ) {
    const slippage = this.getSlippageForAssets(
      request.from.asset.assetId,
      request.to.asset.assetId,
      preferences
    );

    const enhancedRequest = {
      ...request,
      slippageTolerance: slippage
    };

    if (preferences.autoRetry) {
      return await executeWithProgressiveSlippage(enhancedRequest, {
        maxRetries: preferences.maxRetries || 3,
        baseSlippage: slippage
      });
    }

    const quote = await getQuote(enhancedRequest);
    return await executeQuote(quote);
  }
}

// Usage example
const slippageManager = new SlippageManager();

// Conservative user
const conservativeResult = await slippageManager.executeWithUserPreferences({
  from: {
    account: yourAccount,
    asset: { assetId: "ob:eth" },
    amount: "100000000000000"
  },
  to: { asset: { assetId: "ob:usdc" } }
}, {
  mode: 'conservative',
  autoRetry: true,
  maxRetries: 2
});

// Custom slippage user
const customResult = await slippageManager.executeWithUserPreferences({
  from: {
    account: yourAccount, 
    asset: { assetId: "ob:usdc" },
    amount: "1000000"
  },
  to: { asset: { assetId: "ob:eth" } }
}, {
  mode: 'custom',
  customValue: 75, // 0.75%
  autoRetry: false
});
```

## Multi-Chain Examples

### Cross-Chain with Solana Assets

```typescript Solana + EVM theme={null}
const crossChainQuote = await getQuote({
  accounts: [
    {
      type: "kernel-v3.1-ecdsa",
      signerAddress: "0x5d6fb4eb211a6a2e406a1111b54d26c534753c8e", 
      accountAddress: "0xb7bc0d7baf6761c302ff6772dfd8f9e22ec706e7"
    },
    {
      type: "solana",
      signerAddress: "5Cb2369421F8a00Ef556d662D6E97C1419B1d37c",
      accountAddress: "5Cb2369421F8a00Ef556d662D6E97C1419B1d37c"
    }
  ],
  from: {
    asset: { assetId: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp/spl-token:EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v" }, // USDC on Solana
    amount: "1000000"
  },
  to: {
    asset: { assetId: "eip155:8453/erc20:0x4200000000000000000000000000000000000006" } // WETH on Base
  },
  slippageTolerance: 150 // 1.5% for cross-chain operations
});
```

## Error Handling Examples

### Complete Error Management

```typescript Error Handling theme={null}
async function robustSlippageExecution(request: QuoteRequest) {
  try {
    const quote = await getQuote(request);
    const result = await executeQuote(quote);
    return { success: true, result };
    
  } catch (error: any) {
    console.error('Quote execution failed:', error);
    
    // Handle specific slippage-related errors
    switch (error.code) {
      case 'QUOTE_REFUNDED':
        return {
          success: false,
          error: 'SLIPPAGE_EXCEEDED',
          message: 'Price moved beyond tolerance. Try again with higher slippage.',
          suggestedSlippage: (request.slippageTolerance || 100) * 1.5,
          retryable: true
        };
        
      case 'SLIPPAGE_TOO_HIGH':
        return {
          success: false,
          error: 'SLIPPAGE_TOO_HIGH', 
          message: 'Slippage tolerance too high. Please use a lower value.',
          maxRecommended: 500, // 5%
          retryable: true
        };
        
      case 'INSUFFICIENT_BALANCE':
        return {
          success: false,
          error: 'INSUFFICIENT_BALANCE',
          message: 'Insufficient balance for this transaction.',
          retryable: false
        };
        
      case 'RATE_LIMITED':
        return {
          success: false,
          error: 'RATE_LIMITED',
          message: 'Too many requests. Please wait before retrying.',
          retryAfter: error.retryAfter || 5000,
          retryable: true
        };
        
      default:
        return {
          success: false,
          error: 'UNKNOWN_ERROR',
          message: error.message || 'An unexpected error occurred.',
          retryable: false
        };
    }
  }
}

// Usage with error handling
const result = await robustSlippageExecution({
  from: {
    account: yourAccount,
    asset: { assetId: "ob:eth" },
    amount: "100000000000000"
  },
  to: { asset: { assetId: "ob:usdc" } },
  slippageTolerance: 100
});

if (!result.success) {
  console.log('Error:', result.message);
  
  if (result.retryable) {
    console.log('This error is retryable');
    if (result.suggestedSlippage) {
      console.log(`Suggested slippage: ${result.suggestedSlippage / 100}%`);
    }
  }
}
```

## Recommended Values by Scenario

<CardGroup cols={2}>
  <Card title="Production Defaults" icon="settings">
    * **Stablecoins**: 10-25 basis points (0.1-0.25%)
    * **Major tokens**: 100 basis points (1%)
    * **Volatile tokens**: 300 basis points (3%)
    * **Cross-chain**: +50% of single-chain values
  </Card>

  <Card title="High-Volume Applications" icon="trending-up">
    * **Start conservative**: 50 basis points (0.5%)
    * **Auto-retry**: Enable with 2-3 attempts
    * **Max slippage**: 500 basis points (5%)
    * **Monitor success rates**: Adjust based on data
  </Card>
</CardGroup>

## Next Steps

<CardGroup cols={2}>
  <Card title="Troubleshooting" icon="wrench" href="/guides/slippage/troubleshooting">
    Common issues and solutions for slippage tolerance implementation
  </Card>

  <Card title="Getting Started" icon="rocket" href="/guides/slippage/getting-started">
    Step-by-step implementation guide for slippage tolerance
  </Card>
</CardGroup>

<Tip>
  Test your slippage implementation with small amounts first to ensure it works correctly before processing larger transactions.
</Tip>