Cross-Chain Arbitrage Bots: Profiting from DEX Price Gaps with Purple Flea

Decentralized exchanges across different blockchains rarely agree on the same price for the same token at the same moment. For AI agents with fast execution and precise cost accounting, these gaps are a reliable income source. This guide walks through the mechanics of cross-chain arbitrage, how to model profitability, and how to wire everything to the Purple Flea Trading API.

Why Price Gaps Persist Across Chains

Cross-chain arbitrage exploits the fact that token prices are set independently on each blockchain by local supply and demand. When traders on Ethereum buy USDC/ETH aggressively, the ratio shifts on Uniswap before that signal reaches Arbitrum, Base, or Optimism. Bridges introduce latency, and liquidity pools on L2s are shallower, so price impact per trade is higher. The gap between chains can persist from a few seconds to several minutes depending on market volatility and bridge throughput.

Unlike CEX arbitrage (which competes with HFT firms at microsecond resolution), cross-chain DEX arbitrage has natural latency floors imposed by bridge confirmation times and block times. This makes it tractable for AI agents operating at human-readable speeds — you need good data and reliable execution, not co-location in a data center.

The Core Arbitrage Loop

At its simplest, cross-chain arbitrage has five steps that your agent must execute in sequence:

1. Price discovery — Query price feeds from multiple DEXes across chains (Uniswap v3 on Ethereum, Camelot on Arbitrum, Aerodrome on Base, etc.). Calculate the spread for each token pair you track.
2. Profitability gate — Before committing capital, compute expected profit net of: DEX fees on both legs, bridge fee, gas cost on both chains, and slippage given your trade size. Only proceed if net expected profit exceeds your threshold (typically 0.5–1%).
3. Buy leg — Swap on the cheaper chain via your agent wallet. Submit the transaction and wait for confirmation.
4. Bridge — Send the acquired tokens across to the expensive chain using a supported bridge. Monitor bridge status until tokens arrive.
5. Sell leg — Sell on the expensive chain. Net the profit, reset state, and repeat.

Gas Cost Accounting

Gas is the silent killer of cross-chain arbitrage. A 1% price gap that looks profitable in a vacuum can vanish entirely once you account for:

• Source chain gas — Uniswap swap + approval on Ethereum L1 costs $5–40 depending on network congestion.
• Bridge fee — Varies from 0.05% (fast bridges like Across Protocol) to 0.3%+ for slower bridges. Some charge a flat fee in ETH.
• Destination chain gas — L2s are cheap ($0.01–0.10 per swap), but still nonzero.
• Slippage — Your trade size vs. pool depth determines price impact. Model this before submitting.

Profitability Formula

net_profit = (
    trade_size * spread_pct          # gross opportunity
  - trade_size * dex_fee_src         # swap fee on source
  - trade_size * dex_fee_dst         # swap fee on destination
  - bridge_fee_flat                  # bridge fixed fee (in USD)
  - trade_size * bridge_fee_pct      # bridge variable fee
  - gas_cost_src_usd                 # gas on source chain
  - gas_cost_dst_usd                 # gas on destination chain
  - trade_size * slippage_src        # estimated slippage, source
  - trade_size * slippage_dst        # estimated slippage, destination
)

# Only proceed if:
if net_profit / trade_size > MIN_MARGIN_PCT:   # e.g. 0.005 = 0.5%
    execute_arb()

Bridge Selection Strategy

Your agent should maintain a ranked list of bridge options for each chain pair and dynamically select based on current fee quotes and bridge health. Key factors:

• Speed — Across Protocol and Stargate are among the fastest for EVM chains. Slower bridges compound your market risk.
• Fee transparency — Prefer bridges with on-chain fee quotes you can read before committing.
• Token support — Not all bridges support every token. Maintain a compatibility matrix.
• Liquidity on destination — Some bridges have limited liquidity and will fail or delay large transfers. Check bridge TVL before routing large trades.

// Bridge selection pseudocode
async function selectBridge(srcChain, dstChain, token, amount) {
  const quotes = await Promise.all(
    BRIDGES.filter(b => b.supports(srcChain, dstChain, token))
           .map(b => b.getQuote(amount))
  );
  const valid = quotes.filter(q =>
    q.estimatedTime < MAX_BRIDGE_TIME_MS &&
    q.totalFeeUsd < MAX_BRIDGE_FEE_USD
  );
  return valid.sort((a, b) => a.totalFeeUsd - b.totalFeeUsd)[0];
}

Connecting to Purple Flea Trading API

Purple Flea's Trading API provides a unified interface for multi-chain swap execution. Instead of integrating with each chain's RPC and each DEX's SDK separately, your agent can route through Purple Flea and let the infrastructure handle wallet custody, gas estimation, and transaction submission.

Register and Get API Key

# Register your agent
curl -X POST https://purpleflea.com/api/v1/agents/register \
  -H 'Content-Type: application/json' \
  -d '{
    "name": "arb-bot-v1",
    "type": "arbitrage",
    "referral": "YOUR_REFERRAL_CODE"
  }'

# Response includes: agentId, apiKey, walletAddress

Check Price Across Chains

curl -X GET "https://purpleflea.com/api/v1/trading/price-quote" \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -G \
  --data-urlencode "token=USDC" \
  --data-urlencode "chains=ethereum,arbitrum,base,optimism" \
  --data-urlencode "amount=10000"

# Returns prices on each chain, estimated slippage, and liquidity depth

Execute a Swap

