EVM Chains

Execute deposit transactions on Ethereum, Arbitrum, Optimism, Base, Polygon, and other EVM-compatible networks.

Overview

This guide covers all EVM-compatible networks supported by Layerswap, including Ethereum, Arbitrum, Optimism, Base, Polygon, Linea, zkSync Era, Scroll, and others.

Prerequisites:

• viem (recommended) or ethers.js
• A wallet client or signer with funds on the source network

call_data Format

For EVM chains, call_data is a hex-encoded string (0x...) representing the transaction’s data field. It always carries a Layerswap memo (a fixed prefix followed by a sequence number) that the backend uses to match the deposit:

• Native token transfers (ETH, MATIC, etc.): call_data is the memo hex. to_address is the deposit address and amount / amount_in_base_units carry the value to send.
• ERC-20 token transfers: call_data is the encoded transfer(address,uint256) function call with the memo hex appended. to_address is the token contract, and amount / amount_in_base_units are 0 — the actual transfer value is encoded inside call_data.

In both cases, build the transaction with to: to_address, value: amount, and data: call_data and the wallet will route it correctly.

Transaction Construction

1. Parse the deposit action

   Extract call_data, to_address, amount, and network.chain_id from the deposit action.

2. Build the transaction

   Construct a transaction object with the deposit action fields mapped to standard EVM transaction parameters.

3. Estimate gas (optional)

   Call eth_estimateGas for a more accurate gas limit. If estimation fails, the transaction can still be sent without an explicit gas limit — the wallet or node will estimate it.

4. Send the transaction

   Sign and broadcast the transaction, then return the hash.

Full Example

Pick the library that fits your stack. The viem and ethers.js tabs cover server-side or Node.js usage. The wagmi tab is for browser-side use with a connected wallet.

viem

import { createWalletClient, createPublicClient, http, parseEther } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { mainnet, arbitrum, optimism, base, polygon } from "viem/chains";

const CHAIN_MAP = {
  1: mainnet,
  42161: arbitrum,
  10: optimism,
  8453: base,
  137: polygon,
  // Add other EVM chains as needed
};

async function executeEvmDeposit(depositAction, privateKey) {
  const { call_data, to_address, amount, network } = depositAction;
  const chainId = Number(network.chain_id);
  const chain = CHAIN_MAP[chainId];

  if (!chain) {
    throw new Error(`Unsupported chain ID: ${chainId}`);
  }

  const account = privateKeyToAccount(privateKey);

  const walletClient = createWalletClient({
    account,
    chain,
    transport: http(network.node_url),
  });

  const publicClient = createPublicClient({
    chain,
    transport: http(network.node_url),
  });

  // Estimate gas
  let gas;
  try {
    gas = await publicClient.estimateGas({
      account: account.address,
      to: to_address,
      value: parseEther(amount.toString()),
      data: call_data,
    });
  } catch (error) {
    console.warn("Gas estimation failed, proceeding without explicit gas limit");
  }

  // Send transaction
  const hash = await walletClient.sendTransaction({
    to: to_address,
    value: parseEther(amount.toString()),
    data: call_data,
    gas,
  });

  return hash;
}

import { ethers } from "ethers";

async function executeEvmDeposit(depositAction, privateKey) {
  const { call_data, to_address, amount, network } = depositAction;

  const provider = new ethers.JsonRpcProvider(network.node_url);
  const wallet = new ethers.Wallet(privateKey, provider);

  // Estimate gas
  let gasLimit;
  try {
    gasLimit = await provider.estimateGas({
      from: wallet.address,
      to: to_address,
      value: ethers.parseEther(amount.toString()),
      data: call_data,
    });
  } catch (error) {
    console.warn("Gas estimation failed, proceeding without explicit gas limit");
  }

  // Send transaction
  const tx = await wallet.sendTransaction({
    to: to_address,
    value: ethers.parseEther(amount.toString()),
    data: call_data,
    gasLimit,
  });

  return tx.hash;
}

import { sendTransaction } from "@wagmi/core";
import { parseEther } from "viem";

async function executeEvmDeposit(depositAction, wagmiConfig) {
  const { call_data, to_address, amount, network } = depositAction;

  const hash = await sendTransaction(wagmiConfig, {
    chainId: Number(network.chain_id),
    to: to_address,
    value: parseEther(amount.toString()),
    data: call_data,
  });

  return hash;
}

When using a browser wallet (wagmi), ensure the user is connected to the correct chain (network.chain_id). If not, prompt them to switch networks before sending the transaction.

Funding via the Depository

The example above covers the direct transfer and deposit address methods. If you created the swap with use_depository: true, the deposit action targets the on-chain Depository contract instead — submit its call_data, and for ERC-20 approve the contract first:

viem

import { createWalletClient, custom, parseAbi } from "viem";

// `swap` is the POST /api/v2/swaps response
const action = swap.deposit_actions[0];
const wallet = createWalletClient({ transport: custom(window.ethereum) });

// ERC-20 only: approve the Depository (to_address) to pull the tokens.
// The amount is the 4th depositERC20 argument, returned in encoded_args.
if (action.token.contract) {
  await wallet.writeContract({
    address: action.token.contract,
    abi: parseAbi(["function approve(address spender, uint256 amount) returns (bool)"]),
    functionName: "approve",
    args: [action.to_address, BigInt(action.encoded_args[3])],
  });
}

// Submit the prepared depositNative / depositERC20 call exactly as returned
await wallet.sendTransaction({
  to: action.to_address, // the Depository contract
  data: action.call_data,
  value: BigInt(action.amount_in_base_units), // 0 for ERC-20, the deposit amount for native
});

See Choosing a method for when to use each.

Next Step

After the transaction is submitted, notify Layerswap so it can match your deposit faster:

curl -X POST https://api.layerswap.io/api/v2/swaps/{swap_id}/deposit_speedup \
  -H "X-LS-APIKEY: your_api_key" \
  -H "Content-Type: application/json" \
  -d '{ "transaction_id": "YOUR_TX_HASH" }'

See the full deposit flow for details, or the Depository guide to fund via the on-chain contract (use_depository).