// Execute swap via REST API
async function executeSwap() {
  const swapData = {
    fromToken: '0xWETH_ADDRESS',
    toToken: '0xUSDC_ADDRESS',
    amount: '1500000000000000000', // 1.5 WETH in wei
    slippageTolerance: '300', // 0.3% in basis points
    recipient: userAddress
  };

  const response = await fetch('https://api.gtxdex.xyz/v1/swap/quote', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${apiKey}`
    },
    body: JSON.stringify(swapData)
  });

  const quote = await response.json();
  console.log('Expected output:', quote.outputAmount, 'USDC');
  
  // Execute the swap
  const executeResponse = await fetch('https://api.gtxdex.xyz/v1/swap/execute', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${apiKey}`
    },
    body: JSON.stringify(quote)
  });

  const result = await executeResponse.json();
  console.log('Swap completed:', result.transactionHash);
}

class SwapAggregator {
  constructor(private client: GTXClient) {}
  
  async executeBatchSwaps(swaps: SwapParams[]) {
    const results = [];
    
    for (const swap of swaps) {
      try {
        // Calculate optimal output for each swap
        const quote = await this.client.getSwapQuote(
          swap.fromToken,
          swap.toToken,
          swap.amount
        );
        
        // Execute if quote is favorable
        if (quote.priceImpact < 0.01) { // Less than 1% impact
          const result = await this.client.swap({
            ...swap,
            minOutputAmount: quote.minOutput
          });
          results.push(result);
        }
      } catch (error) {
        console.error(`Swap failed for ${swap.fromToken}:`, error);
      }
    }
    
    return results;
  }
}

class DCASwapper {
  constructor(
    private client: GTXClient,
    private fromToken: string,
    private toToken: string,
    private totalAmount: number,
    private intervals: number
  ) {}
  
  async startDCA() {
    const amountPerInterval = this.totalAmount / this.intervals;
    
    for (let i = 0; i < this.intervals; i++) {
      try {
        await this.client.swap({
          fromToken: this.fromToken,
          toToken: this.toToken,
          amount: amountPerInterval.toString(),
          slippageTolerance: 0.005 // Higher tolerance for automation
        });
        
        console.log(`DCA swap ${i + 1}/${this.intervals} completed`);
        
        // Wait for next interval (example: 1 hour)
        await new Promise(resolve => setTimeout(resolve, 3600000));
      } catch (error) {
        console.error(`DCA swap ${i + 1} failed:`, error);
      }
    }
  }
}

try {
  const swapResult = await client.swap({
    fromToken: tokenA,
    toToken: tokenB,
    amount: "100",
    slippageTolerance: 0.003
  });
} catch (error) {
  if (error.message.includes('slippage')) {
    console.log('Increase slippage tolerance');
  } else if (error.message.includes('insufficient')) {
    console.log('Check token balance');
  } else {
    console.error('Unexpected error:', error);
  }
}