Tron Go SDK

https://gotron.sh/docs
Admin
This project provides documentation for using the Tron blockchain with the Go SDK, covering API...
Tokens:15,695
Snippets:177
Trust Score:2.7
Update:4 months ago
Show doc for...
Tokens:
Raw
### Install GoTRON SDK

Source: https://gotron.sh

Install the GoTRON SDK using curl and sh. This is the initial step to get started with the SDK.

```bash
$ curl -fsSL gotron.sh/install | sh
```

--------------------------------

### Install GoTRON SDK

Source: https://gotron.sh/docs/installation

Add the GoTRON SDK to your Go project using the go get command.

```bash
go get github.com/fbsobreira/gotron-sdk
```

--------------------------------

### Install tronctl CLI (Go)

Source: https://gotron.sh/docs/installation

Install the tronctl CLI using the Go install command.

```bash
go install github.com/fbsobreira/gotron-sdk/cmd/tronctl@latest
```

--------------------------------

### Install tronctl CLI (curl)

Source: https://gotron.sh/docs/installation

Quickest way to install the tronctl CLI using curl.

```bash
curl -fsSL gotron.sh/install | sh
```

--------------------------------

### Install MCP Server Locally

Source: https://gotron.sh/docs/mcp-server

Install the MCP server on your local machine using curl.

```bash
curl -fsSL gotron.sh/install-mcp | sh
```

--------------------------------

### Build MCP Server from Source

Source: https://gotron.sh/docs/mcp-server

Build the MCP server from source using go install.

```bash
go install github.com/fbsobreira/gotron-mcp@latest
```

--------------------------------

### Install GoTRON MCP Server

Source: https://gotron.sh

Use this command to install the GoTRON MCP Server locally via curl.

```bash
$ curl -fsSL gotron.sh/install-mcp | sh
```

--------------------------------

### Verify tronctl CLI Installation

Source: https://gotron.sh/docs/installation

Check the installed version of the tronctl CLI.

```bash
tronctl --version
```

--------------------------------

### Get Account Resources

Source: https://gotron.sh/docs/api-reference

Returns the account’s energy and bandwidth resources.

```go
resources, err := conn.GetAccountResource(address)
```

--------------------------------

### Manage Wallets with tronctl CLI

Source: https://gotron.sh/docs/tron-wallet-go

Provides command-line examples for managing TRON wallets using the tronctl utility, including creating, listing, and importing keys.

```bash
# Create a new wallet
tronctl keys add my-wallet

# List wallets
tronctl keys list

# Import private key
tronctl keys import my-wallet --private-key <key>
```

--------------------------------

### Use GoTRON SDK in a Go Project

Source: https://gotron.sh

Connect to the TRON gRPC endpoint, retrieve account details, and print the balance. Ensure the gRPC client is started before use and deferred to stop.

```go
package main

import (
	"fmt"
	"log"
	"github.com/fbsobreira/gotron-sdk/pkg/client"
)

func main() {
	conn := client.NewGrpcClient("grpc.trongrid.io:50051")
	if err := conn.Start(); err != nil {
		log.Fatal(err)
	}
	defer conn.Stop()

	acc, err := conn.GetAccount("TRX_ADDRESS")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Balance: %d SUN\n", acc.Balance)
}
```

--------------------------------

### tronctl CLI Commands for Staking and Voting

Source: https://gotron.sh/docs/tron-staking-go

Provides command-line examples for staking TRX for energy or bandwidth, voting for SRs, and checking rewards using the tronctl utility.

```bash
# Stake for energy
tronctl stake --from ADDRESS --amount 1000 --resource ENERGY

# Stake for bandwidth
tronctl stake --from ADDRESS --amount 500 --resource BANDWIDTH

# Vote for SR
tronctl vote --from ADDRESS --witness SR_ADDRESS --count 1000

# Check rewards
tronctl rewards ADDRESS
```

--------------------------------

### Get Account Information

Source: https://gotron.sh/docs/cli-usage

Fetch detailed information about a TRON account.

```bash
tronctl account info <address>
```

--------------------------------

### Connect to TRON Node

Source: https://gotron.sh/docs/sdk-usage

Establishes a gRPC connection to a TRON node. Ensure the client is started before use and stopped when finished.

```go
package main

import (
    "fmt"
    "log"

    "github.com/fbsobreira/gotron-sdk/pkg/client"
)

func main() {
    conn := client.NewGrpcClient("grpc.trongrid.io:50051")
    if err := conn.Start(); err != nil {
        log.Fatal(err)
    }
    defer conn.Stop()
}
```

--------------------------------

### Export Account Activity via CLI

Source: https://gotron.sh/docs/examples

Uses the tronctl CLI to fetch account information and recent transaction history. Requires the tronctl tool to be installed and configured.

```bash
# Check account details
tronctl account info TRX_ADDRESS

# Get recent transactions
tronctl account transactions TRX_ADDRESS --limit 20
```

--------------------------------

### Get Account Information

Source: https://gotron.sh/docs/api-reference

Retrieves full account information, including balance, resources, and frozen balances. Access balance via `account.Balance`.

```go
account, err := conn.GetAccount(address)
```

--------------------------------

### Get Account Balance with Go SDK

Source: https://gotron.sh

Use the Go SDK to connect to the TRON gRPC endpoint and retrieve an account's balance. Ensure you have the necessary imports.

```go
conn := client.NewGrpcClient("grpc.trongrid.io:50051")
conn.Start()
acc, _ := conn.GetAccount(addr)
fmt.Println(acc.Balance)
```

--------------------------------

### Connect to Hosted MCP Server Endpoint

Source: https://gotron.sh/docs/mcp-server

Use this public endpoint for instant connection without local installation.

```plaintext
https://mcp.gotron.sh/mcp
```

