EVM Cross-Chain Bridges

A single component bridges tokens across EVM chains in one source-chain transaction. Fully decentralized: every quote is read on-chain through your own JSON-RPC endpoint. No API key, no external HTTP service, no off-chain attestation server.

Under the hood the component fans out to multiple decentralized bridge routes in parallel (LayerZero / OFT pools, canonical AMM bridges, hToken-style bridges) and auto-selects the path with the lowest effective fee for the requested asset pair. The chosen route is opaque to the caller — you only see the resulting calldata, fee, and finality estimate.

BRIDGE_EVM_TOKENS

BRIDGE_EVM_TOKENS Workflow Component

Build the source-chain transaction that bridges amount of tokenAddress from sourceChainId to destinationChainId. The component queries every supported route in parallel, picks the cheapest (ties broken by faster finality), applies your slippage, and returns ready-to-sign calldata.

Config

Inputs

Outputs

Required upstream step

Bridging an ERC-20 requires an approve(spender = approvalAddress, amount) call before broadcasting the bridge transaction. Use BUILD_EVM_ERC20_APPROVE_CALLDATA for that step.

Bridging native ETH does not need an approve — the bridge amount is attached via value.

Errors

The component throws a 400 ComponentException for the following cases:

SDK example — USDC from Arbitrum to Ethereum

import { WorkspaceClient, ComponentModule } from '@zafeguard/caller-sdk';
const workspace = new WorkspaceClient({ apiKey: process.env.ZAFEGUARD_API_KEY! });

const SENDER    = '0xYourSourceAddress';
const RECIPIENT = '0xYourDestinationAddress';
const USDC_ARB  = '0xaf88d065e77c8cC2239327C5EDb3A432268e5831';

// 1. Get the bridge route + calldata
const bridge = await workspace.call(ComponentModule.BRIDGE_EVM_TOKENS, {
  sourceChainId:      42161,         // Arbitrum One
  destinationChainId: 1,             // Ethereum
  tokenAddress:       USDC_ARB,
  // outputTokenAddress omitted — auto-resolves to USDC on Ethereum
  amount:             '1000000',     // 1 USDC
  recipient:          RECIPIENT,
  sender:             SENDER,
  jsonRpcUrl:         process.env.ARBITRUM_RPC_URL!,
}).promise();

console.log('Route fee:', bridge.estimatedFeeBps, 'bps');
console.log('Finality:', bridge.estimatedFinalitySec, 'seconds');
console.log('Min delivered:', bridge.minOutputAmount, 'USDC base units');

// 2. Approve the bridge router (USDC is an ERC-20 → approve is required)
const approve = await workspace.call(ComponentModule.BUILD_EVM_ERC20_APPROVE_CALLDATA, {
  tokenAddress: USDC_ARB,
  spender:      bridge.approvalAddress,
  amount:       '1000000',
}).promise();

// 3. From here: BUILD_EVM_TRANSACTION → SIGN → BROADCAST → WAIT  (twice — approve, then bridge)
//    For native-ETH bridges you skip the approve transaction entirely.

Native-ETH bridge

For native ETH, pass the zero-address sentinel and skip the approve step. The bridge amount is attached via value along with the messaging fee.

const bridge = await workspace.call(ComponentModule.BRIDGE_EVM_TOKENS, {
  sourceChainId:      42161,
  destinationChainId: 10, // Optimism
  tokenAddress:       '0x0000000000000000000000000000000000000000',
  amount:             '10000000000000000', // 0.01 ETH
  recipient:          RECIPIENT,
  sender:             SENDER,
  jsonRpcUrl:         process.env.ARBITRUM_RPC_URL!,
}).promise();

// bridge.value = bridge amount + native messaging fee
// No approve step — feed straight into BUILD_EVM_TRANSACTION

How routing works

The component quotes several bridges in parallel and picks the cheapest route within your maxFeeBps. If you pinned outputTokenAddress, only quotes delivering that token are considered. Ties are broken by faster finalitySec. Slippage is applied once at the end to the winning quote.

Chain & asset coverage

The component covers the major EVM chains for the common liquidity assets:

• Assets: USDC, USDT, DAI, native ETH, plus selected route-specific stables (FRAX, gOHM, MATIC, METIS).
• Chains: Ethereum, Optimism, BNB Chain, Polygon, Sonic, Fantom, zkSync Era, Metis, Polygon zkEVM, Moonbeam, Mantle, Base, Arbitrum, Avalanche, Linea, Blast, Scroll, Unichain, Berachain, Gnosis — and others as the underlying routes add support.

If a pair isn't covered for same-asset routing, try outputTokenAddress to opt into a cross-asset route, or use a swap component upstream (see DeFi →) to convert into a supported source asset first.

Full bridge workflow (ERC-20)

BUILD_EVM_ERC20_APPROVE_CALLDATA  (spender = bridge.approvalAddress)
        │
        ▼
BUILD_EVM_TRANSACTION  →  SIGN_EVM_TRANSACTION  →  BROADCAST_EVM_TRANSACTION  →  WAIT_FOR_EVM_TRANSACTION
        │
        ▼
BRIDGE_EVM_TOKENS
        │
        ▼
BUILD_EVM_TRANSACTION  →  SIGN_EVM_TRANSACTION  →  BROADCAST_EVM_TRANSACTION  →  WAIT_FOR_EVM_TRANSACTION
        │
        ▼ (decentralized message layer settles on destination)
Tokens land at `recipient` on the destination chain within `estimatedFinalitySec`.

For native-ETH bridges, drop the first APPROVE → BUILD → SIGN → BROADCAST → WAIT block — BRIDGE_EVM_TOKENS covers everything in a single source-chain transaction with value set appropriately.