使用Go语言开发TronLink钱包SDK-完整指南与源码解析

使用Go语言开发TronLink钱包SDK-完整指南与源码解析

本文将详细介绍如何使用Go语言开发一个与TronLink钱包交互的SDK，包含完整的代码实现和详细的解释。这个SDK可以帮助开发者轻松集成TRON区块链功能到他们的Go应用中。

什么是TronLink钱包？

TronLink是TRON区块链上最受欢迎的钱包之一，它允许用户安全地存储、发送和接收TRX及其他TRC代币，并与DApps交互。通过开发一个Go语言的SDK，我们可以让后端服务也能与TRON区块链无缝集成。

开发环境准备

在开始之前，请确保你已经安装了以下工具：

-Go1.16+(推荐最新版本)
-Git
-一个代码编辑器(如VSCode)

项目结构

我们的TronLink钱包SDK将包含以下主要组件：

1.账户管理
2.TRX转账功能
3.TRC20代币操作
4.智能合约交互
5.交易查询

完整代码实现

首先，我们创建一个新的Go模块：

mkdirtronlink-sdk
cdtronlink-sdk
gomodinitgithub.com/yourusername/tronlink-sdk

1.基础配置和工具函数

创建config.go文件：

packagetronlink

import(
    "crypto/ecdsa"
    "encoding/hex"
    "errors"
    "fmt"
    "math/big"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/crypto"
    "github.com/fbsobreira/gotron-sdk/pkg/address"
    "github.com/fbsobreira/gotron-sdk/pkg/client"
    "github.com/fbsobreira/gotron-sdk/pkg/proto/api"
    "github.com/fbsobreira/gotron-sdk/pkg/proto/core"
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials/insecure"
)

const(
    MainnetGrpcEndpoint="grpc.trongrid.io:50051"
    ShastaTestnetGrpc="grpc.shasta.trongrid.io:50051"
)

//TronLinkSDK主结构体
typeTronLinkSDKstruct{
    clientclient.GrpcClient
    privateKeyecdsa.PrivateKey
    addressstring
    isConnectedbool
}

//NewTronLinkSDK创建一个新的TronLinkSDK实例
funcNewTronLinkSDK(privateKeyHex,nodeURLstring)(TronLinkSDK,error){
    //解析私钥
    privateKey,err:=crypto.HexToECDSA(privateKeyHex)
    iferr!=nil{
        returnnil,fmt.Errorf("invalidprivatekey:%v",err)
    }

    //从私钥获取地址
    publicKey:=privateKey.Public()
    publicKeyECDSA,ok:=publicKey.(ecdsa.PublicKey)
    if!ok{
        returnnil,errors.New("errorcastingpublickeytoECDSA")
    }

    addr:=crypto.PubkeyToAddress(publicKeyECDSA)
    tronAddr:=address.PubkeyToAddress(publicKeyECDSA).String()

    //创建gRPC连接
    conn:=client.NewGrpcClient(nodeURL)
    iferr:=conn.Start(grpc.WithTransportCredentials(insecure.NewCredentials()));err!=nil{
        returnnil,fmt.Errorf("failedtoconnecttonode:%v",err)
    }

    return&TronLinkSDK{
        client:conn,
        privateKey:privateKey,
        address:tronAddr,
        isConnected:true,
    },nil
}

//Close关闭连接
func(sdkTronLinkSDK)Close(){
    ifsdk.isConnected{
        sdk.client.Stop()
        sdk.isConnected=false
    }
}

//GetAddress获取当前钱包地址
func(sdkTronLinkSDK)GetAddress()string{
    returnsdk.address
}

2.账户相关功能

创建account.go文件：

packagetronlink

import(
    "context"
    "fmt"

    "github.com/fbsobreira/gotron-sdk/pkg/proto/core"
)

//GetAccountInfo获取账户信息
func(sdkTronLinkSDK)GetAccountInfo(addressstring)(core.Account,error){
    acc,err:=sdk.client.GetAccount(address)
    iferr!=nil{
        returnnil,fmt.Errorf("failedtogetaccountinfo:%v",err)
    }
    returnacc,nil
}