--------------------------------

### Get TRC10 Token Information

Source: https://gotron.sh/docs/api-reference

Returns TRC10 token information by its asset ID.

```go
asset, err := conn.GetAssetIssueByID(id)
```

--------------------------------

### Get Transaction by ID

Source: https://gotron.sh/docs/api-reference

Retrieves a transaction from the network using its unique hash ID.

```go
tx, err := conn.GetTransactionByID(id)
```

--------------------------------

### Get TRC20 Token Decimals

Source: https://gotron.sh/docs/api-reference

Returns the token’s decimal places for a given TRC20 contract address.

```go
decimals, err := conn.TRC20GetDecimals(contractAddress)
```

--------------------------------

### Get Account Balance

Source: https://gotron.sh/docs/sdk-usage

Retrieves the balance of a TRON account in SUN. Requires a valid TRON address.

```go
acc, err := conn.GetAccount("TRX_ADDRESS")
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Balance: %d SUN\n", acc.Balance)
```

--------------------------------

### Get Latest Block

Source: https://gotron.sh/docs/api-reference

Returns the most recently added block on the TRON blockchain.

```go
block, err := conn.GetNowBlock()
```

--------------------------------

### Get Transaction Info by ID

Source: https://gotron.sh/docs/api-reference

Retrieves detailed execution information for a transaction, including fee, energy usage, and logs.

```go
info, err := conn.GetTransactionInfoByID(id)
```

--------------------------------

### Get TRC20 Token Symbol

Source: https://gotron.sh/docs/api-reference

Returns the symbol of a TRC20 token using its contract address.

```go
symbol, err := conn.TRC20GetSymbol(contractAddress)
```

--------------------------------

### Get Block by Number

Source: https://gotron.sh/docs/api-reference

Retrieves a specific block from the TRON blockchain using its numerical sequence.

```go
block, err := conn.GetBlockByNum(num)
```

--------------------------------

### Check USDT Balance on TRON

Source: https://gotron.sh/docs/send-usdt-tron-go

Use this snippet to retrieve the USDT (TRC20) balance for a given TRON address. Ensure you have the GoTRON SDK installed and a gRPC connection to the TRON network.

```go
package main

import (
    "fmt"
    "log"
    "math/big"

    "github.com/fbsobreira/gotron-sdk/pkg/client"
)

func main() {
    conn := client.NewGrpcClient("grpc.trongrid.io:50051")
    if err := conn.Start(); err != nil {
        log.Fatal(err)
    }
    defer conn.Stop()

    usdtContract := "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t"
    address := "YOUR_TRON_ADDRESS"

    balance, err := conn.TRC20ContractBalance(address, usdtContract)
    if err != nil {
        log.Fatal(err)
    }

    // USDT has 6 decimals
    decimals := new(big.Float).SetInt(new(big.Int).Exp(big.NewInt(10), big.NewInt(6), nil))
    human := new(big.Float).Quo(new(big.Float).SetInt(balance), decimals)

    fmt.Printf("USDT Balance: %s\n", human.Text('f', 6))
}
```

--------------------------------

### GetNowBlock

Source: https://gotron.sh/docs/api-reference

Returns the latest block on the TRON network. This is useful for getting the most recent block information.

```APIDOC
## GetNowBlock

### Description
Returns the latest block.

### Method
`GetNowBlock() (*api.BlockExtention, error)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```go
block, err := client.GetNowBlock()
if err != nil {
    // Handle error
}
```

### Response
#### Success Response
Returns an `api.BlockExtention` object representing the latest block.

#### Response Example
None
```

--------------------------------

### Get TRC20 Token Name

Source: https://gotron.sh/docs/api-reference

Returns the name of a TRC20 token using its contract address.

```go
name, err := conn.TRC20GetName(contractAddress)
```

--------------------------------

### Get TRC20 Token Balance

Source: https://gotron.sh/docs/sdk-usage

Fetches the balance of a specific TRC20 token for a given holder address. Requires holder and token contract addresses.

```go
balance, err := conn.TRC20ContractBalance(
    "HOLDER_ADDRESS",
    "TOKEN_CONTRACT_ADDRESS",
)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Token balance: %s\n", balance.String())
```

--------------------------------

### Build tronctl CLI from Source

Source: https://gotron.sh/docs/installation

Clone the repository and build the tronctl CLI from source.

```bash
git clone https://github.com/fbsobreira/gotron-sdk.git
cd gotron-sdk
go build ./cmd/tronctl
```

--------------------------------

### GrpcClient.Start

Source: https://gotron.sh/docs/api-reference

Establishes the gRPC connection for the client. This method can accept optional dial options for advanced configuration.

```APIDOC
## GrpcClient.Start

### Description
Establishes the gRPC connection. Accepts optional dial options.

### Method
`(g *GrpcClient) Start(opts ...grpc.DialOption) error`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```go
// Assuming 'conn' is a *GrpcClient instance
err := conn.Start()
if err != nil {
    // Handle error
}
```

### Response
#### Success Response (0)
Indicates the connection was established successfully.

#### Response Example
None
```

--------------------------------

### Configure Claude Desktop MCP Server

Source: https://gotron.sh/docs/mcp-server

Add the GoTRON MCP server to your Claude Desktop configuration file.

```json
{
  "mcpServers": {
    "gotron": {
      "command": "gotron-mcp"
    }
  }
}
```

--------------------------------

### Add GoTRON MCP Server to Claude Desktop / Claude Code

Source: https://gotron.sh/docs/mcp-server

Connect to the GoTRON MCP server using the claude CLI.

```bash
claude mcp add gotron --transport http https://mcp.gotron.sh/mcp
```

--------------------------------

### Sign a TRON Transaction with Keystore

Source: https://gotron.sh/docs/tron-wallet-go

Builds a TRON transfer transaction, signs it using an account from the keystore, and prepares it for broadcasting.

```go
// Build a transaction
tx, err := conn.Transfer(from, to, 1_000_000)
if err != nil {
    log.Fatal(err)
}

