EVM Example | DEX SDK | Resources | DEX API | DEX API Docs

·

Mastering DEX Interactions with EVM: A Developer’s Guide to Approvals, Swaps, and Quotes

Decentralized exchanges (DEXs) are at the forefront of the Web3 revolution, enabling permissionless, non-custodial trading across blockchain networks. For developers building on EVM-compatible chains, understanding how to programmatically interact with DEXs is essential. This guide walks through core functionalities—token approvals, executing swaps, and fetching price quotes—using a robust DEX SDK that supports EVM-based blockchains like Base.

Whether you're integrating decentralized trading into a dApp or automating portfolio management, this resource provides practical code examples and insights into real-world implementation.

Understanding Token Approvals on EVM Chains

Before a smart contract can spend your tokens—such as during a swap—you must grant it permission via an approval transaction. This step ensures security by allowing users to control exactly how much of a given token a contract can access.

The following example demonstrates how to approve a token for spending using the DEX SDK:

// approval.ts
import { client } from './DexClient';

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

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

async function executeApproval(tokenAddress: string, amount: string) {
  try {
    console.log("Getting token information...");
    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);

    console.log(`\nApproval Details:`);
    console.log(`--------------------`);
    console.log(`Token: ${tokenInfo.data[0].fromToken.tokenSymbol}`);
    console.log(`Amount: ${amount}${tokenInfo.data[0].fromToken.tokenSymbol}`);
    console.log(`Amount in base units: ${rawAmount}`);

    const result = await client.dex.executeApproval({
      chainId: '8453',
      tokenContractAddress: tokenAddress,
      approveAmount: rawAmount
    });

    if ('alreadyApproved' in result) {
      console.log("\nToken already approved for the requested amount!");
      return { success: true, alreadyApproved: true };
    } else {
      console.log("\nApproval completed successfully!");
      console.log("Transaction Hash:", result.transactionHash);
      console.log("Explorer URL:", result.explorerUrl);
      return result;
    }
  } catch (error) {
    if (error instanceof Error) {
      console.error('Error executing approval:', error.message);
    }
    throw error;
  }
}

This pattern ensures accurate conversion from human-readable amounts (e.g., 1000 USDC) to base units (wei-like values), critical for correct on-chain execution.

👉 Learn how to securely manage token approvals in your dApp

Executing Cross-Asset Swaps Programmatically

Once approvals are set, you can execute swaps between tokens. The SDK simplifies this process with executeSwap, which handles route optimization, slippage tolerance, and transaction broadcasting.

Here's an example of swapping native ETH for USDC on the Base network:

// swap.ts
import { client } from './DexClient';

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:');
    console.log(JSON.stringify(swapResult, null, 2));
    return swapResult;
  } catch (error) {
    if (error instanceof Error) {
      console.error('Error executing swap:', error.message);
      const match = error.message.match(/API Error: (.*)/);
      if (match) console.error('API Error Details:', match[1]);
    }
    throw error;
  }
}

This function supports any EVM-compatible chain by adjusting the chainId. You can also integrate SUI or testnets like Base Sepolia (84532) with minimal configuration changes.

Fetching Accurate Price Quotes

Before executing trades, it’s crucial to know expected output and potential price impact. The getQuote method returns real-time pricing data across liquidity sources.

Example usage:

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

This call retrieves estimated output for swapping 1 USDC to WETH on Base, including gas estimates and route details. It helps prevent failed transactions due to volatility or insufficient output.

👉 Discover how real-time quotes enhance trading accuracy

Frequently Asked Questions

What is an EVM-compatible chain?

An EVM-compatible chain is a blockchain that supports the Ethereum Virtual Machine, enabling deployment of Ethereum-based smart contracts. Examples include Base, Arbitrum, Optimism, and Polygon.

Why do I need to approve tokens before swapping?

Token approval ensures security by letting users specify how much a contract can spend from their wallet. Without approval, even legitimate contracts cannot transfer ERC-20 tokens.

Can I use this SDK on non-EVM blockchains?

Yes. While EVM chains are fully supported, the SDK also enables interactions on non-EVM networks like SUI by specifying the appropriate chainId.

How does slippage affect my swap?

Slippage defines the acceptable price deviation during a trade. A 0.5% slippage means the transaction will revert if the final price moves more than ±0.5% from the quoted rate.

Is my private key secure when using executeSwap?

Your private key is used only locally to sign transactions. Never expose it in client-side code or public repositories. Always use environment variables (process.env) for sensitive data.

What happens if a swap fails?

Failed swaps typically result from high volatility, low liquidity, or network congestion. The SDK returns detailed error messages to help debug issues quickly.

Best Practices for Production Use

Integrating DEX functionality into your application unlocks powerful financial capabilities. With tools like getQuote, executeApproval, and executeSwap, developers can build seamless, secure, and efficient trading experiences across EVM and multi-chain environments.

👉 Start building advanced DeFi integrations today

Core Keywords:

All external links have been replaced with optimized anchor text pointing to the designated URL as per instructions.