🚀Achieve Best Performance for Landing a Transaction

To achieve the best performance for landing a singular transaction (landing speed and inclusion rate), your transaction should include a Priority Fee & a Tip.

When calling the submitting endpoint, do NOT use the frontRunningProtection option or there is a good chance that your transaction will be delayed. Make sure your transaction includes a good Priority Fee & a Tip. If you are not Enterprise-Elite or higher tier, your transaction is required to have a bloXroute memo instruction.

In addition, Trader API offers some additional parameters to enhance the propagation of your transactions, like staked connections. Your bloXroute subscription tier will also affect how many channels will be used for propagation, which affects the propagation time.

Follow the steps below for best practice for getting the optimal performance:

Priority fee

Make sure your transaction includes the priory fee by adding computePrice Instruction. You can use the Priority Fee Stream to get the current recommended priority fee.

TypeScript

const modifyComputeUnits = ComputeBudgetProgram.setComputeUnitLimit({ 
  units: 1000000 
});

const addPriorityFee = ComputeBudgetProgram.setComputeUnitPrice({ 
  microLamports: 1 
});

const transaction = new Transaction()
.add(modifyComputeUnits)
.add(addPriorityFee)
...
  );

Rust

let txn = submit_transaction(
  &connection,
  &wallet_signer,
  // Array of instructions: 0: Set Compute Unit Limt, 1: Set Prioritization Fee, 
  // 2: Do something, 3: Do something else
  [ComputeBudgetInstruction::set_compute_unit_limit(1_000_000u32),
  ComputeBudgetInstruction::set_compute_unit_price(1u32),
  ...
)?;

tip Instruction

If you want to get the optimal performance you need to include a tip instruction. The Trader API service fee will be determined by the different features you will use (such as stacked connection, on-demand TPUs etc) so make sure to include a high enough tip.

Go

import (
	"github.com/gagliardetto/solana-go"
	"github.com/gagliardetto/solana-go/programs/system"
)

const (
	// BloxrouteTipAddress is from here and may fall out of date from time to time. Check our docs:
	// https://docs.bloxroute.com/solana/trader-api-v2/front-running-protection-and-transaction-bundle
	BloxrouteTipAddress = "HWEoBxYs7ssKuudEjzjmpfJVX7Dvi7wescFsVx2L5yoY"
)

// CreateBloxrouteTipTransactionToUseBundles creates a transaction you can use to when using PostSubmitBundle endpoints.
// This transaction should be the LAST transaction in your submission bundle
func CreateBloxrouteTipTransactionToUseBundles(privateKey solana.PrivateKey, tipAmount uint64, recentBlockHash solana.Hash) (*solana.Transaction, error) {
	recipient := solana.MustPublicKeyFromBase58(BloxrouteTipAddress)

	tx, err := solana.NewTransaction([]solana.Instruction{
		system.NewTransferInstruction(tipAmount, privateKey.PublicKey(), recipient).Build()}, recentBlockHash)
	if err != nil {
		return nil, err
	}

	signatures, err := tx.Sign(func(key solana.PublicKey) *solana.PrivateKey {
		if key.Equals(privateKey.PublicKey()) {
			return &privateKey
		}
		return nil
	})
	if err != nil {
		return nil, err
	}

	tx.Signatures = signatures

	return tx, nil
}

TypeScript

import {
    Keypair,
    PublicKey,
    Transaction,
    TransactionInstruction,
    MessageCompiledInstruction,
    VersionedTransaction,
    SystemProgram,
} from "@solana/web3.js"

// check documentation for latest tip wallet, and how to send tip transactions
// https://docs.bloxroute.com/solana/trader-api-v2/front-running-protection-and-transaction-bundle
const TRADER_API_TIP_WALLET = "HWEoBxYs7ssKuudEjzjmpfJVX7Dvi7wescFsVx2L5yoY"

// createTraderAPIMemoInstruction generates a transaction instruction that places a memo in the transaction log
// Having a memo instruction with signals Trader-API usage is required
export function CreateTraderAPITipInstruction(
    senderAddress: PublicKey,
    tipAmount: number
): TransactionInstruction {
    const tipAddress = new PublicKey(TRADER_API_TIP_WALLET)

    return SystemProgram.transfer({
        fromPubkey: senderAddress,
        toPubkey: tipAddress,
        lamports: tipAmount,
    })
}

Python

from numpy import uint64
from solders import pubkey as pk
from solders import instruction as inst
from solders import transaction as solders_tx
from solders.hash import Hash
from solders.keypair import Keypair
from solders.message import Message
from solders.pubkey import Pubkey
from solders.system_program import transfer, TransferParams
from solders.transaction import Transaction

# as of 2/12/2024, this is the bloxRoute tip wallet... check docs to see latest up to date tip wallet:
# https://docs.bloxroute.com/solana/trader-api-v2/front-running-protection-and-transaction-bundle
BloxrouteTipWallet = pk.Pubkey.from_string(
    "HWEoBxYs7ssKuudEjzjmpfJVX7Dvi7wescFsVx2L5yoY"
)


# create_trader_api_tip_instruction creates a tip instruction to send to bloxRoute. This is used if a user wants to send
# bundles or wants front running protection. If using bloXroute API, this instruction must be included in the last
# transaction sent to the API
def create_trader_api_tip_instruction(
    tip_amount: uint64,
    sender_address: Pubkey,
) -> inst.Instruction:
    instruction = transfer(
        TransferParams(
            from_pubkey=sender_address,
            to_pubkey=BloxrouteTipWallet,
            lamports=int(tip_amount),
        )
    )

    return instruction

If your language of choice is not included above, you can create an instruction referencing our tip-receiving address: HWEoBxYs7ssKuudEjzjmpfJVX7Dvi7wescFsVx2L5yoY.

Submit the transaction

Submit your transaction to Trader API using the Submit Endpoint. Make sure frontRunningProtection is set to False.

For best performance and assuming you included a high enough tip and set useStakedRPC to True

HTTP

curl -X 'POST' \
  'https://ny.solana.dex.blxrbdn.com/api/v2/submit' \
  -header "Authorization: $AUTH_HEADER" \
  -d '{
 "transaction": {"content": "AjF+Br2CUIENJqV1...BAAABCQ=="},
 "frontRunningProtection": false,
 "useStakedRPCs": true,
}'