// Sign with keystore
ks := keystore.NewKeyStore("./keystore")
account := ks.Accounts()[0]

signedTx, err := ks.SignTx(account, tx.Transaction)
if err != nil {
    log.Fatal(err)
}

// Broadcast
result, err := conn.Broadcast(signedTx)
```

--------------------------------

### Import Private Key

Source: https://gotron.sh/docs/cli-usage

Import an existing TRON account using its private key.

```bash
tronctl keys import my-wallet --private-key <key>
```

--------------------------------

### Configure Windsurf MCP Server

Source: https://gotron.sh/docs/mcp-server

Add the GoTRON MCP server to your Windsurf MCP configuration.

```json
{
  "mcpServers": {
    "gotron": {
      "serverUrl": "https://mcp.gotron.sh/mcp"
    }
  }
}
```

--------------------------------

### Freeze Balance for Resources

Source: https://gotron.sh/docs/api-reference

Creates a freeze balance transaction for energy or bandwidth. Use `core.ResourceCode_ENERGY` or `core.ResourceCode_BANDWIDTH`.

```go
tx, err := conn.FreezeBalance(from, delegateTo, resource, frozenBalance)
```

--------------------------------

### Configure Cursor MCP Server

Source: https://gotron.sh/docs/mcp-server

Add the GoTRON MCP server to your Cursor IDE's MCP configuration.

```json
{
  "mcpServers": {
    "gotron": {
      "url": "https://mcp.gotron.sh/mcp"
    }
  }
}
```

--------------------------------

### Add GoTRON MCP Server to Claude Desktop/Code

Source: https://gotron.sh

Configure Claude Desktop or Claude Code to connect to the GoTRON MCP Server using its HTTP endpoint.

```bash
$ claude mcp add gotron --transport http https://mcp.gotron.sh/mcp
```

--------------------------------

### Create New Account

Source: https://gotron.sh/docs/cli-usage

Generate a new TRON account and associated keys.

```bash
tronctl keys add my-wallet
```

--------------------------------

### Sign Transaction with Keystore

Source: https://gotron.sh/docs/sdk-usage

Signs a transaction using a local keystore. Requires the keystore path and transaction object. The signed transaction can then be broadcast.

```go
import "github.com/fbsobreira/gotron-sdk/pkg/keystore"

ks := keystore.NewKeyStore(keystorePath)
account := ks.Accounts()[0]

signedTx, err := ks.SignTx(account, tx)
if err != nil {
    log.Fatal(err)
}

// Broadcast
result, err := conn.Broadcast(signedTx)
```

--------------------------------

### Check Account Resources

Source: https://gotron.sh/docs/tron-staking-go

Retrieves and prints the current energy and bandwidth usage and limits for a given TRON address.

```go
package main

import (
    "fmt"
    "log"

    "github.com/fbsobreira/gotron-sdk/pkg/client"
)

func main() {
    conn := client.NewGrpcClient("grpc.trongrid.io:50051")
    if err := conn.Start(); err != nil {
        log.Fatal(err)
    }
    defer conn.Stop()

    resource, err := conn.GetAccountResource("YOUR_ADDRESS")
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Energy: %d / %d\n",
        resource.GetEnergyUsed(),
        resource.GetEnergyLimit(),
    )
    fmt.Printf("Bandwidth: %d / %d\n",
        resource.GetFreeNetUsed(),
        resource.GetFreeNetLimit(),
    )
}
```

--------------------------------

### Configure GoTRON MCP Server in Windsurf

Source: https://gotron.sh

Add the GoTRON MCP Server configuration to your Windsurf settings.

```json
{
"mcpServers": {
"gotron": {
"serverUrl": "https://mcp.gotron.sh/mcp"
}
}
}
```

--------------------------------

### Configure GoTRON MCP Server in Cursor/Cline/VS Code

Source: https://gotron.sh

Add the GoTRON MCP Server configuration to your Cursor, Cline, or VS Code settings.

```json
{
"mcpServers": {
"gotron": {
"url": "https://mcp.gotron.sh/mcp"
}
}
}
```

--------------------------------

### Import an Existing Private Key

Source: https://gotron.sh/docs/tron-wallet-go

Imports an existing TRON private key into the keystore. This requires the private key and a passphrase for the keystore.

```go
import "crypto/ecdsa"
import "github.com/fbsobreira/gotron-sdk/pkg/keystore"

ks := keystore.NewKeyStore("./keystore")
account, err := ks.ImportECDSA(privateKey, "passphrase")
```

--------------------------------

### Check Account Balance with tronctl

Source: https://gotron.sh

Use the tronctl CLI tool to check the balance of a TRON account. Replace 'TRX...' with the actual account address.

```bash
$ tronctl account balance TRX...
Balance: 12,450.500000 TRX
```

--------------------------------

### TRC20 Token Operations in Go

Source: https://gotron.sh/docs/smart-contracts

The GoTRON SDK provides helper methods for TRC20 token operations, including fetching metadata (name, symbol, decimals), checking balances, and sending tokens. Ensure the TRON gRPC client is initialized.

```go
// Get token metadata
name, _ := conn.TRC20GetName("TOKEN_CONTRACT")
symbol, _ := conn.TRC20GetSymbol("TOKEN_CONTRACT")
decimals, _ := conn.TRC20GetDecimals("TOKEN_CONTRACT")

fmt.Printf("Token: %s (%s), Decimals: %s\n", name, symbol, decimals)

