Broadcast gRPC Method

Parameters

tx

object

REQUIRED

The transaction to broadcast

raw_data

object

The raw transaction data

ref_block_bytes

string

Reference block bytes

ref_block_num

integer

Reference block number

ref_block_hash

string

Reference block hash

expiration

integer

Transaction expiration time

auths

array

Authorization data

data

string

Additional data (not used)

contract

array

Contract data

scripts

string

Scripts data (not used)

timestamp

integer

Transaction timestamp

fee_limit

integer

Maximum fee allowed for this transaction

signature

array

Transaction signatures (only supports size = 1, repeated for multi-sig extension)

ret

array

Transaction results

fee

integer

Fee paid for the transaction

ret

string

Result code (enum: Transaction_ResultCode)

contractRet

string

Contract execution result (enum: Transaction_ResultContractResult)

assetIssueID

string

Asset issue ID

withdraw_amount

integer

Amount withdrawn

unfreeze_amount

integer

Amount unfrozen

exchangeReceivedAmount

integer

Amount received in exchange

exchangeInjectAnotherAmount

integer

Amount injected in exchange

exchangeWithdrawAnotherAmount

integer

Amount withdrawn from exchange

exchange_id

integer

Exchange ID

shieldedTransactionFee

integer

Fee for shielded transaction

orderId

string

Order ID

orderDetails

array

Market order details

makerOrderId

string

Maker order ID

takerOrderId

string

Taker order ID

fillSellQuantity

integer

Quantity filled on sell side

fillBuyQuantity

integer

Quantity filled on buy side

withdraw_expire_amount

integer

Expired withdrawal amount

cancelUnfreezeV2Amount

object

Mapping of canceled unfreeze V2 amounts

Returns

result

boolean

Whether the broadcast was successful

code

string

The response code (enum: ReturnResponseCode)

SUCCESS

integer

Operation successful

SIGERROR

integer

Error in signature

CONTRACT_VALIDATE_ERROR

integer

Contract validation error

CONTRACT_EXE_ERROR

integer

Contract execution error

BANDWITH_ERROR

integer

Bandwidth error

DUP_TRANSACTION_ERROR

integer

Duplicate transaction error

TAPOS_ERROR

integer

TAPOS error

TOO_BIG_TRANSACTION_ERROR

integer

Transaction too large

TRANSACTION_EXPIRATION_ERROR

integer

Transaction expired

SERVER_BUSY

integer

Server busy

NO_CONNECTION

integer

No connection

NOT_ENOUGH_EFFECTIVE_CONNECTION

integer

Not enough effective connections

BLOCK_UNSOLIDIFIED

integer

Block not solidified

OTHER_ERROR

integer

Other error

message

string

The response message

Request

package main

import (
	"context"
	"crypto/sha256"
	"crypto/tls"
	"encoding/hex"
	"fmt"
	"encoding/json"
	"github.com/fbsobreira/gotron-sdk/pkg/client"
	"github.com/btcsuite/btcd/btcec/v2"
	"github.com/ethereum/go-ethereum/crypto"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials"
	"google.golang.org/protobuf/proto"
)

// 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()

	fromAddress := "YOUR_ADDRESS"
	toAddress := "RECIPIENT_ADDRESS"
	amount := int64(1000000)
	privateKeyHex := "YOUR_PRIVATE_KEY"
	
	tx, err := conn.Transfer(
		fromAddress,
		toAddress,
		amount,
	)
	if err != nil {
		fmt.Printf("Error creating transfer transaction: %v\n", err)
		return
	}
	
	fmt.Println("Transfer Transaction Created:")
	jsonData, err := json.MarshalIndent(tx, "", "  ")
	if err != nil {
		fmt.Printf("Error marshaling to JSON: %v\n", err)
		return
	}
	fmt.Println(string(jsonData))
	
	// Sign the transaction
	privateKeyBytes, err := hex.DecodeString(privateKeyHex)
	if err != nil {
		fmt.Printf("Error decoding private key: %v\n", err)
		return
	}
	
	// Get the raw data from the transaction and hash it
	rawData, err := proto.Marshal(tx.Transaction.GetRawData())
	if err != nil {
		fmt.Printf("Error marshaling raw data: %v\n", err)
		return
	}
	
	// Create SHA256 hash of the raw data
	h256h := sha256.New()
	h256h.Write(rawData)
	hash := h256h.Sum(nil)
	
	// Sign the hash with the private key
	sk, _ := btcec.PrivKeyFromBytes(privateKeyBytes)
	signature, err := crypto.Sign(hash, sk.ToECDSA())
	if err != nil {
		fmt.Printf("Error signing transaction: %v\n", err)
		return
	}
	
	// Add the signature to the transaction
	tx.Transaction.Signature = append(tx.Transaction.Signature, signature)
	
	// Broadcast the signed transaction
	result, err := conn.Broadcast(tx.Transaction)
	if err != nil {
		fmt.Printf("Error broadcasting transaction: %v\n", err)
		return
	}
	
	// Print the broadcast result
	fmt.Println("Broadcast Result:")
	resultJSON, err := json.MarshalIndent(result, "", "  ")
	if err != nil {
		fmt.Printf("Error marshaling result to JSON: %v\n", err)
		return
	}
	fmt.Println(string(resultJSON))
}

Don't have an account yet?

Create your QuickNode endpoint in seconds and start building

Get started for free