WebSocket

wscat -c wss://ny.solana.dex.blxrbdn.com/ws --execute '{"jsonrpc": "2.0", "id": 1, "method": "PostSubmit", "params": {
  "transaction": {"content": "AjF+Br2CU...AMBAAABCQ=="},
   "frontRunningProtection": false,
   "useStakedRPCs": true,
}}'

Python

# submitting raw transactions
await api.post_submit(
    post_submit_request=proto.PostSubmitRequest(
        transaction=proto.TransactionMessage(content=signed_tx),
        front_running_protection=False,
        use_staked_RPCs=True
)

TypeScript

await provider.postSubmit({
    transaction: { content: encodedTxn, isCleanup: false },
    frontRunningProtection: false,
    useStakedRPCs: true,
})

If you are not an Elite or Ultra user, your transaction must include the bloXroute Memo Instruction.

Construct Memo Program Instruction by yourself

Our SDKs include hooks for adding this instruction for successful submission:

Go

import "github.com/gagliardetto/solana-go"

// AddMemoToSerializedTxn adds memo instruction to a serialized transaction, it's primarily used if the user
// doesn't want to interact with Trader-API directly
func AddMemoToSerializedTxn(
	txBase64, 
	memoContent string,
	owner solana.PublicKey, 
	privateKeys map[solana.PublicKey]solana.PrivateKey
) (string, error) {}
	
// CreateTraderAPIMemoInstruction generates a transaction instruction that places a memo in the transaction log
// Having a memo instruction with signals Trader-API usage is required
func CreateTraderAPIMemoInstruction(msg string) solana.Instruction {}

Python

from solana import transaction as solana_transaction

# create_trader_api_memo_instruction generates a transaction instruction that places a memo in the transaction log
# Having a memo instruction with signals Trader-API usage is required
def create_trader_api_memo_instruction(
    msg: str,
) -> solana_transaction.TransactionInstruction:
    # ...

# add_memo_to_serialized_txn adds memo instruction to a serialized transaction, it's primarily used if the user
# doesn't want to interact with Trader-API directly
def add_memo_to_serialized_txn(
    tx_base64: str, memo_content: str, owner: PublicKey, *private_keys: Keypair
) -> str:
    # ...

TypeScript

export function createTraderAPIMemoInstruction(msg: string): TransactionInstruction {

export function addMemoToSerializedTxn(txBase64: string, memoContent: string, owner: PublicKey, signer: Keypair): string {

If your language of choice is not included above, you can create an instruction referencing program HQ2UUt18uJqKaQFJhgV9zaTdQxUZjNrsKFgoEDquBkcx, with any data as the body. Make sure the memo_content is exactly "Powered by bloXroute Trader Api".