// Get balance
balance, _ := conn.TRC20ContractBalance("HOLDER", "TOKEN_CONTRACT")
fmt.Printf("Balance: %s\n", balance.String())

// Transfer
tx, err := conn.TRC20Send("FROM", "TO", "TOKEN_CONTRACT", amount, feeLimit)
```

--------------------------------

### List Accounts

Source: https://gotron.sh/docs/cli-usage

Display a list of all managed TRON accounts.

```bash
tronctl keys list
```

--------------------------------

### Sign a TRON Transaction with Ledger

Source: https://gotron.sh/docs/tron-wallet-go

Demonstrates signing a TRON transaction using a Ledger hardware wallet. This requires the transaction bytes as input.

```go
import "github.com/fbsobreira/gotron-sdk/pkg/ledger"

// Sign with Ledger device
signedTx, err := ledger.SignTx(txBytes)
if err != nil {
    log.Fatal(err)
}
```

--------------------------------

### Create a New TRON Account

Source: https://gotron.sh/docs/tron-wallet-go

Generates a new TRON account with an encrypted keystore. Ensure you provide a secure passphrase for the keystore.

```go
package main

import (
    "fmt"
    "log"

    "github.com/fbsobreira/gotron-sdk/pkg/keystore"
)

func main() {
    ks := keystore.NewKeyStore("./keystore")

    account, err := ks.NewAccount("your-secure-passphrase")
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("New address: %s\n", account.Address)
}
```

--------------------------------

### client.NewGrpcClient

Source: https://gotron.sh/docs/api-reference

Creates a new TRON gRPC client instance. This is the primary way to initialize a client for interacting with the TRON network.

```APIDOC
## client.NewGrpcClient

### Description
Creates a new TRON gRPC client instance.

### Method
`client.NewGrpcClient(endpoint string) *GrpcClient`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```go
conn := client.NewGrpcClient("grpc.trongrid.io:50051")
```

### Response
#### Success Response
Returns a *GrpcClient instance.

#### Response Example
None
```

--------------------------------

### Monitor TRX Deposits by Balance Watching

Source: https://gotron.sh/docs/monitor-deposits

Poll an account's TRX balance at regular intervals to detect changes. Ensure the GoTRON SDK is imported.

```go
package main

import (
    "fmt"
    "log"
    "time"

    "github.com/fbsobreira/gotron-sdk/pkg/client"
)

func main() {
    conn := client.NewGrpcClient("grpc.trongrid.io:50051")
    if err := conn.Start(); err != nil {
        log.Fatal(err)
    }
    defer conn.Stop()

    address := "WATCH_ADDRESS"
    var lastBalance int64

    for {
        acc, err := conn.GetAccount(address)
        if err != nil {
            log.Printf("Error: %v", err)
            time.Sleep(3 * time.Second)
            continue
        }

        if acc.Balance != lastBalance {
            fmt.Printf("TRX balance changed: %d -> %d SUN\n",
                lastBalance, acc.Balance)
            lastBalance = acc.Balance
        }

        time.Sleep(3 * time.Second)
    }
}
```

--------------------------------

### List TRON Accounts

Source: https://gotron.sh/docs/tron-wallet-go

Retrieves and prints the addresses of all accounts stored in the keystore. This is useful for managing multiple wallets.

```go
ks := keystore.NewKeyStore("./keystore")
for _, account := range ks.Accounts() {
    fmt.Printf("Address: %s\n", account.Address)
}
```

--------------------------------

### Check Transaction Energy and Bandwidth Costs

Source: https://gotron.sh/docs/examples

Retrieves and displays the current energy and bandwidth usage and limits for a given TRON address. This helps in estimating transaction costs.

```go
resource, err := conn.GetAccountResource("YOUR_ADDRESS")
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Energy: %d / %d\n",
    resource.GetEnergyUsed(),
    resource.GetEnergyLimit(),
)
fmt.Printf("Bandwidth: %d / %d\n",
    resource.GetFreeNetUsed(),
    resource.GetFreeNetLimit(),
)
```

--------------------------------

### Monitor TRC20 Token Deposits by Balance Watching

Source: https://gotron.sh/docs/monitor-deposits

Monitor TRC20 token balances, such as USDT, by polling the contract balance at regular intervals. Requires the GoTRON SDK.

```go
package main

import (
    "fmt"
    "log"
    "math/big"
    "time"

    "github.com/fbsobreira/gotron-sdk/pkg/client"
)

func main() {
    conn := client.NewGrpcClient("grpc.trongrid.io:50051")
    if err := conn.Start(); err != nil {
        log.Fatal(err)
    }
    defer conn.Stop()

    address := "WATCH_ADDRESS"
    usdtContract := "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t"
    lastBalance := big.NewInt(0)

    for {
        balance, err := conn.TRC20ContractBalance(address, usdtContract)
        if err != nil {
            log.Printf("Error: %v", err)
            time.Sleep(3 * time.Second)
            continue
        }

        if balance.Cmp(lastBalance) != 0 {
            fmt.Printf("USDT balance changed: %s -> %s\n",
                lastBalance.String(), balance.String())
            lastBalance = new(big.Int).Set(balance)
        }

        time.Sleep(3 * time.Second)
    }
}
```

--------------------------------

### Scan Blocks for Transactions

Source: https://gotron.sh/docs/monitor-deposits

Scan blocks sequentially to track deposits by examining transactions targeting a specific address. This approach provides more detailed deposit tracking. Ensure the GoTRON SDK is imported.

```go
package main

import (
    "fmt"
    "log"
    "time"

    "github.com/fbsobreira/gotron-sdk/pkg/client"
)