//GetBalance获取账户TRX余额
func(sdkTronLinkSDK)GetBalance(addressstring)(int64,error){
    acc,err:=sdk.GetAccountInfo(address)
    iferr!=nil{
        return0,err
    }
    returnacc.Balance,nil
}

//GetAccountResources获取账户资源信息
func(sdkTronLinkSDK)GetAccountResources(addressstring)(core.AccountResource,error){
    res,err:=sdk.client.GetAccountResource(address)
    iferr!=nil{
        returnnil,fmt.Errorf("failedtogetaccountresources:%v",err)
    }
    returnres,nil
}

//GetAccountTransactions获取账户交易记录
func(sdkTronLinkSDK)GetAccountTransactions(addressstring,limitint32)([]core.Transaction,error){
    txs,err:=sdk.client.GetTransactionsByAddress(address,limit)
    iferr!=nil{
        returnnil,fmt.Errorf("failedtogettransactions:%v",err)
    }
    returntxs,nil
}

3.TRX转账功能

创建transaction.go文件：

packagetronlink

import(
    "context"
    "fmt"
    "math/big"

    "github.com/fbsobreira/gotron-sdk/pkg/common"
    "github.com/fbsobreira/gotron-sdk/pkg/proto/core"
    "google.golang.org/protobuf/proto"
)

//SendTRX发送TRX交易
func(sdkTronLinkSDK)SendTRX(toAddressstring,amountint64)(string,error){
    //验证地址格式
    if!address.IsValid(toAddress){
        return"",fmt.Errorf("invalidtoaddress")
    }

    //创建交易
    tx,err:=sdk.client.Transfer(sdk.address,toAddress,amount)
    iferr!=nil{
        return"",fmt.Errorf("failedtocreatetransfertransaction:%v",err)
    }

    //签名交易
    signedTx,err:=sdk.signTransaction(tx.Transaction)
    iferr!=nil{
        return"",fmt.Errorf("failedtosigntransaction:%v",err)
    }

    //广播交易
    result,err:=sdk.client.Broadcast(signedTx)
    iferr!=nil{
        return"",fmt.Errorf("failedtobroadcasttransaction:%v",err)
    }

    ifresult.Code!=core.Return_SUCCESS{
        return"",fmt.Errorf("transactionfailed:%s",result.Message)
    }

    returncommon.BytesToHexString(tx.GetTxid()),nil
}

//signTransaction签名交易
func(sdkTronLinkSDK)signTransaction(txcore.Transaction)(core.Transaction,error){
    rawData,err:=proto.Marshal(tx.GetRawData())
    iferr!=nil{
        returnnil,fmt.Errorf("failedtomarshalrawdata:%v",err)
    }

    hash:=common.Keccak256(rawData)
    signature,err:=crypto.Sign(hash,sdk.privateKey)
    iferr!=nil{
        returnnil,fmt.Errorf("failedtosigntransaction:%v",err)
    }

    tx.Signature=append(tx.Signature,signature)
    returntx,nil
}

//GetTransactionInfo获取交易详情
func(sdkTronLinkSDK)GetTransactionInfo(txIDstring)(core.TransactionInfo,error){
    txBytes,err:=common.FromHex(txID)
    iferr!=nil{
        returnnil,fmt.Errorf("invalidtransactionID:%v",err)
    }

    info,err:=sdk.client.GetTransactionInfoByID(common.BytesToHexString(txBytes))
    iferr!=nil{
        returnnil,fmt.Errorf("failedtogettransactioninfo:%v",err)
    }

    returninfo,nil
}

4.TRC20代币操作

创建trc20.go文件：

packagetronlink

import(
    "context"
    "fmt"
    "math/big"

    "github.com/ethereum/go-ethereum/accounts/abi"
    "github.com/ethereum/go-ethereum/common"
    "github.com/fbsobreira/gotron-sdk/pkg/abi/trc20"
    "github.com/fbsobreira/gotron-sdk/pkg/proto/core"
)

