GetBlockByLimitNext gRPC Method

Parameters

start

integer

REQUIRED

The starting block height

end

integer

REQUIRED

The ending block height (exclusive)

Returns

block

array

List of blocks in the specified range

transactions

array

List of transactions in the block

transaction

object

Transaction details

raw_data

object

Raw transaction data

signature

array

Transaction signatures

ret

array

Transaction results

txid

string

Transaction ID (hash of transaction.rowdata)

constant_result

array

Results from constant function calls

result

object

Transaction result status

energy_used

integer

Amount of energy used

logs

array

Event logs generated

internal_transactions

array

Internal transactions within a smart contract

energy_penalty

integer

Energy penalty applied

block_header

object

Header information for the block

raw_data

object

Raw header data

witness_signature

string

Signature of the witness

blockid

string

The block ID (hash)

Request

package main

import (
	"context"
	"crypto/tls"
	"encoding/json"
	"fmt"
	"github.com/fbsobreira/gotron-sdk/pkg/client"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"log"
)

// QuickNode endpoints consist of two crucial components: the endpoint name and the corresponding token
// For eg: QN Endpoint: https://docs-demo.tron-mainnet.quiknode.pro/abcde123456789
// endpoint will be: docs-demo.tron-mainnet.quiknode.pro:50051  {50051 is the port number for Tron gRPC}
// token will be : abcde123456789

var token = "YOUR_TOKEN"
var endpoint = "YOUR_ENDPOINT:50051"

type auth struct {
	token string
}

func (a *auth) GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error) {
	return map[string]string{
		"x-token": a.token,
	}, nil
}

func (a *auth) RequireTransportSecurity() bool {
	return false
}

func main() {

	opts := []grpc.DialOption{
		grpc.WithTransportCredentials(credentials.NewTLS(&tls.Config{})),
		grpc.WithPerRPCCredentials(&auth{token}),
	}
	
	conn := client.NewGrpcClient(endpoint)
	if err := conn.Start(opts...); err != nil {
		panic(err)
	}
	defer conn.Conn.Close()
	
	start := int64(45000000)
	end := int64(45000005)
	
	blocks, err := conn.GetBlockByLimitNext(start, end)
	if err != nil {
		log.Fatalf("Error getting blocks: %v", err)
	}
	
	resultJSON, err := json.MarshalIndent(blocks, "", "  ")
	if err != nil {
		log.Fatalf("Failed to marshal blocks: %v", err)
	}
	fmt.Println(string(resultJSON))
}

Don't have an account yet?

Create your QuickNode endpoint in seconds and start building

Get started for free