func main() {
    conn := client.NewGrpcClient("grpc.trongrid.io:50051")
    if err := conn.Start(); err != nil {
        log.Fatal(err)
    }
    defer conn.Stop()

    // Start from the latest block
    block, err := conn.GetNowBlock()
    if err != nil {
        log.Fatal(err)
    }
    lastBlock := block.BlockHeader.RawData.Number

    for {
        current, err := conn.GetNowBlock()
        if err != nil {
            log.Printf("Error: %v", err)
            time.Sleep(3 * time.Second)
            continue
        }

        currentNum := current.BlockHeader.RawData.Number
        for num := lastBlock + 1; num <= currentNum; num++ {
            b, err := conn.GetBlockByNum(num)
            if err != nil {
                log.Printf("Error fetching block %d: %v", num, err)
                continue
            }

            for _, tx := range b.Transactions {
                // Process each transaction
                fmt.Printf("Block %d: tx %x\n", num, tx.Txid)
            }
        }

        lastBlock = currentNum
        time.Sleep(3 * time.Second)
    }
}
```

--------------------------------

### Trigger Smart Contract Method

Source: https://gotron.sh/docs/api-reference

Calls a smart contract method. Requires sender, contract address, method name, JSON parameters, fee limit, and token details if applicable.

```go
tx, err := conn.TriggerContract(from, contractAddress, method, jsonString, feeLimit, tAmount, tTokenID, tTokenAmount)
```

--------------------------------

### Trigger State-Changing Method using tronctl CLI

Source: https://gotron.sh/docs/smart-contracts

Use the tronctl CLI to trigger a state-changing smart contract method. Provide the sender address, contract address, method name, parameters, and fee limit.

```bash
# Trigger a state-changing method
tronctl contract trigger \
  --from CALLER_ADDRESS \
  --contract CONTRACT_ADDRESS \
  --method "transfer(address,uint256)" \
  --params '["RECIPIENT", "1000000"]' \
  --fee-limit 100000000
```

--------------------------------

### Stake TRX for Bandwidth

Source: https://gotron.sh/docs/cli-usage

Stake TRX to obtain Bandwidth resources for transactions.

```bash
tronctl stake \
  --from <address> \
  --amount 500 \
  --resource BANDWIDTH
```

--------------------------------

### Create New gRPC Client

Source: https://gotron.sh/docs/api-reference

Creates a new TRON gRPC client instance using the provided endpoint.

```go
conn := client.NewGrpcClient("grpc.trongrid.io:50051")
```

--------------------------------

### Call Read-Only Contract Method using tronctl CLI

Source: https://gotron.sh/docs/smart-contracts

Use the tronctl CLI to call a read-only smart contract method. Specify the contract address, method name, and parameters.

```bash
# Call a read-only contract method
tronctl contract call \
  --contract CONTRACT_ADDRESS \
  --method "balanceOf(address)" \
  --params '["HOLDER_ADDRESS"]'
```

--------------------------------

### Check Account Balance

Source: https://gotron.sh/docs/cli-usage

Retrieve the balance of a TRON account.

```bash
tronctl account balance <address>
```

--------------------------------

### Freeze TRX for Bandwidth

Source: https://gotron.sh/docs/tron-staking-go

Stakes a specified amount of TRX to obtain bandwidth resources. Ensure the owner address is correctly set.

```go
tx, err := conn.FreezeBalance(
    "OWNER_ADDRESS",
    "OWNER_ADDRESS",
    core.ResourceCode_BANDWIDTH,
    500_000_000, // 500 TRX in SUN
)
```

--------------------------------

### FreezeBalance

Source: https://gotron.sh/docs/api-reference

Creates a freeze balance transaction for energy or bandwidth. Use `core.ResourceCode_ENERGY` or `core.ResourceCode_BANDWIDTH` to specify the resource type.

```APIDOC
## FreezeBalance

### Description
Creates a freeze balance transaction for energy or bandwidth. Use `core.ResourceCode_ENERGY` or `core.ResourceCode_BANDWIDTH`.

### Method
`FreezeBalance(from, delegateTo string, resource core.ResourceCode, frozenBalance int64) (*api.TransactionExtention, error)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
* `from` (string) - Required - The address to freeze balance from (base58)
* `delegateTo` (string) - Optional - The address to delegate resources to (base58). If empty, resources are for the `from` address.
* `resource` (core.ResourceCode) - Required - The type of resource to freeze (`core.ResourceCode_ENERGY` or `core.ResourceCode_BANDWIDTH`)
* `frozenBalance` (int64) - Required - The amount of TRX to freeze in SUN

### Request Example
```go
transaction, err := client.FreezeBalance("TFromAddress", "", core.ResourceCode_ENERGY, 1000000000000000000) // Freeze 1000 TRX for energy
if err != nil {
    // Handle error
}
```

### Response
#### Success Response
Returns an `api.TransactionExtention` object representing the unsigned freeze transaction.

#### Response Example
None
```

--------------------------------

### GetAccountResource

Source: https://gotron.sh/docs/api-reference

Retrieves the account's energy and bandwidth resources. This is crucial for understanding transaction costs and network participation.

```APIDOC
## GetAccountResource

### Description
Returns the account’s energy and bandwidth resources.

### Method
`GetAccountResource(address string) (*api.AccountResourceMessage, error)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```go
resources, err := client.GetAccountResource("T9yD14Nj9j7xAB4dbGeiXMPfW3a9z39k5Q")
if err != nil {
    // Handle error
}
energy := resources.Energy
bandwidth := resources.Bandwidth
```

### Response
#### Success Response
Returns an `api.AccountResourceMessage` object containing energy and bandwidth details.

