Layerswap Docs

For supported routes, the API returns a Depository contract address and encoded call that a wallet or smart contract can use to fund the swap. This method works well for server wallets, batched calls, and sponsored transactions. The EVM contract has been audited by Hexens.

Create the swap

curl --request POST 'https://api.layerswap.io/api/v2/swaps' \
  --header 'Content-Type: application/json' \
  --header 'X-LS-APIKEY: YOUR_API_KEY' \
  --data '{
    "source_network": "ETHEREUM_MAINNET",
    "source_token": "USDC",
    "destination_network": "ARBITRUM_MAINNET",
    "destination_token": "USDC",
    "destination_address": "0xRecipient",
    "refund_address": "0xSourceNetworkRefundAddress",
    "amount": 100,
    "use_depository": true
  }'

Depository action fields

The response includes deposit_actions. For the contract action:

string

Depository contract address and, for ERC-20 deposits, the approval spender.

string

Encoded deposit call to submit unchanged.

string[] | null

Function argument values in call order. Use them to reconstruct the contract call when needed.

string

Native transaction value in base units. This is normally 0 for an ERC-20 call.

string | null

Gas estimate returned by the API, when available.

The API response is authoritative for the target and arguments.

Approve and submit the deposit action

EVM (viem)
Tron (TronWeb)

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
});

For native deposits, the approval is skipped and the returned amount_in_base_units is sent as value. Never replace the swap ID, receiver, or target embedded in call_data.

On Tron, the Depository supports TRC-20 actions. Approve action.to_address, wait for the approval to confirm, then call depositERC20 with the returned encoded_args:

TronWeb

import { TronWeb } from 'tronweb';

async function executeTronDepository(action, privateKey, waitForConfirmation) {
  const [id, , receiverHex, amountHex] = action.encoded_args; // [id, token, receiver, amount]
  const amount = BigInt(amountHex).toString();
  const tronWeb = new TronWeb({
    fullNode: action.network.node_url,
    solidityNode: action.network.node_url,
    privateKey,
  });
  const sender = tronWeb.defaultAddress.base58;

  // encoded_args carry EVM-style hex addresses — convert the receiver to a Tron address
  const receiver = tronWeb.address.fromHex(
    `41${receiverHex.replace(/^0x/, '')}`,
  );

  // 1) Approve the Depository (to_address) to spend the TRC-20 amount
  const approve = (await tronWeb.transactionBuilder.triggerSmartContract(
    action.token.contract,
    'approve(address,uint256)',
    { feeLimit: 100_000_000 },
    [
      { type: 'address', value: action.to_address },
      { type: 'uint256', value: amount },
    ],
    sender,
  )).transaction;
  const signedApprove = await tronWeb.trx.sign(approve);
  const approvalResult = await tronWeb.trx.sendRawTransaction(signedApprove);
  if (!approvalResult.result) throw new Error('TRC-20 approval failed');
  await waitForConfirmation(signedApprove.txID);

  // 2) Call depositERC20(bytes32 id, address token, address receiver, uint256 amount)
  //    on the Depository, after the approval confirms
  const deposit = (await tronWeb.transactionBuilder.triggerSmartContract(
    action.to_address,
    'depositERC20(bytes32,address,address,uint256)',
    { feeLimit: 100_000_000 },
    [
      { type: 'bytes32', value: id },
      { type: 'address', value: action.token.contract },
      { type: 'address', value: receiver },
      { type: 'uint256', value: amount },
    ],
    sender,
  )).transaction;
  const signedDeposit = await tronWeb.trx.sign(deposit);
  const depositResult = await tronWeb.trx.sendRawTransaction(signedDeposit);
  if (!depositResult.result) throw new Error('Depository transaction failed');
  return signedDeposit.txID;
}

The examples’ feeLimit and gas values are caps, not estimates — set them according to your execution policy. Do not reorder or replace the returned arguments.

Detect the deposit

Store the submitted transaction hash, then use GET /swaps/by_transaction_hash/{hash} or GET /swaps/{id}. The swap then follows the normal lifecycle. See the Privy server wallets recipe for batching approval and deposit in a sponsored server-wallet flow.

Start here

Funding

Operations

Recipes

Endpoints

Fund via the Depository contract

Create the swap

Depository action fields

Approve and submit the deposit action

Detect the deposit

​Create the swap

​Depository action fields

​Approve and submit the deposit action

​Detect the deposit

Create the swap

Depository action fields

Approve and submit the deposit action

Detect the deposit