Send Binary Transactions

Key Improvements Include:

1. No Base64 Encoding/Decoding Overhead

2. No Packet Splitting due to reduced data size

3. Reduced Transmission time

Key points

• Create Transaction in raw binary format

• Header is optional

• Mandatory to add api-key and method in URI params

• Send request on endpoint /irisb

URI Params

Param	Type	Description
api-key	String	Mandatory, To set api key for authentication
method	String	Mandatory, To set method
mev-protect	Boolean	Optional, To set mev protect, default is false
swqos-only	Boolean	Optional, if set true, txn will be only send via swqos, default is false

Methods

Method	REST Method	Description
sendTransaction	POST	To send binary transaction
sendBatch	POST	To send batch of up to 25 txns in binary
getHealth	POST	To keep connection alive

Send Transaction

Example Request

curl --location 'https://lim.gateway.astralane.io/irisb?api-key=APIKEY&method=sendTransaction' \
--data-binary @transaction.bin

Code Example :

Rust

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::builder()
        .build()?;

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("Content-Type", "application/octet-stream".parse()?); //Optional

    let irisb_transaction_bytes = bincode::serialize(&irisb_transaction)
        .context("Failed to serialize IrisB transaction to binary")?;

    let request = client.request(reqwest::Method::POST, "https://lim.gateway.astralane.io/irisb?api-key=APIKEY&method=sendTransaction")
        .headers(headers)
        .body(irisb_transaction_bytes);

    let response = request.send().await?;
    let body = response.text().await?;

    println!("{}", body);

    Ok(())
}

TypeScript

Expected Response

{
  "result": "5KtPn1LGuxhFiwjxErkxTb7XxtLVjFW9QjMpv3Y7gW1x..."
}

Status Code	Description
200	Request is successful
400	Request might have some issues

---

Send Batch

Request Body Format

The body is a raw binary stream (Content-Type: application/octet-stream). Each transaction is framed as:

[ 2 bytes: tx length (big-endian u16) ][ N bytes: bincode-serialized transaction ]

Transactions are concatenated back-to-back with no separators or envelope:

+--------+----------+--------+----------+-----+
| len_0  |   tx_0   | len_1  |   tx_1   | ... |
| u16 BE | bincode  | u16 BE | bincode  |     |
+--------+----------+--------+----------+-----+

Headers required:

• Content-Type: application/octet-stream

Example

Rust

use bincode;
use reqwest::Client;
use solana_sdk::{signature::Signature, transaction::Transaction};
use std::str::FromStr;

fn build_binary_body(transactions: &[Transaction]) -> Vec<u8> {
    let mut body = Vec::new();
    for tx in transactions {
        let tx_bytes = bincode::serialize(tx).expect("failed to serialize transaction");
        let len = tx_bytes.len() as u16;
        body.extend_from_slice(&len.to_be_bytes());
        body.extend_from_slice(&tx_bytes);
    }
    body
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let url = "https://lim.gateway.astralane.io/irisb?api-key=APIKEY&method=sendBatch";

    // Build your Vec<Transaction> however you like
    let transactions: Vec<Transaction> = vec![/* tx1, tx2, ... */];

    let binary_body = build_binary_body(&transactions);

    let client = Client::new();
    let response = client
        .post(url)
        .header("content-type", "application/octet-stream")
        .body(binary_body)
        .send()
        .await?;

    let status = response.status();
    let body_text = response.text().await?;

    if !status.is_success() {
        anyhow::bail!("request failed ({}): {}", status, body_text);
    }

    // Parse signatures from the response
    let parsed: serde_json::Value = serde_json::from_str(&body_text)?;

    let sig_array = parsed["result"]
        .as_array()
        .or_else(|| parsed.as_array())
        .expect("unexpected response format");

    let signatures: Vec<Signature> = sig_array
        .iter()
        .map(|v| {
            let s = v.as_str().expect("signature must be a string");
            Signature::from_str(s).expect("invalid signature")
        })
        .collect();

    for (i, sig) in signatures.iter().enumerate() {
        println!("tx[{}] signature: {}", i, sig);
    }

    Ok(())
}

Typescript

Response

The server returns JSON. The result field is an array of signatures, one per transaction in the order they were sent:

{
  "result": [
    "5KtPn1LGuxhFiwjxErkxTb7XxtLVjFW9QjMpv3Y7gW1x...",
    "3RmHNpos7e4Bs3Y8j4Q1fGj5M5kPnxUeFNkMWv2jZrw5..."
  ]
}

• Array length matches the number of transactions sent.

• Signatures are in the same order as the transactions in the request body.