#### Response Example
```json
{
  "Energy": 10000,
  "Bandwidth": 5000
}
```
```

--------------------------------

### Configure TRON Node

Source: https://gotron.sh/docs/cli-usage

Set the preferred TRON node for tronctl to interact with.

```bash
tronctl config set node grpc.trongrid.io:50051
```

--------------------------------

### Estimate Energy Cost for Smart Contract Calls in Go

Source: https://gotron.sh/docs/smart-contracts

Estimate the remaining energy available for a caller address by retrieving account resources. This helps in planning contract execution and avoiding insufficient energy errors.

```go
resource, err := conn.GetAccountResource("CALLER_ADDRESS")
if err != nil {
    log.Fatal(err)
}

energyAvailable := resource.GetEnergyLimit() - resource.GetEnergyUsed()
fmt.Printf("Energy available: %d\n", energyAvailable)
```

--------------------------------

### Sign Transaction with Ledger

Source: https://gotron.sh/docs/sdk-usage

Signs a transaction using a Ledger hardware wallet. Requires the transaction bytes.

```go
import "github.com/fbsobreira/gotron-sdk/pkg/ledger"

signedTx, err := ledger.SignTx(txBytes)
```

--------------------------------

### Perform TRC20 Token Operations via CLI

Source: https://gotron.sh/docs/examples

Manages TRC20 tokens using the tronctl CLI, including checking balances and initiating transfers. Specify contract, sender, recipient, and amount.

```bash
# Check TRC20 balance
tronctl trc20 balance USDT_CONTRACT HOLDER_ADDRESS

# Transfer TRC20 tokens
tronctl trc20 transfer \
  --contract USDT_CONTRACT \
  --from SENDER \
  --to RECIPIENT \
  --amount 100
```

--------------------------------

### GetAccount

Source: https://gotron.sh/docs/api-reference

Retrieves the full account information, including balance, resources, permissions, and frozen balances. The account balance can be accessed via the `Balance` field.

```APIDOC
## GetAccount

### Description
Returns the full account information including balance, resources, permissions, and frozen balances. Access balance via `account.Balance`.

### Method
`GetAccount(address string) (*core.Account, error)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```go
account, err := client.GetAccount("T9yD14Nj9j7xAB4dbGeiXMPfW3a9z39k5Q")
if err != nil {
    // Handle error
}
balance := account.Balance
```

### Response
#### Success Response
Returns a `core.Account` object containing account details.

#### Response Example
```json
{
  "Balance": 1000000000000000000,
  "Frozen": [
    {
      "FrozenBalance": 500000000000000000,
      "ExpireTime": 1678886400000
    }
  ],
  "AccountName": "exampleAccount",
  "Address": "T9yD14Nj9j7xAB4dbGeiXMPfW3a9z39k5Q"
}
```
```

--------------------------------

### Send TRX

Source: https://gotron.sh/docs/cli-usage

Transfer TRX from one account to another.

```bash
tronctl transfer \
  --from <sender> \
  --to <recipient> \
  --amount 100
```

--------------------------------

### Stake TRX for Energy

Source: https://gotron.sh/docs/cli-usage

Stake TRX to obtain Energy resources for transaction fees.

```bash
tronctl stake \
  --from <address> \
  --amount 1000 \
  --resource ENERGY
```

--------------------------------

### Monitor Account Balance Changes

Source: https://gotron.sh/docs/examples

Continuously watches an account for any changes in its balance and logs the new balance. It polls the TRON network every 3 seconds.

```go
package main

import (
    "fmt"
    "log"
    "time"

    "github.com/fbsobreira/gotron-sdk/pkg/client"
)

func main() {
    conn := client.NewGrpcClient("grpc.trongrid.io:50051")
    if err := conn.Start(); err != nil {
        log.Fatal(err)
    }
    defer conn.Stop()

    address := "TRX_ADDRESS"
    var lastBalance int64

    for {
        acc, err := conn.GetAccount(address)
        if err != nil {
            log.Printf("Error: %v", err)
            continue
        }

        if acc.Balance != lastBalance {
            fmt.Printf("Balance changed: %d -> %d SUN\n", lastBalance, acc.Balance)
            lastBalance = acc.Balance
        }

        time.Sleep(3 * time.Second)
    }
}
```

--------------------------------

### client.NewGrpcClientWithTimeout

Source: https://gotron.sh/docs/api-reference

Creates a new TRON gRPC client instance with a custom connection timeout. This allows for more control over connection establishment.

```APIDOC
## client.NewGrpcClientWithTimeout

### Description
Creates a new client with a custom connection timeout.

### Method
`client.NewGrpcClientWithTimeout(endpoint string, timeout time.Duration) *GrpcClient`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```go
// Example usage with a 5-second timeout
timeout := 5 * time.Second
conn := client.NewGrpcClientWithTimeout("grpc.trongrid.io:50051", timeout)
```

### Response
#### Success Response
Returns a *GrpcClient instance with the specified timeout.

#### Response Example
None
```

--------------------------------

### Call a Read-Only Smart Contract Method in Go

Source: https://gotron.sh/docs/smart-contracts

Use TriggerConstantContract to call read-only methods on a smart contract without broadcasting a transaction. Ensure the gRPC client is initialized and connected.

```go
package main

import (
    "fmt"
    "log"

    "github.com/fbsobreira/gotron-sdk/pkg/client"
)

func main() {
    conn := client.NewGrpcClient("grpc.trongrid.io:50051")
    if err := conn.Start(); err != nil {
        log.Fatal(err)
    }
    defer conn.Stop()

    // Call a read-only method
    tx, err := conn.TriggerConstantContract(
        "CALLER_ADDRESS",
        "CONTRACT_ADDRESS",
        "balanceOf(address)",
        `[{"address": "HOLDER_ADDRESS"}]`,
    )
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Result: %x\n", tx.GetConstantResult())
}
```

--------------------------------

### Create TRX Transfer Transaction

Source: https://gotron.sh/docs/api-reference

