Layerswap Docs

For the standard Tron transfer flow, construct a TRC-20 transfer(address,uint256) transaction and add the returned call_data as UTF-8 transaction data. Layerswap uses that memo to match the deposit. Supported networks: Tron Mainnet, Tron Testnet (Shasta/Nile)

Full example

The Server-side tab signs with a raw private key. The Browser tab uses a Tron wallet adapter (TronLink and similar) and its signTransaction method.

import { TronWeb } from 'tronweb';

function utf8ToHex(value: string) {
  return Array.from(new TextEncoder().encode(value))
    .map((byte) => byte.toString(16).padStart(2, '0'))
    .join('');
}

async function executeTronDeposit(action, senderAddress, privateKey) {
  if (!action.token.contract) {
    throw new Error('This example requires a TRC-20 action');
  }

  const tronWeb = new TronWeb({
    fullNode: action.network.node_url,
    solidityNode: action.network.node_url,
    privateKey,
  });

  const { transaction: unsigned } =
    await tronWeb.transactionBuilder.triggerSmartContract(
      action.token.contract,
      'transfer(address,uint256)',
      { feeLimit: 100_000_000 },
      [
        { type: 'address', value: action.to_address },
        { type: 'uint256', value: String(action.amount_in_base_units) },
      ],
      senderAddress,
    );

  const withMemo = await tronWeb.transactionBuilder.addUpdateData(
    unsigned,
    utf8ToHex(action.call_data),
    'hex',
  );

  const signed = await tronWeb.trx.sign(withMemo);
  const result = await tronWeb.trx.sendRawTransaction(signed);

  if (!result.result) {
    throw new Error(result.message || 'Tron broadcast failed');
  }
  return signed.txID;
}

import { TronWeb } from 'tronweb';

function utf8ToHex(value: string) {
  return Array.from(new TextEncoder().encode(value))
    .map((byte) => byte.toString(16).padStart(2, '0'))
    .join('');
}

async function executeTronDeposit(action, senderAddress, signTransaction) {
  if (!action.token.contract) {
    throw new Error('This example requires a TRC-20 action');
  }

  const tronWeb = new TronWeb({
    fullNode: action.network.node_url,
    solidityNode: action.network.node_url,
  });

  const { transaction: unsigned } =
    await tronWeb.transactionBuilder.triggerSmartContract(
      action.token.contract,
      'transfer(address,uint256)',
      { feeLimit: 100_000_000 },
      [
        { type: 'address', value: action.to_address },
        { type: 'uint256', value: String(action.amount_in_base_units) },
      ],
      senderAddress,
    );

  const withMemo = await tronWeb.transactionBuilder.addUpdateData(
    unsigned,
    utf8ToHex(action.call_data),
    'hex',
  );

  const signed = await signTransaction(withMemo);
  const result = await tronWeb.trx.sendRawTransaction(signed);

  if (!result.result) {
    throw new Error(result.message || 'Tron broadcast failed');
  }
  return signed.txID;
}

Set the fee limit according to your integration’s Tron policy. The example value is a cap, not an estimate. Using amount_in_base_units as a string avoids float rounding.

Funding via the Depository

The examples above cover the standard transfer flow. If the swap was created with use_depository: true, the action targets Layerswap’s on-chain Depository contract instead of carrying the standard-transfer memo. On Tron the Depository supports TRC-20 tokens only — approve the contract, then call depositERC20:

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

See Funding methods for when to use each. Store the transaction id and track the swap.

Start here

Funding

Operations

Recipes

Endpoints

Tron

Full example

Funding via the Depository

​Full example

​Funding via the Depository

Full example

Funding via the Depository