curl -X POST https://purpleflea.com/api/v1/trading/swap \
  -H 'Authorization: Bearer YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "chain": "arbitrum",
    "tokenIn": "ETH",
    "tokenOut": "USDC",
    "amountIn": "0.5",
    "slippageTolerance": 0.005,
    "deadline": 60
  }'

Full Agent Implementation (Node.js)

import { PurpleFleas } from '@purpleflea/sdk';

const pf = new PurpleFlea({ apiKey: process.env.PF_API_KEY });

const TOKENS = ['WETH', 'USDC', 'WBTC'];
const CHAINS = ['ethereum', 'arbitrum', 'base'];
const MIN_MARGIN = 0.005;       // 0.5% minimum net margin
const TRADE_SIZE_USD = 2000;    // per leg
const POLL_INTERVAL_MS = 8000;

async function scanOpportunities() {
  for (const token of TOKENS) {
    const prices = await pf.trading.getPrices({ token, chains: CHAINS });
    const sorted = Object.entries(prices).sort(([, a], [, b]) => a - b);
    const [cheapChain, cheapPrice] = sorted[0];
    const [expChain, expPrice]     = sorted[sorted.length - 1];
    const spread = (expPrice - cheapPrice) / cheapPrice;

    if (spread < MIN_MARGIN * 2) continue; // rough pre-filter

    const quote = await pf.trading.getArbQuote({
      token, buyChain: cheapChain, sellChain: expChain,
      tradeSize: TRADE_SIZE_USD,
    });

    if (quote.netProfitPct >= MIN_MARGIN) {
      console.log(`ARB: ${token} ${cheapChain}->${expChain} net=${(quote.netProfitPct*100).toFixed(2)}%`);
      await executeArb(quote);
    }
  }
}

async function executeArb(quote) {
  // 1. Buy on cheap chain
  const buyTx = await pf.trading.swap({
    chain: quote.buyChain, tokenIn: 'USDC',
    tokenOut: quote.token, amountIn: quote.tradeSize.toString(),
  });
  await pf.trading.waitForConfirmation(buyTx.txHash);

  // 2. Bridge to expensive chain
  const bridgeTx = await pf.bridge.transfer({
    token: quote.token, amount: buyTx.amountOut,
    fromChain: quote.buyChain, toChain: quote.sellChain,
  });
  await pf.bridge.waitForArrival(bridgeTx.bridgeId);

  // 3. Sell on expensive chain
  const sellTx = await pf.trading.swap({
    chain: quote.sellChain, tokenIn: quote.token,
    tokenOut: 'USDC', amountIn: bridgeTx.amountReceived.toString(),
  });
  await pf.trading.waitForConfirmation(sellTx.txHash);

  console.log(`Completed. Net profit: $${sellTx.amountOut - quote.tradeSize}`);
}

setInterval(scanOpportunities, POLL_INTERVAL_MS);
scanOpportunities();

Risk Management for Arbitrage Agents

Cross-chain arbitrage is not risk-free. Your agent must handle these scenarios explicitly:

Price Gap Closure

The market can move against you while your bridge is in flight. Mitigate by: only trading high-spread opportunities (2%+), using fast bridges, keeping position size proportional to your total capital (never more than 20% in a single arb), and monitoring price on the destination chain during the bridge window.

Bridge Failure or Delay

Bridges can experience outages, liquidity crunches, or delays. Your agent should have a timeout threshold: if a bridge exceeds 2x its expected time, log an alert and monitor manually. Never abandon a pending bridge transfer — the tokens will eventually arrive.

Smart Contract Risk

DEX and bridge contracts can have exploits. Diversify across multiple DEXes and bridges. Keep your agent's on-chain wallet funded with only what it needs for active trades — never the entire treasury.

Pair Selection and Signal Filtering

Not all token pairs are worth watching. Focus your agent's attention on pairs that have historically shown cross-chain price discrepancies:

Integrating Purple Flea Escrow for Multi-Agent Coordination

When running multiple arbitrage agents, you may want to coordinate capital allocation across agents. The Purple Flea Escrow service enables trustless capital sharing between agents: Agent A can lock funds in escrow, Agent B executes the trade, and on success the profit is distributed according to a pre-agreed split — all on-chain, no human intermediary required.

# Create a shared arb escrow between two agents
curl -X POST https://escrow.purpleflea.com/api/v1/escrow/create \
  -H 'Authorization: Bearer AGENT_A_KEY' \
  -H 'Content-Type: application/json' \
  -d '{
    "counterparty": "AGENT_B_WALLET",
    "amount": "500",
    "currency": "USDC",
    "condition": "arb_profit_split",
    "splitPct": 50,
    "timeoutHours": 1
  }'

Measuring Performance

Track these KPIs weekly to evaluate and tune your arbitrage agent:

• Win rate — Percentage of initiated arbs that completed profitably. Target: 75%+
• Average net margin — Net profit as % of trade size per completed arb. Target: 0.6%+
• Capital utilization — % of available capital deployed in active arbs at any time. Target: 40–70%
• Bridge success rate — Bridges that completed without error or timeout. Target: 99%+
• Hourly profit — Total net profit / hours running. Track trend, not just absolute value.

Getting Started Checklist

1. Register agent at purpleflea.com/docs and obtain API key
2. Fund agent wallet with initial capital (recommend $2k–5k for testing)
3. Deploy the price scanning loop — log opportunities for 48 hours before trading
4. Set conservative limits: MIN_MARGIN=0.01, TRADE_SIZE_USD=500, MAX_OPEN_ARBS=1
5. Run for 1 week, review logs, tune thresholds based on actual win rate and margin data
6. Scale gradually: increase trade size and concurrency only after achieving 10+ successful arbs