Creates an unsigned TRX transfer transaction. The amount is specified in SUN (1 TRX = 1,000,000 SUN).

```go
tx, err := conn.Transfer(from, toAddress, amount)
```

--------------------------------

### Freeze TRX for Energy

Source: https://gotron.sh/docs/sdk-usage

Freezes TRX to obtain energy resources. Specify owner, receiver, resource type, and amount in SUN.

```go
tx, err := conn.FreezeBalance(
    "OWNER_ADDRESS",
    "RECEIVER_ADDRESS",
    core.ResourceCode_ENERGY,
    1000000000, // amount in SUN
)
```

--------------------------------

### Trigger Constant Smart Contract Method

Source: https://gotron.sh/docs/api-reference

Calls a read-only smart contract method. This operation does not require broadcasting as it does not modify the blockchain state.

```go
tx, err := conn.TriggerConstantContract(from, contractAddress, method, jsonString)
```

--------------------------------

### Freeze TRX for Energy

Source: https://gotron.sh/docs/tron-staking-go

Stakes a specified amount of TRX to obtain energy resources. Ensure the owner address is correctly set.

```go
tx, err := conn.FreezeBalance(
    "OWNER_ADDRESS",
    "OWNER_ADDRESS", // delegate to self
    core.ResourceCode_ENERGY,
    1_000_000_000, // 1000 TRX in SUN
)
if err != nil {
    log.Fatal(err)
}
// Sign and broadcast tx...
```

--------------------------------

### TRC20GetDecimals

Source: https://gotron.sh/docs/api-reference

Returns the decimal places of a TRC20 token. This is necessary for correctly displaying token amounts.

```APIDOC
## TRC20GetDecimals

### Description
Returns the token’s decimal places.

### Method
`TRC20GetDecimals(contractAddress string) (*big.Int, error)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
* `contractAddress` (string) - Required - The TRC20 contract address

### Request Example
```go
decimals, err := client.TRC20GetDecimals("Trc20ContractAddress")
if err != nil {
    // Handle error
}
```

### Response
#### Success Response
Returns a `*big.Int` representing the number of decimal places.

#### Response Example
```json
{
  "Int": "18"
}
```
```

--------------------------------

### Send USDT on TRON

Source: https://gotron.sh/docs/send-usdt-tron-go

This code sends USDT (TRC20) from one TRON address to another. It requires the sender's address, recipient's address, amount, and a fee limit. The transaction is signed using a local keystore.

```go
package main

import (
    "fmt"
    "log"
    "math/big"

    "github.com/fbsobreira/gotron-sdk/pkg/client"
    "github.com/fbsobreira/gotron-sdk/pkg/keystore"
)

func main() {
    conn := client.NewGrpcClient("grpc.trongrid.io:50051")
    if err := conn.Start(); err != nil {
        log.Fatal(err)
    }
    defer conn.Stop()

    usdtContract := "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t"
    from := "SENDER_ADDRESS"
    to := "RECIPIENT_ADDRESS"
    amount := big.NewInt(10_000_000) // 10 USDT (6 decimals)
    feeLimit := int64(100_000_000)   // 100 TRX fee limit

    // Create unsigned transaction
    tx, err := conn.TRC20Send(from, to, usdtContract, amount, feeLimit)
    if err != nil {
        log.Fatal(err)
    }

    // Sign with keystore
    ks := keystore.NewKeyStore("./keystore")
    account := ks.Accounts()[0]
    signedTx, err := ks.SignTx(account, tx.Transaction)
    if err != nil {
        log.Fatal(err)
    }

    // Broadcast
    result, err := conn.Broadcast(signedTx)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Transaction sent: %v\n", result)
}
```

--------------------------------

### Estimate TRON Energy Cost for USDT Transfer

Source: https://gotron.sh/docs/send-usdt-tron-go

Before sending USDT, estimate the energy cost required for the transaction. This helps in managing TRX for transaction fees if energy is insufficient.

```go
resource, err := conn.GetAccountResource("SENDER_ADDRESS")
if err != nil {
    log.Fatal(err)
}

fmt.Printf("Energy available: %d / %d\n",
    resource.GetEnergyLimit()-resource.GetEnergyUsed(),
    resource.GetEnergyLimit(),
)
```

--------------------------------

### Trigger a State-Changing Smart Contract Method in Go

Source: https://gotron.sh/docs/smart-contracts

Use TriggerContract to execute a contract method that modifies state. This requires specifying caller, contract address, method signature, parameters, fee limit, and optionally call value and token details.

```go
tx, err := conn.TriggerContract(
    "CALLER_ADDRESS",
    "CONTRACT_ADDRESS",
    "transfer(address,uint256)",
    `[{"address": "RECIPIENT"}, {"uint256": "1000000"}]`,
    100000000, // fee limit (100 TRX)
    0,           // call value (TRX to send)
    "",          // token ID (empty for TRX)
    0,           // token amount
)
if err != nil {
    log.Fatal(err)
}

// Sign and broadcast tx.Transaction...
```

--------------------------------

### Batch TRC20 Transfers with Goroutines

Source: https://gotron.sh/docs/examples

Sends TRC20 tokens to multiple recipients concurrently using goroutines. Ensure the sender address and contract address are correctly set.

```go
package main

import (
    "fmt"
    "log"
    "math/big"
    "sync"

    "github.com/fbsobreira/gotron-sdk/pkg/client"
)

type Transfer struct {
    To     string
    Amount *big.Int
}

