How to Use the DEX API for Token Approvals and Swaps

·

The DEX API provides a powerful interface for developers to integrate decentralized exchange functionalities directly into their applications. This guide walks through key operations such as token approvals and swaps, essential for any DeFi interaction.

Understanding Token Approvals

Before any token swap can occur on a decentralized exchange, the smart contract must have permission to access the tokens in your wallet. This process is known as a token approval.

The toBaseUnits Helper Function

When working with blockchain transactions, amounts must be specified in the token's smallest unit (base units). This helper function converts a human-readable amount into the correct base unit format.

export function toBaseUnits(amount: string, decimals: number): string {
  const [integerPart, decimalPart = ''] = amount.split('.');
  const currentDecimals = decimalPart.length;
  let result = integerPart + decimalPart;

  if (currentDecimals < decimals) {
    result = result + '0'.repeat(decimals - currentDecimals);
  } else if (currentDecimals > decimals) {
    result = result.slice(0, result.length - (currentDecimals - decimals));
  }

  result = result.replace(/^0+/, '') || '0';
  return result;
}

Executing a Token Approval

The approval process involves two main steps: retrieving token information and executing the approval transaction.

async function executeApproval(tokenAddress: string, amount: string) {
  try {
    const tokenInfo = await client.dex.getQuote({
      chainId: '8453',
      fromTokenAddress: tokenAddress,
      toTokenAddress: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
      amount: '1000000',
      slippage: '0.005'
    });
    
    const tokenDecimals = parseInt(tokenInfo.data[0].fromToken.decimal);
    const rawAmount = toBaseUnits(amount, tokenDecimals);
    
    const result = await client.dex.executeApproval({
      chainId: '8453',
      tokenContractAddress: tokenAddress,
      approveAmount: rawAmount
    });
    
    if ('alreadyApproved' in result) {
      console.log("Token already approved!");
      return { success: true, alreadyApproved: true };
    } else {
      console.log("Approval completed successfully!");
      console.log("Transaction Hash:", result.transactionHash);
      return result;
    }
  } catch (error) {
    if (error instanceof Error) {
      console.error('Error executing approval:', error.message);
    }
    throw error;
  }
}

Executing Token Swaps

Once tokens are approved, you can execute swaps between different assets. The DEX API handles the complex routing logic to find the best available prices.

Basic Swap Implementation

This example demonstrates swapping ETH for USDC on the Base network:

async function executeSwap() {
  try {
    if (!process.env.EVM_PRIVATE_KEY) {
      throw new Error('Missing EVM_PRIVATE_KEY in .env file');
    }

    const swapResult = await client.dex.executeSwap({
      chainId: '8453',
      fromTokenAddress: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
      toTokenAddress: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
      amount: String(10 * 10 ** 14),
      slippage: '0.005',
      userWalletAddress: process.env.EVM_WALLET_ADDRESS!
    });

    console.log('Swap executed successfully:');
    return swapResult;
  } catch (error) {
    if (error instanceof Error) {
      console.error('Error executing swap:', error.message);
    }
    throw error;
  }
}

Retrieving Price Quotes

Before executing any swap, it's crucial to get a price quote to understand the expected exchange rate and potential slippage.

Getting a Quote Example

const quote = await client.dex.getQuote({
  chainId: '8453',
  fromTokenAddress: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
  toTokenAddress: '0x4200000000000000000000000000000000000006',
  amount: '1000000',
  slippage: '0.005'
});

The quote response includes detailed information about the expected exchange rate, minimum amount out, and other crucial trading parameters.

Best Practices for DEX Integration

When integrating DEX functionality into your application, consider these essential practices:

👉 Explore advanced trading strategies

Frequently Asked Questions

What is a token approval and why is it necessary?
Token approval is a required security step that grants a smart contract permission to access specific tokens in your wallet. This prevents unauthorized access while allowing legitimate operations like trading on decentralized exchanges.

How do I handle different blockchain networks?
The DEX API supports multiple networks through the chainId parameter. Simply change this value to switch between different blockchain environments while maintaining the same API interface.

What should I do if a transaction fails?
First, check the error message for specific details. Common issues include insufficient gas, price movement exceeding slippage tolerance, or temporary network congestion. Always implement retry logic with appropriate delays.

How can I ensure I'm getting the best exchange rates?
The API automatically routes through the best available liquidity pools. For optimal results, always get a fresh quote immediately before executing trades and consider setting competitive slippage parameters.

What security measures should I implement?
Never expose private keys in client-side code. Use environment variables for sensitive information, validate all parameters before sending transactions, and implement proper error handling to protect user funds.

Can I use this API for high-frequency trading?
While the API is performant, high-frequency trading requires additional considerations like gas optimization, mempool monitoring, and sophisticated price impact calculations. 👉 Get advanced trading methods