🔌 Tronsell Wiki

RPC Infrastructure

Comprehensive guide to TRON's Remote Procedure Call (RPC) infrastructure. Learn about HTTP JSON-RPC, gRPC, load balancing, high availability, security, and scaling strategies for production RPC endpoints.

Updated: July 2025 ~13 min read Infrastructure · Advanced

🔌 RPC at a Glance

HTTP RPC Port 8090

gRPC Port 50051

Protocols HTTP + gRPC

Load Balancing Round Robin / Least Conn

HA Strategy Active-Active

Security TLS + Rate Limiting

🔌 RPC Infrastructure Overview

TRON's RPC (Remote Procedure Call) infrastructure is the gateway for applications, developers, and users to interact with the blockchain. It provides a standardized interface for querying blockchain data, submitting transactions, and interacting with smart contracts.

The RPC layer sits on top of the full node and exposes two primary interfaces:

HTTP JSON-RPC — REST-like endpoints on port 8090 for simple, language-agnostic access.
gRPC — High-performance, strongly-typed RPC on port 50051 using Protocol Buffers.

📌 RPC Importance

RPC infrastructure is critical for dApps, exchanges, wallets, and analytics platforms. It must be reliable, scalable, and secure to handle production workloads.

🧩 RPC Infrastructure Components

🌐

HTTP JSON-RPC

Port 8090. Simple REST endpoints for wallet, contract, and block operations. Easy to integrate with any programming language.

⚡

gRPC

Port 50051. High-performance RPC with Protocol Buffers. Supports streaming and bidirectional communication.

🔄

Load Balancer

Distributes RPC traffic across multiple nodes. Supports round-robin, least connections, and health checking.

🔒

API Gateway

Provides authentication, rate limiting, request logging, and TLS termination for RPC endpoints.

🌐 HTTP JSON-RPC Endpoints

The HTTP JSON-RPC API is the most accessible way to interact with a TRON node. All endpoints accept POST requests with a JSON body.

Common HTTP Endpoints

Endpoint	Method	Description
/wallet/getnowblock	POST	Get the current block header
/wallet/getaccount	POST	Get account balance and resources
/wallet/createtransaction	POST	Create a transfer transaction
/wallet/broadcasttransaction	POST	Broadcast a signed transaction
/wallet/triggersmartcontract	POST	Execute a smart contract method
/contract/deploycontract	POST	Deploy a smart contract

                    # Example HTTP RPC request
                    curl -X POST http://localhost:8090/wallet/getnowblock \
                      -H "Content-Type: application/json" -d '{}'
                

💡 HTTP vs gRPC

HTTP JSON-RPC is easier to use for quick prototyping and debugging. For production applications with high throughput, gRPC is recommended for its performance and type safety.

⚡ gRPC Infrastructure

gRPC is a modern RPC framework developed by Google. TRON uses gRPC for its high-performance API, offering significant advantages over HTTP JSON-RPC.

gRPC Features

Protocol Buffers — Binary serialization for smaller payloads and faster parsing.
Streaming — Support for server-streaming, client-streaming, and bidirectional streaming.
Type Safety — Strongly-typed interfaces generated from .proto files.
Multiplexing — Multiple calls over a single connection.

                    # Example gRPC call using grpcurl
                    grpcurl -plaintext localhost:50051 protocol.Wallet/GetNowBlock
                

gRPC Services

Wallet — Account, transaction, and block operations.
Contract — Smart contract deployment and execution.
Network — Node status, peer information.
Database — Historical data queries.

⚡ gRPC Performance

gRPC can handle 10x-100x more requests per second than HTTP JSON-RPC for the same hardware, making it the preferred choice for production RPC infrastructure.

⚖️ Load Balancing & High Availability

For production RPC infrastructure, a single node is a single point of failure. Load balancing distributes traffic across multiple nodes, ensuring reliability and scalability.

Load Balancing Strategies