func main() {
    conn := client.NewGrpcClient("grpc.trongrid.io:50051")
    if err := conn.Start(); err != nil {
        log.Fatal(err)
    }
    defer conn.Stop()

    contract := "TOKEN_CONTRACT"
    from := "SENDER_ADDRESS"
    feeLimit := int64(300000)

    transfers := []Transfer{
        {To: "ADDR_1", Amount: big.NewInt(1000)},
        {To: "ADDR_2", Amount: big.NewInt(2000)},
        {To: "ADDR_3", Amount: big.NewInt(3000)},
    }

    var wg sync.WaitGroup
    for _, t := range transfers {
        wg.Add(1)
        go func(t Transfer) {
            defer wg.Done()
            tx, err := conn.TRC20Send(from, t.To, contract, t.Amount, feeLimit)
            if err != nil {
                log.Printf("Failed to send to %s: %v", t.To, err)
                return
            }
            fmt.Printf("Sent %s tokens to %s: %s\n", t.Amount, t.To, tx.GetTxid())
        }(t)
    }
    wg.Wait()
}
```

--------------------------------

### TransferAsset

Source: https://gotron.sh/docs/api-reference

Creates an unsigned TRC10 transfer transaction. Use this method to initiate a transfer of TRC10 tokens.

```APIDOC
## TransferAsset

### Description
Creates an unsigned TRC10 transfer transaction.

### Method
`TransferAsset(from, toAddress, assetID string, amount int64) (*api.TransactionExtention, error)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
* `from` (string) - Required - Sender address (base58)
* `toAddress` (string) - Required - Recipient address (base58)
* `assetID` (string) - Required - The TRC10 asset ID
* `amount` (int64) - Required - The amount of tokens to transfer

### Request Example
```go
transaction, err := client.TransferAsset("TFromAddress", "TToAddress", "1000000", 100)
if err != nil {
    // Handle error
}
```

### Response
#### Success Response
Returns an `api.TransactionExtention` object representing the unsigned transaction.

#### Response Example
None
```

--------------------------------

### TRC20GetName

Source: https://gotron.sh/docs/api-reference

Returns the name of a TRC20 token. This is useful for displaying the token's full name.

```APIDOC
## TRC20GetName

### Description
Returns the token name.

### Method
`TRC20GetName(contractAddress string) (string, error)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
* `contractAddress` (string) - Required - The TRC20 contract address

### Request Example
```go
name, err := client.TRC20GetName("Trc20ContractAddress")
if err != nil {
    // Handle error
}
```

### Response
#### Success Response
Returns a string representing the token name.

#### Response Example
```json
"MyTokenName"
```
```

--------------------------------

### TriggerContract

Source: https://gotron.sh/docs/api-reference

Calls a smart contract method. This is used for interacting with smart contracts that modify state and require broadcasting.

```APIDOC
## TriggerContract

### Description
Calls a smart contract method.

### Method
`TriggerContract(from, contractAddress, method, jsonString string, feeLimit, tAmount int64, tTokenID string, tTokenAmount int64) (*api.TransactionExtention, error)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
* `from` (string) - Required - The address initiating the call (base58)
* `contractAddress` (string) - Required - The smart contract address
* `method` (string) - Required - The name of the smart contract method to call
* `jsonString` (string) - Required - Parameters for the method in JSON format
* `feeLimit` (int64) - Required - The maximum fee limit for the transaction
* `tAmount` (int64) - Optional - The amount of TRX to send with the call (in SUN)
* `tTokenID` (string) - Optional - The ID of the token to send with the call (e.g., TRC10 asset ID)
* `tTokenAmount` (int64) - Optional - The amount of tokens to send with the call

### Request Example
```go
params := "[\"param1_value\"]"
transaction, err := client.TriggerContract("TFromAddress", "Trc20ContractAddress", "transfer", params, 1000000, 0, "", 0)
if err != nil {
    // Handle error
}
```

### Response
#### Success Response
Returns an `api.TransactionExtention` object representing the unsigned transaction.

#### Response Example
None
```

--------------------------------

### Send TRC20 Tokens

Source: https://gotron.sh/docs/cli-usage

Transfer TRC20 tokens between accounts, specifying the token contract address.

```bash
tronctl trc20 transfer \
  --contract <token_address> \
  --from <sender> \
  --to <recipient> \
  --amount 1000
```

--------------------------------

### Vote for Witness Candidates

Source: https://gotron.sh/docs/api-reference

Votes for super representative candidates. Accepts the owner's address and a map of witness addresses to vote counts.

```go
tx, err := conn.VoteWitnessAccount(owner, votes)
```

--------------------------------

### TRC20Send

Source: https://gotron.sh/docs/api-reference

Creates an unsigned TRC20 transfer transaction. This method is used to initiate a TRC20 token transfer.

```APIDOC
## TRC20Send

### Description
Creates an unsigned TRC20 transfer transaction.

### Method
`TRC20Send(from, to, contract string, amount *big.Int, feeLimit int64) (*api.TransactionExtention, error)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
* `from` (string) - Required - Sender address (base58)
* `to` (string) - Required - Recipient address (base58)
* `contract` (string) - Required - The TRC20 contract address
* `amount` (*big.Int) - Required - The amount of tokens to transfer
* `feeLimit` (int64) - Required - The maximum fee limit for the transaction

### Request Example
```go
amount := new(big.Int)
amount.SetString("1000000000000000000", 10) // 1 TRC20 token
feeLimit := int64(1000000)
transaction, err := client.TRC20Send("TFromAddress", "TToAddress", "Trc20ContractAddress", amount, feeLimit)
if err != nil {
    // Handle error
}
```

### Response
#### Success Response
Returns an `api.TransactionExtention` object representing the unsigned transaction.

#### Response Example
None
```

--------------------------------

### Unfreeze Balance

Source: https://gotron.sh/docs/api-reference

Unfreezes previously frozen TRX. Specify the resource code for energy or bandwidth.

```go
tx, err := conn.UnfreezeBalance(from, delegateTo, resource)
```
Tokens:
Raw