Slippage Tolerance Examples

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: "ds:eth" },
    amount: "100000000000000"
  },
  to: { asset: { assetId: "ds:usdc" } },
  slippageTolerance: adaptiveSlippage // Dynamically calculated
});

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: "ds:eth" },
      amount: "100000000000000"
    },
    to: { asset: { assetId: "ds: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);
}

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: "ds:eth" },
    amount: "100000000000000"
  },
  to: { asset: { assetId: "ds:usdc" } }
}, {
  mode: 'conservative',
  autoRetry: true,
  maxRetries: 2
});

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

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
});

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: "ds:eth" },
    amount: "100000000000000"
  },
  to: { asset: { assetId: "ds: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}%`);
    }
  }
}