Broadcast gRPC Method

Parameters

object

REQUIRED

raw_data

object

ref_block_bytes

string

ref_block_num

integer

ref_block_hash

string

expiration

integer

auths

array

data

string

contract

array

scripts

string

timestamp

integer

fee_limit

integer

signature

array

ret

array

fee

integer

ret

string

contractRet

string

assetIssueID

string

withdraw_amount

integer

unfreeze_amount

integer

exchangeReceivedAmount

integer

exchangeInjectAnotherAmount

integer

exchangeWithdrawAnotherAmount

integer

exchange_id

integer

shieldedTransactionFee

integer

orderId

string

orderDetails

array

makerOrderId

string

takerOrderId

string

fillSellQuantity

integer

fillBuyQuantity

integer

withdraw_expire_amount

integer

cancelUnfreezeV2Amount

object

Returns

result

boolean

code

string

SUCCESS

integer

SIGERROR

integer

CONTRACT_VALIDATE_ERROR

integer

CONTRACT_EXE_ERROR

integer

BANDWITH_ERROR

integer

DUP_TRANSACTION_ERROR

integer

TAPOS_ERROR

integer

TOO_BIG_TRANSACTION_ERROR

integer

TRANSACTION_EXPIRATION_ERROR

integer

SERVER_BUSY

integer

NO_CONNECTION

integer

NOT_ENOUGH_EFFECTIVE_CONNECTION

integer

BLOCK_UNSOLIDIFIED

integer

OTHER_ERROR

integer

message

string

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

Broadcast gRPC Method

Loading...

Parameters

Returns