Public Transactions

The blxr_tx endpoint allows users to send a single transaction faster than the p2p network using the BDN. The endpoint returns a transaction hash.

This service is available via both the Cloud API and Gateway API.

The bloXroute best practice is for users to send transactions to both the Gateway-API and to their blockchain node. You should send transactions in parallel to the Gateway and to your blockchain node as a backup.

For latency-sensitive orderflow, WebSocket is recommended and can provide latency improvement over HTTP/HTTPS. If you prefer to short-lived connections, use HTTP over HTTPS for improved latency.

Submission Endpoint

Method: blxr_tx
Cloud API Endpoint: api.blxrbdn.com
Gateway API Endpoint: 127.0.0.1:28333/ws (assumes WebSocket port 28333)
Request type: HTTPS,WSS

Parameters

Parameter

Description

Instructions & Notes

transaction

Raw transactions bytes without 0x prefix.

Mandatory. Learn more about constructing the transaction here.

blockchain_network

Blockchain network name.

Mandatory. Use BSC-Mainnet for BSC Mainnet

*Use with Cloud-API when working with BSC.

node_validation

Transaction is sent to the blockchain node for validation, and the Gateway returns any error message received in response.

Available only with Gateway API

Optional

Default: False

Example

Cloud-API

wscat -c wss://api.blxrbdn.com/ws --header "Authorization: <YOUR-AUTHORIZATION-HEADER>"
> {"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params": 
  {"transaction": "f86b0184...e0b58219",
   "blockchain_network": "BSC-Mainnet"}}
< ....

const WebSocket = require('ws');

const ws = new WebSocket(
  "wss://api.blxrbdn.com/ws", 
  {
    headers: { 
      "Authorization" : <YOUR-AUTHORIZATION-HEADER>  
    },
    rejectUnauthorized: false,
  }
);

function proceed() {
    // ETH Example
    ws.send(`{"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params": {"transaction": "f86b0184...e0b58219"}}`);
    // BSC Example
    // ws.send(`{"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params": {"transaction": "f86b0184...e0b58219", "blockchain_network": "BSC-Mainnet"}}`);
    //
    // or use a variable for the transaction string:
    // rawTx = "f86b0184...e0b58219";
    // ws.send(`{"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params": {"transaction": "${rawTx}"}}`);
}


function handle(response) {
    console.log(response.toString()); // or process it generally
}

ws.on('open', proceed);
ws.on('message', handle);

# Python 3.7 or higher required due to the use of asyncio.run()
import asyncio, json, ssl
from websocket import create_connection

async def main():
    try:
        ws = create_connection('wss://api.blxrbdn.com/ws',
                               header=["Authorization:{}".format("YOUR_AUTHORIZATION_HEADER")],
                               sslopt={"cert_reqs": ssl.CERT_NONE})
        # ETH Example
        request = json.dumps({"id": 1, "method": "blxr_tx", "params": {"transaction": "f86b0184...e0b58219"}})
        
        # BSC Example
        request = json.dumps({"id": 1, "method": "blxr_tx", "params": {"transaction": "f86b0184...e0b58219", "blockchain_network": "BSC-Mainnet"}})
        
        ws.send(str(request))
        while True:
            response = json.loads(ws.recv())
            print(response) # or process it generally
    except Exception as e:
        print(f'Connection failed, Reason: {e}')


if __name__ == '__main__':
    asyncio.run(main()

package main

import (
	"crypto/tls"
	"fmt"
	"github.com/gorilla/websocket"
	"net/http"
)

func main() {
	tlsConfig := &tls.Config{
		InsecureSkipVerify: true,
	}
	dialer := websocket.DefaultDialer
	dialer.TLSClientConfig = tlsConfig
	wsSubscriber, _, err := dialer.Dial("wss://api.blxrbdn.com/ws", http.Header{"Authorization": []string{<YOUR-AUTHORIZATION-HEADER>}})

	if err != nil {
		fmt.Println(err)
		return
	}

        // ETH Example
	request := `{"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params": {"transaction": "f86b0184...e0b58219"}}`
        // BSC Example
        // request := `{"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params": {"transaction": "f86b0184...e0b58219", "blockchain_network": "BSC-Mainnet"}}`
	err = wsSubscriber.WriteMessage(websocket.TextMessage, []byte(request))
	if err != nil {
		fmt.Println(err)
		return
	}

	_, response, err := wsSubscriber.ReadMessage()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(string(response)) // or process it generally
}

# ETH Example
curl https://api.blxrbdn.com \
    -X POST \
    -H "Content-Type: application/json" \
    -H "Authorization: <YOUR-AUTHORIZATION-HEADER>" \
    -d '{"method": "blxr_tx", "id": "1", "params": {"transaction": "f86b0184...e0b58219"}}'

# BSC Example
curl https://api.blxrbdn.com \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: <YOUR-AUTHORIZATION-HEADER>" \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "blxr_tx",
    "params": {
      "transaction": "f86b0184...e0b58219",
      "blockchain_network": "BSC-Mainnet",
      "backrunme_reward_address": "0xYourRewardAddressHere"
    }
  }'