Strategy	Description	Pros	Cons
Round Robin	Distributes requests evenly across nodes	Simple, fair distribution	Does not account for node load
Least Connections	Sends requests to the node with fewest active connections	Better load distribution under varying loads	Requires connection tracking
Health Check	Routes only to healthy nodes	Prevents routing to dead or lagging nodes	Adds monitoring overhead
Geo-aware	Routes to nodes closest to the client	Reduces latency	Requires geo-location data

Load Balancer Tools

Nginx — HTTP/gRPC load balancing with health checks.
HAProxy — High-performance TCP and HTTP load balancing.
Envoy — Modern edge proxy with advanced traffic management.
Cloud Load Balancers — AWS NLB, GCP Cloud Load Balancing.

                    # Example Nginx configuration for gRPC load balancing
                    upstream tron_grpc {
                      server node1:50051;
                      server node2:50051;
                      server node3:50051;
                    }
                    server {
                      listen 50051 http2;
                      location / {
                        grpc_pass grpc://tron_grpc;
                      }
                    }
                

📌 HA Architecture

For high availability, deploy at least 3–5 full nodes behind a load balancer. This provides redundancy and allows you to perform maintenance without downtime.

🔒 RPC Security

RPC endpoints are a primary attack vector. Securing them is critical for production deployments.

🔐

TLS/SSL

Encrypt all RPC traffic with TLS. Use valid certificates from a trusted CA. gRPC requires HTTP/2 over TLS.

🚦

Rate Limiting

Limit requests per IP or API key to prevent abuse and DDoS attacks. Implement at the gateway level.

🔑

Authentication

Use API keys or JWT tokens for authenticated endpoints. Restrict access to trusted applications.

🛡️

IP Whitelisting

Restrict RPC access to specific IP ranges or VPNs for internal services.

                    # Example Nginx rate limiting
                    limit_req_zone $binary_remote_addr zone=api:10m rate=10r/s;
                    server {
                      location /wallet/ {
                        limit_req zone=api burst=20;
                        proxy_pass http://tron_node:8090;
                      }
                    }
                

🔒 Security Checklist

✅ Enable TLS for all RPC traffic
✅ Implement rate limiting
✅ Use API keys for authentication
✅ Restrict IP ranges where possible
✅ Enable access logging and monitoring
✅ Regularly update TLS certificates

📈 Scaling RPC Infrastructure

As demand grows, your RPC infrastructure must scale. Here are strategies for scaling:

Horizontal Scaling — Add more full nodes behind the load balancer.
Read Replicas — Use dedicated nodes for read-only queries to reduce load on write-capable nodes.
Caching — Cache frequently accessed data (e.g., account balances) at the API gateway.
Connection Pooling — Reuse gRPC connections to reduce overhead.
Geo-distribution — Deploy nodes in multiple regions to reduce latency for global users.

📊 Monitoring

Monitor RPC latency, error rates, and request volume. Use tools like Prometheus, Grafana, or Datadog to visualize metrics and set up alerts.

❓ Frequently Asked Questions

What ports does TRON use for RPC?

TRON uses 8090 for HTTP JSON-RPC and 50051 for gRPC. These are configurable in config.conf.

What is the difference between HTTP RPC and gRPC?

HTTP RPC uses JSON over REST — simple and human-readable. gRPC uses Protocol Buffers for binary serialization — significantly faster, strongly typed, and supports streaming.

How do I load balance gRPC traffic?

gRPC traffic can be load balanced using L7 (application-level) load balancers that support gRPC, such as Envoy, Nginx (with grpc_pass), or HAProxy. Client-side load balancing is also possible.

Should I expose RPC ports publicly?

Only if you are providing a public RPC service. In all cases, implement TLS, rate limiting, and authentication. For internal services, use IP whitelisting or VPNs.

How many nodes do I need for production RPC?

For high availability, deploy at least 3 nodes behind a load balancer. This allows you to handle traffic spikes and perform rolling upgrades without downtime.

⚡ Build on TRON's RPC Infrastructure

Running RPC endpoints or building dApps? Pair your infrastructure with Tronsell Energy to power your transactions at the lowest cost.

⚡ Get Tron Energy 📞 Contact Support