Solana

Execute deposit transactions on Solana by deserializing and signing the pre-built transaction from call_data.

Overview

Solana deposits are straightforward because the Layerswap API returns a fully constructed, serialized transaction in call_data. You only need to decode it, set a fresh blockhash, sign it, and send it.

Prerequisites:

• @solana/web3.js for transaction handling and RPC communication

call_data Format

For Solana, call_data is a base64-encoded serialized Transaction. It contains all the instructions, accounts, and program IDs already set up by the Layerswap backend — including SPL token transfers when applicable.

// Node.js / server-side
const buffer = Buffer.from(callData, "base64");
const transaction = Transaction.from(buffer);

// Browser
const buffer = Uint8Array.from(atob(callData), (c) => c.charCodeAt(0));
const transaction = Transaction.from(buffer);

The pre-built transaction includes a top-level SPL Memo instruction whose UTF-8 content is the swap’s metadata.sequence_number — this is how Layerswap matches your deposit to the swap (the Solana equivalent of Bitcoin’s OP_RETURN), and it works identically for native SOL and SPL-token deposits. Refreshing the blockhash and signing is expected, but don’t drop or alter the instructions — a deposit that reaches to_address without the memo won’t be matched and the swap will expire. Submitting call_data as-is guarantees the memo is present and correct.

Transaction Construction

1. Decode the transaction

   Convert the base64 call_data string into a Transaction object.

2. Set a fresh blockhash

   Fetch the latest blockhash from the Solana RPC and update the transaction. This ensures the transaction doesn’t expire before it’s confirmed.

3. Validate balances (optional)

   Estimate the transaction fee and verify the sender has enough SOL for fees and enough of the source token for the transfer amount.

4. Sign the transaction

   Sign the transaction with the sender’s keypair or wallet adapter.

5. Send and confirm

   Submit the signed transaction to the network and wait for confirmation.

Full Example

The Server-side tab signs locally with a Keypair. The Browser tab uses a connected wallet adapter (Phantom, Solflare, etc.) and its signTransaction method.

Server-side

import {
  Connection,
  Transaction,
  Keypair,
  LAMPORTS_PER_SOL,
  sendAndConfirmTransaction,
} from "@solana/web3.js";
import bs58 from "bs58";

async function executeSolanaDeposit(
  depositAction: any,
  senderKeypair: Keypair
) {
  const { call_data, network } = depositAction;

  const connection = new Connection(network.node_url, "confirmed");

  // Decode base64 call_data into a Transaction
  const buffer = Buffer.from(call_data, "base64");
  const transaction = Transaction.from(buffer);

  // Set a fresh blockhash
  const { blockhash, lastValidBlockHeight } =
    await connection.getLatestBlockhash();
  transaction.recentBlockhash = blockhash;
  transaction.lastValidBlockHeight = lastValidBlockHeight;

  // Send and confirm
  const signature = await sendAndConfirmTransaction(
    connection,
    transaction,
    [senderKeypair],
    { commitment: "confirmed" }
  );

  return signature;
}

Sending with Retry Logic

Solana transactions can sometimes fail to land due to network congestion. A robust implementation resends the transaction periodically until it’s confirmed or the blockhash expires:

import { Connection, Transaction } from "@solana/web3.js";

async function sendWithRetry(
  connection: Connection,
  serializedTx: Buffer,
  blockhash: string,
  lastValidBlockHeight: number
): Promise<string> {
  const txid = await connection.sendRawTransaction(serializedTx, {
    skipPreflight: true,
  });

  const controller = new AbortController();

  // Resend every 2 seconds in the background
  const resendLoop = async () => {
    while (!controller.signal.aborted) {
      await new Promise((r) => setTimeout(r, 2000));
      if (controller.signal.aborted) return;
      try {
        await connection.sendRawTransaction(serializedTx, {
          skipPreflight: true,
        });
      } catch {
        // Ignore resend errors
      }
    }
  };
  resendLoop();

  try {
    await connection.confirmTransaction(
      { signature: txid, blockhash, lastValidBlockHeight },
      "confirmed"
    );
  } finally {
    controller.abort();
  }

  return txid;
}

Building the transaction yourself

If you construct the deposit transaction yourself instead of submitting call_data, you must satisfy both conditions, or the deposit won’t be matched:

1. Send the funds to to_address — native SOL via the System program, or SPL tokens to the recipient’s associated token account.
2. Add the swap’s metadata.sequence_number as a top-level instruction through the SPL Memo program. A memo emitted from inside another program (via CPI / inner instruction) is not read.

import { PublicKey, TransactionInstruction } from "@solana/web3.js";

// SPL Memo program (the same program id Layerswap uses in its own deposit transactions)
const MEMO_PROGRAM_ID = new PublicKey("Memo1UhkJRfHyvLMcVucJwxXeuD728EqVDDwQDxFMNo");

// swap.metadata.sequence_number from the POST /api/v2/swaps response
const memoInstruction = new TransactionInstruction({
  keys: [{ pubkey: sender, isSigner: true, isWritable: true }],
  programId: MEMO_PROGRAM_ID,
  data: Buffer.from(String(swap.metadata.sequence_number), "utf8"),
});

transaction.add(transferInstruction);
transaction.add(memoInstruction); // top-level, alongside the transfer

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.