Gateway-API:

# ETH Example
wscat -c ws://127.0.0.1:28333/ws --header "Authorization: <YOUR-AUTHORIZATION-HEADER>"
> {"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params":
   {"transaction": "f86b0184...e0b58219"}}
< ......

const WebSocket = require('ws');

const ws = new WebSocket(
  "ws://127.0.0.1:28333/ws", 
  {
    headers: { 
      "Authorization" : <YOUR-AUTHORIZATION-HEADER>
    },
    rejectUnauthorized: false,
  }
);

function proceed() {
    // ETH Example
    ws.send(`{"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params": {"transaction": "f86b0184...e0b58219"}}`);
    // BSC Example
    // ws.send(`{"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params": {"transaction": "f86b0184...e0b58219", "blockchain_network": "BSC-Mainnet"}}`);
    //
    // or use a variable for the transaction string:
    // rawTx = "f86b0184...e0b58219";
    // ws.send(`{"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params": {"transaction": "${rawTx}"}}`);
}


function handle(response) {
    console.log(response.toString()); // or process it generally
}

ws.on('open', proceed);
ws.on('message', handle);

# Python 3.7 or higher required due to the use of asyncio.run()
import asyncio, json, ssl
from websocket import create_connection

async def main():
    try:
        ws = create_connection('ws://127.0.0.1:28333/ws',
                               header=["Authorization:{}".format("YOUR_AUTHORIZATION_HEADER")],
                               sslopt={"cert_reqs": ssl.CERT_NONE})
        # ETH Example
        request = json.dumps({"id": 1, "method": "blxr_tx", "params": {"transaction": "f86b0184...e0b58219"}})
        
        # BSC Example
        request = json.dumps({"id": 1, "method": "blxr_tx", "params": {"transaction": "f86b0184...e0b58219", "blockchain_network": "BSC-Mainnet"}})
        
        ws.send(str(request))
        while True:
            response = json.loads(ws.recv())
            print(response) # or process it generally
    except Exception as e:
        print(f'Connection failed, Reason: {e}')

package main

import (
	"crypto/tls"
	"fmt"
	"github.com/gorilla/websocket"
	"net/http"
)

func main() {
	tlsConfig := &tls.Config{
		InsecureSkipVerify: true,
	}
	dialer := websocket.DefaultDialer
	dialer.TLSClientConfig = tlsConfig
	wsSubscriber, _, err := dialer.Dial("ws://127.0.0.1:28333/ws", http.Header{"Authorization": []string{<YOUR-AUTHORIZATION-HEADER>}})

	if err != nil {
		fmt.Println(err)
		return
	}

  // ETH Example
	request := `{"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params": {"transaction": "f86b0184...e0b58219"}}`
  // BSC Example
  // request := `{"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params": {"transaction": "f86b0184...e0b58219", "blockchain_network": "BSC-Mainnet"}}`
	err = wsSubscriber.WriteMessage(websocket.TextMessage, []byte(request))
	if err != nil {
		fmt.Println(err)
		return
	}

	_, response, err := wsSubscriber.ReadMessage()
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(string(response)) // or process it generally
}

 main

import (
	"context"
	"fmt"
	"time"
	
	pb "github.com/bloXroute-Labs/bxgateway-private-go/bxgateway/v2/protobuf"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
)

func main() {
	// gRPC server default values
	gatewayHostIP := "127.0.0.1"
	gatewayGRPCPort := 5001
	
	// this will use localhost CA to verify the certificate
	creds := credentials.NewClientTLSFromCert(nil, "")

	// Open gRPC connection to Gateway.
	conn, _ := grpc.Dial(
		fmt.Sprintf("%v:%v", gatewayHostIP, gatewayGRPCPort), 
		grpc.WithTransportCredentials(creds),
	)

	// Use the Gateway client connection interface. 
	client := pb.NewGatewayClient(conn)
	
	// create context and defer cancel of context
	callContext, cancel := context.WithTimeout(context.Background(), 24*time.Hour)
	defer cancel()
	
	// send tx
	reply, err := client.BlxrTx(callContext, &pb.BlxrTxRequest{AuthHeader: "<YOUR-AUTHORIZATION-HEADER>", Transaction: "f86b0184...e0b58219"})
	if err != nil {
		print(err)
		return
	}
	
	txHash := reply.TxHash
	print(txHash) // or process it generally
}

Response

{
    "jsonrpc": "2.0", 
    "id": "1", 
    "result": {
        "tx_hash": "ffd59870844e5...bfa54a69"
    }
}

PreviousPrivate Transactions NextTx-Trace

Last updated 2 days ago

hashtagSubmission Endpoint

hashtagParameters

hashtagExample

hashtagCloud-API

hashtagGateway-API:

hashtagResponse