//TRC20Transfer发送TRC20代币
func(sdkTronLinkSDK)TRC20Transfer(contractAddress,toAddressstring,amountbig.Int)(string,error){
    //验证地址格式
    if!address.IsValid(toAddress)||!address.IsValid(contractAddress){
        return"",fmt.Errorf("invalidaddressformat")
    }

    //加载TRC20合约ABI
    parsedABI,err:=abi.JSON(strings.NewReader(trc20.TRC20ABI))
    iferr!=nil{
        return"",fmt.Errorf("failedtoparseTRC20ABI:%v",err)
    }

    //构造transfer方法调用数据
    data,err:=parsedABI.Pack("transfer",common.HexToAddress(toAddress),amount)
    iferr!=nil{
        return"",fmt.Errorf("failedtopacktransferdata:%v",err)
    }

    //创建智能合约调用交易
    tx,err:=sdk.client.TriggerConstantContract(
        sdk.address,
        contractAddress,
        "transfer",
        data,
    )
    iferr!=nil{
        return"",fmt.Errorf("failedtocreatecontractcall:%v",err)
    }

    //签名交易
    signedTx,err:=sdk.signTransaction(tx.Transaction)
    iferr!=nil{
        return"",fmt.Errorf("failedtosigntransaction:%v",err)
    }

    //广播交易
    result,err:=sdk.client.Broadcast(signedTx)
    iferr!=nil{
        return"",fmt.Errorf("failedtobroadcasttransaction:%v",err)
    }

    ifresult.Code!=core.Return_SUCCESS{
        return"",fmt.Errorf("transactionfailed:%s",result.Message)
    }

    returncommon.BytesToHexString(tx.GetTxid()),nil
}

//GetTRC20Balance获取TRC20代币余额
func(sdkTronLinkSDK)GetTRC20Balance(contractAddress,ownerAddressstring)(big.Int,error){
    //验证地址格式
    if!address.IsValid(ownerAddress)||!address.IsValid(contractAddress){
        returnnil,fmt.Errorf("invalidaddressformat")
    }

    //加载TRC20合约ABI
    parsedABI,err:=abi.JSON(strings.NewReader(trc20.TRC20ABI))
    iferr!=nil{
        returnnil,fmt.Errorf("failedtoparseTRC20ABI:%v",err)
    }

    //构造balanceOf方法调用数据
    data,err:=parsedABI.Pack("balanceOf",common.HexToAddress(ownerAddress))
    iferr!=nil{
        returnnil,fmt.Errorf("failedtopackbalanceOfdata:%v",err)
    }

    //调用合约
    result,err:=sdk.client.TriggerConstantContract(
        ownerAddress,
        contractAddress,
        "balanceOf",
        data,
    )
    iferr!=nil{
        returnnil,fmt.Errorf("failedtocallcontract:%v",err)
    }

    //解析返回结果
    varbalancebig.Int
    iferr:=parsedABI.UnpackIntoInterface(&balance,"balanceOf",result.GetConstantResult()[0]);err!=nil{
        returnnil,fmt.Errorf("failedtounpackbalance:%v",err)
    }

    returnbalance,nil
}

5.智能合约交互

创建contract.go文件：

packagetronlink

import(
    "fmt"

    "github.com/ethereum/go-ethereum/accounts/abi"
    "github.com/fbsobreira/gotron-sdk/pkg/proto/core"
)

//CallContract调用智能合约方法
func(sdkTronLinkSDK)CallContract(contractAddress,methodstring,params...interface{})([]interface{},error){
    //验证地址格式
    if!address.IsValid(contractAddress){
        returnnil,fmt.Errorf("invalidcontractaddress")
    }

    //获取合约ABI(这里需要根据实际合约替换)
    contractABI,err:=abi.JSON(strings.NewReader(`[{"inputs":[],"name":"get","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"}]`))
    iferr!=nil{
        returnnil,fmt.Errorf("failedtoparsecontractABI:%v",err)
    }

    //构造方法调用数据
    data,err:=contractABI.Pack(method,params...)
    iferr!=nil{
        returnnil,fmt.Errorf("failedtopackmethoddata:%v",err)
    }

    //调用合约
    result,err:=sdk.client.TriggerConstantContract(
        sdk.address,
        contractAddress,
        method,
        data,
    )
    iferr!=nil{
        returnnil,fmt.Errorf("failedtocallcontract:%v",err)
    }

    //解析返回结果
    varoutput[]interface{}
    iferr:=contractABI.UnpackIntoInterface(&output,method,result.GetConstantResult()[0]);err!=nil{
        returnnil,fmt.Errorf("failedtounpackresult:%v",err)
    }

    returnoutput,nil
}

