Fuel

Execute deposit transactions on the Fuel network using pre-built script transactions from call_data.

Overview

Fuel deposits use a script-based transaction model. The Layerswap API returns a pre-built script transaction in call_data that you need to deserialize, fund with the required coin quantities, and submit.

Prerequisites:

• fuels (Fuel TypeScript SDK) for transaction construction and wallet interaction

Supported networks: Fuel Mainnet, Fuel Testnet

call_data Format

For Fuel, call_data is a JSON string containing two fields:

{
  "script": { /* ScriptTransactionRequest object */ },
  "quantities": [
    { "amount": "1000000", "assetId": "0x..." }
  ]
}

• script — A serialized ScriptTransactionRequest object containing the transaction script, inputs, outputs, and other parameters.
• quantities — An array of coin quantities required to fund the transaction (covers the transfer amount and fees).

Transaction Construction

1. Parse call_data

   Deserialize the JSON string and extract the script and quantities fields.

2. Reconstruct the ScriptTransactionRequest

   Use ScriptTransactionRequest.from() to create a proper transaction request object from the serialized data.

3. Estimate and fund

   Call estimateAndFund() on the transaction with the wallet and required quantities. This estimates gas costs and adds the necessary coin inputs.

4. Simulate (optional)

   Simulate the transaction against the Fuel provider to verify it will succeed before sending.

5. Send the transaction

   Submit the transaction through the Fuel wallet and get the transaction ID.

Full Example

Pick the flavor that matches your setup. The Server-side tab signs with a raw private key. The Browser tab uses the Fuel Wallet extension via the Fuel connector. The @fuels/react tab wraps it as a hook for React apps.

Server-side

import {
  Provider,
  Wallet,
  ScriptTransactionRequest,
  coinQuantityfy,
} from "fuels";

async function executeFuelDeposit(
  depositAction: any,
  privateKey: string
) {
  const { call_data, network } = depositAction;

  // Connect to the Fuel provider
  const provider = new Provider(network.node_url);
  const wallet = Wallet.fromPrivateKey(privateKey, provider);

  // Parse the call_data
  const parsedCallData = JSON.parse(call_data);

  // Reconstruct the script transaction
  const scriptTransaction = ScriptTransactionRequest.from(
    parsedCallData.script
  );

  // Parse coin quantities
  const quantities = parsedCallData.quantities.map((q: any) =>
    coinQuantityfy(q)
  );

  // Estimate gas and fund the transaction with required coins
  await scriptTransaction.estimateAndFund(wallet, { quantities });

  // Simulate to verify (optional but recommended)
  await provider.simulate(scriptTransaction);

  // Send the transaction
  const response = await wallet.sendTransaction(scriptTransaction);

  return response.id;
}

import {
  Provider,
  ScriptTransactionRequest,
  coinQuantityfy,
} from "fuels";

async function executeFuelDeposit(
  depositAction: any,
  fuel: any, // Fuel instance from @fuels/react
  senderAddress: string
) {
  const { call_data, network } = depositAction;

  const provider = new Provider(network.node_url);
  const wallet = await fuel.getWallet(senderAddress, provider);

  if (!wallet) {
    throw new Error("Fuel wallet not found");
  }

  const parsedCallData = JSON.parse(call_data);
  const scriptTransaction = ScriptTransactionRequest.from(
    parsedCallData.script
  );
  const quantities = parsedCallData.quantities.map((q: any) =>
    coinQuantityfy(q)
  );

  await scriptTransaction.estimateAndFund(wallet, { quantities });

  // Simulate first
  await provider.simulate(scriptTransaction);

  // Send through the browser wallet
  const response = await wallet.sendTransaction(scriptTransaction);

  return response.id;
}

import { useFuel } from "@fuels/react";
import {
  Provider,
  ScriptTransactionRequest,
  coinQuantityfy,
} from "fuels";

function useFuelDeposit() {
  const { fuel } = useFuel();

  async function executeDeposit(
    depositAction: any,
    senderAddress: string
  ): Promise<string> {
    if (!fuel) {
      throw new Error("Fuel not initialized");
    }

    const { call_data, network } = depositAction;

    const provider = new Provider(network.node_url);
    const wallet = await fuel.getWallet(senderAddress, provider);

    if (!wallet) {
      throw new Error("Fuel wallet not found");
    }

    const parsedCallData = JSON.parse(call_data);
    const scriptTransaction = ScriptTransactionRequest.from(
      parsedCallData.script
    );
    const quantities = parsedCallData.quantities.map((q: any) =>
      coinQuantityfy(q)
    );

    await scriptTransaction.estimateAndFund(wallet, { quantities });
    await provider.simulate(scriptTransaction);

    const response = await wallet.sendTransaction(scriptTransaction);
    return response.id;
  }

  return { executeDeposit };
}

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.