eth_sendRawTransaction

Introduce how to integrate BlockRazor Base RPC’s `eth_sendRawTransaction` method.

Base RPC is a transaction sending interface provided by BlockRazor for Base, used to send signed raw transactions. Currently, it only supports the eth_sendRawTransaction method and provides both gRPC and HTTPS.

Why choose BlockRazor Base RPC?

For Wallets and DEXs, directly connecting to the official Base Sequencer can meet basic sending requirements, but for businesses serving global users and focusing on cross-regional performance and production environment stability, the sending path itself still has room for further optimization. For a detailed comparison of BlockRazor Base RPC and the official sending service, please refer to the Benchmark.

Global multi-point deployment

Compared to directly connecting to the Base Sequencer, BlockRazor Base RPC provides sending entry points in multiple core regions, making it suitable for wallets and DEXs to choose the nearest endpoint based on their service deployment location. For businesses serving global users, sending entry points closer to business servers and core user regions typically help shorten request paths and improve transaction sending efficiency.

Intercontinental express lines

BlockRazor Base RPC's optimization focuses not only on ingress node deployment but also on data transmission links between regional relays. Compared to inter-regional forwarding methods that rely entirely on ordinary public network routing, intercontinental express lines can significantly reduce the impact of routing fluctuations, congestion, and link jitter in inter-relay transmission, improving the stability and consistency of transaction requests throughout the overall transmission routing.

Endpoint

gRPC

Region	Endpoint
Frankfurt	frankfurt.grpc.base.blockrazor.xyz:80
Virginia	virginia.grpc.base.blockrazor.xyz:80
Tokyo	tokyo.grpc.base.blockrazor.xyz:80

HTTPS

Price

User Type	Limit	Price
New registered users	1 Tx / 5s	免費
Paid users	5 Txs / 1s	$1000 / 月

Request Parameter

Parameter	Mandatory	Format	Example	Remark
rawTransaction	mandatory	string[hex]	"0xd46e8dd67c5d32be8d24c6b0afe7c5c3f4e9c3b2dae18d0c6b0cf5c8f3e8b2c1"	signed raw transaction

Request Example

gRPC

Access the example here

// sendTransactions is an example function for sending a transaction.
// It's designed to reuse an existing gRPC client connection to avoid connection latency.
func sendTransactions(client basepb.BaseApiClient, authToken string, rawTxString string) {
	log.Println("[SendTx] Sending transaction...")
	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()

	// Add the authentication token to the outgoing request's metadata.
	md := metadata.Pairs("authorization", authToken)
	ctx = metadata.NewOutgoingContext(ctx, md)

	req := &basepb.SendTransactionRequest{
		RawTransaction: rawTxString,
	}

	res, err := client.SendTransaction(ctx, req)
	if err != nil {
		log.Printf("[SendTx] Failed to send transaction: %v", err)
	} else {
		log.Printf("[SendTx] Transaction sent successfully. Hash: %s", res.GetTxHash())
	}
}

HTTPS

proto

syntax = "proto3";

option go_package = "./basepb";


import "google/protobuf/wrappers.proto";

message BaseBlock {
  string parent_hash = 1;
  string fee_recipient = 2;
  bytes state_root = 3;
  bytes receipts_root = 4;
  bytes logs_bloom = 5;
  bytes prev_randao = 6;
  uint64 block_number = 7;
  uint64 gas_limit = 8;
  uint64 gas_used = 9;
  uint64 timestamp = 10;
  bytes extra_data = 11;
  repeated uint64 base_fee_per_gas = 12;
  string block_hash = 13;
  repeated bytes transactions = 14;

  repeated Withdrawal withdrawals = 15;
  google.protobuf.UInt64Value blob_gas_used = 16;
  google.protobuf.UInt64Value excess_blob_gas = 17;
  google.protobuf.BytesValue withdrawals_root = 18;
}

message Withdrawal {
  uint64 index = 1;
  uint64 validator = 2;
  bytes address = 3;
  uint64 amount = 4;
}

message GetRawFlashBlocksStreamRequest {
}

message GetBlockStreamRequest {
}

message SendTransactionRequest {
  string rawTransaction = 1;
}

message SendTransactionResponse {
  string txHash = 1;
}

message FlashBlockStrRequest {
}

message RawFlashBlockStrResponse {
  bytes message = 1;
}

service BaseApi {
  rpc SendTransaction(SendTransactionRequest) returns (SendTransactionResponse);
  rpc GetBlockStream(GetBlockStreamRequest) returns (stream BaseBlock);
  rpc GetRawFlashBlockStream(GetRawFlashBlocksStreamRequest) returns (stream RawFlashBlockStrResponse);
}

Response

Normal

res: txHash:"0xaf430540d20eae2448947ffb254b03180b82333ef0c56bd526f7047489c195b5"

Abnormal

res: txHash:"Unknown TxHash"