//DeployContract部署智能合约
func(sdkTronLinkSDK)DeployContract(abiJSONstring,bytecodestring,params...interface{})(string,error){
    //解析ABI
    contractABI,err:=abi.JSON(strings.NewReader(abiJSON))
    iferr!=nil{
        return"",fmt.Errorf("failedtoparsecontractABI:%v",err)
    }

    //构造构造函数数据
    data,err:=contractABI.Pack("",params...)
    iferr!=nil{
        return"",fmt.Errorf("failedtopackconstructordata:%v",err)
    }

    //合并字节码和构造函数数据
    deployData:=append(common.FromHex(bytecode),data...)

    //创建部署交易
    tx,err:=sdk.client.DeployContract(
        sdk.address,
        "",
        deployData,
        10000000,
        0,
    )
    iferr!=nil{
        return"",fmt.Errorf("failedtocreatedeploytransaction:%v",err)
    }

    //签名交易
    signedTx,err:=sdk.signTransaction(tx.Transaction)
    iferr!=nil{
        return"",fmt.Errorf("failedtosigntransaction:%v",err)
    }

    //广播交易
    result,err:=sdk.client.Broadcast(signedTx)
    iferr!=nil{
        return"",fmt.Errorf("failedtobroadcasttransaction:%v",err)
    }

    ifresult.Code!=core.Return_SUCCESS{
        return"",fmt.Errorf("transactionfailed:%s",result.Message)
    }

    returncommon.BytesToHexString(tx.GetTxid()),nil
}

使用示例

创建一个example/main.go文件来演示如何使用这个SDK：

packagemain

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

    "github.com/yourusername/tronlink-sdk/tronlink"
)

funcmain(){
    //替换为你的私钥
    privateKey:="你的TRON私钥(16进制格式)"

    //创建SDK实例(使用Shasta测试网)
    sdk,err:=tronlink.NewTronLinkSDK(privateKey,tronlink.ShastaTestnetGrpc)
    iferr!=nil{
        log.Fatalf("FailedtocreateTronLinkSDK:%v",err)
    }
    defersdk.Close()

    //获取钱包地址
    address:=sdk.GetAddress()
    fmt.Printf("Walletaddress:%s\n",address)

    //获取余额
    balance,err:=sdk.GetBalance(address)
    iferr!=nil{
        log.Fatalf("Failedtogetbalance:%v",err)
    }
    fmt.Printf("TRXbalance:%dSUN(%.6fTRX)\n",balance,float64(balance)/1_000_000)

    //发送TRX交易示例(取消注释以实际执行)
    /
    toAddress:="接收地址"
    amount:=int64(1_000_000)//1TRX
    txID,err:=sdk.SendTRX(toAddress,amount)
    iferr!=nil{
        log.Fatalf("FailedtosendTRX:%v",err)
    }
    fmt.Printf("TRXsentsuccessfully!TXID:%s\n",txID)
    /

    //TRC20代币操作示例(USDT测试合约)
    usdtContract:="TXLAQ63Xg1NAzckPwKHvzw7CSEmLMEqcdj"//Shasta测试网USDT
    balance,err:=sdk.GetTRC20Balance(usdtContract,address)
    iferr!=nil{
        log.Fatalf("FailedtogetTRC20balance:%v",err)
    }
    fmt.Printf("USDTbalance:%s\n",balance.String())

    //发送TRC20代币示例(取消注释以实际执行)
    /
    toAddress:="接收地址"
    amount:=big.NewInt(1000000)//1USDT(6decimals)
    txID,err:=sdk.TRC20Transfer(usdtContract,toAddress,amount)
    iferr!=nil{
        log.Fatalf("FailedtosendTRC20tokens:%v",err)
    }
    fmt.Printf("TRC20tokenssentsuccessfully!TXID:%s\n",txID)
    /
}

依赖管理

确保你的go.mod文件包含以下依赖：

modulegithub.com/yourusername/tronlink-sdk

go1.19

require(
    github.com/et