使用Go语言构建TronLink钱包：完整指南与源码实现

使用Go语言构建TronLink钱包：完整指南与源码实现

引言

在区块链技术快速发展的今天，Tron网络因其高吞吐量和低交易费用而广受欢迎。TronLink作为Tron生态中最受欢迎的钱包之一，为用户提供了便捷的TRX和TRC代币管理体验。本文将详细介绍如何使用Go语言从头开始构建一个类似TronLink的钱包应用，包含完整的源码实现。

准备工作

在开始之前，我们需要安装以下工具和库：

1.Go语言环境（1.18+）
2.Tron官方GoSDK：github.com/fbsobreira/gotron-sdk
3.用于加密的库：golang.org/x/crypto

gogetgithub.com/fbsobreira/gotron-sdk/pkg/client
gogetgolang.org/x/crypto/...

钱包核心功能实现

1.钱包账户管理

首先，我们实现钱包账户的核心功能，包括创建新账户、导入私钥、导出私钥等。

packagewallet

import(
    "crypto/ecdsa"
    "encoding/hex"
    "errors"
    "fmt"
    "log"

    "github.com/ethereum/go-ethereum/crypto"
    "github.com/fbsobreira/gotron-sdk/pkg/address"
)

//Wallet表示一个Tron钱包
typeWalletstruct{
    privateKeyecdsa.PrivateKey
    Addressstring
}

//NewWallet创建一个新的Tron钱包
funcNewWallet()(Wallet,error){
    privateKey,err:=crypto.GenerateKey()
    iferr!=nil{
        returnnil,fmt.Errorf("生成密钥失败:%v",err)
    }

    return&Wallet{
        privateKey:privateKey,
        Address:address.PubkeyToAddress(privateKey.PublicKey).Hex(),
    },nil
}

//ImportFromPrivateKey从私钥导入钱包
funcImportFromPrivateKey(hexPrivateKeystring)(Wallet,error){
    privateKeyBytes,err:=hex.DecodeString(hexPrivateKey)
    iferr!=nil{
        returnnil,fmt.Errorf("私钥解码失败:%v",err)
    }

    privateKey,err:=crypto.ToECDSA(privateKeyBytes)
    iferr!=nil{
        returnnil,fmt.Errorf("私钥转换失败:%v",err)
    }

    return&Wallet{
        privateKey:privateKey,
        Address:address.PubkeyToAddress(privateKey.PublicKey).Hex(),
    },nil
}

//GetPrivateKey获取私钥的十六进制字符串
func(wWallet)GetPrivateKey()string{
    returnhex.EncodeToString(crypto.FromECDSA(w.privateKey))
}

//GetPublicKey获取公钥的十六进制字符串
func(wWallet)GetPublicKey()string{
    returnhex.EncodeToString(crypto.FromECDSAPub(&w.privateKey.PublicKey))
}

//ValidateAddress验证Tron地址是否有效
funcValidateAddress(addrstring)bool{
    _,err:=address.Base58ToAddress(addr)
    returnerr==nil
}

2.TRX转账功能实现

接下来，我们实现TRX转账的核心功能：

packagewallet

import(
    "context"
    "math/big"
    "time"

    "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"
)

//TronClient封装Tron网络客户端
typeTronClientstruct{
    client.GrpcClient
}

//NewTronClient创建新的Tron客户端连接
funcNewTronClient(endpointstring)(TronClient,error){
    conn:=client.NewGrpcClient(endpoint)
    iferr:=conn.Start(grpc.WithInsecure());err!=nil{
        returnnil,fmt.Errorf("连接Tron节点失败:%v",err)
    }

    return&TronClient{conn},nil
}

//SendTRX发送TRX交易
func(tcTronClient)SendTRX(wWallet,toAddressstring,amountint64)(string,error){
    //验证接收地址
    if!ValidateAddress(toAddress){
        return"",errors.New("无效的接收地址")
    }

    //创建交易
    tx,err:=tc.Transfer(w.Address,toAddress,amount)
    iferr!=nil{
        return"",fmt.Errorf("创建交易失败:%v",err)
    }

    //签名交易
    signedTx,err:=tc.SignTransaction(tx,w.privateKey)
    iferr!=nil{
        return"",fmt.Errorf("签名交易失败:%v",err)
    }

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

    ifresult.Code!=api.Return_SUCCESS{
        return"",fmt.Errorf("交易失败:%s",result.Message)
    }

    returnhex.EncodeToString(tx.GetTxid()),nil
}

//GetBalance获取TRX余额
func(tcTronClient)GetBalance(addressstring)(big.Int,error){
    acc,err:=tc.GetAccount(address)
    iferr!=nil{
        returnnil,fmt.Errorf("获取账户信息失败:%v",err)
    }
    returnbig.NewInt(acc.Balance),nil
}

//GetTransactionInfo获取交易信息
func(tcTronClient)GetTransactionInfo(txIDstring)(core.TransactionInfo,error){
    ctx,cancel:=context.WithTimeout(context.Background(),10time.Second)
    defercancel()

    txBytes,err:=hex.DecodeString(txID)
    iferr!=nil{
        returnnil,fmt.Errorf("解码交易ID失败:%v",err)
    }

    returntc.Client.GetTransactionInfoById(ctx,&api.BytesMessage{Value:txBytes})
}

3.TRC20代币操作

实现TRC20代币的转账和查询功能：

packagewallet

import(
    "context"
    "encoding/hex"
    "fmt"
    "math/big"
    "strings"

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

//TRC20Contract表示TRC20代币合约
typeTRC20Contractstruct{
    ContractAddressstring
    ClientTronClient
}

//NewTRC20Contract创建新的TRC20合约实例
funcNewTRC20Contract(contractAddressstring,clientTronClient)TRC20Contract{
    return&TRC20Contract{
        ContractAddress:contractAddress,
        Client:client,
    }
}

//TransferTRC20代币转账
func(cTRC20Contract)Transfer(wWallet,toAddressstring,amountbig.Int)(string,error){
    //验证接收地址
    if!ValidateAddress(toAddress){
        return"",errors.New("无效的接收地址")
    }

    //构建ABI数据
    contractABI,err:=abi.JSON(strings.NewReader(TRC20ABI))
    iferr!=nil{
        return"",fmt.Errorf("解析ABI失败:%v",err)
    }

    data,err:=contractABI.Pack("transfer",common.HexToAddress(toAddress),amount)
    iferr!=nil{
        return"",fmt.Errorf("打包数据失败:%v",err)
    }

    //创建触发智能合约交易
    tx,err:=c.Client.TriggerContract(
        w.Address,
        c.ContractAddress,
        "transfer(address,uint256)",
        hex.EncodeToString(data),
        0,
        100000000,
        0,
    )
    iferr!=nil{
        return"",fmt.Errorf("创建合约交易失败:%v",err)
    }

    //签名交易
    signedTx,err:=c.Client.SignTransaction(tx.Transaction,w.privateKey)
    iferr!=nil{
        return"",fmt.Errorf("签名交易失败:%v",err)
    }

    //广播交易
    result,err:=c.Client.Broadcast(signedTx)
    iferr!=nil{
        return"",fmt.Errorf("广播交易失败:%v",err)
    }

    ifresult.Code!=api.Return_SUCCESS{
        return"",fmt.Errorf("交易失败:%s",result.Message)
    }

    returnhex.EncodeToString(tx.Transaction.GetTxid()),nil
}

//BalanceOf查询TRC20代币余额
func(cTRC20Contract)BalanceOf(addressstring)(big.Int,error){
    //构建ABI数据
    contractABI,err:=abi.JSON(strings.NewReader(TRC20ABI))
    iferr!=nil{
        returnnil,fmt.Errorf("解析ABI失败:%v",err)
    }

    data,err:=contractABI.Pack("balanceOf",common.HexToAddress(address))
    iferr!=nil{
        returnnil,fmt.Errorf("打包数据失败:%v",err)
    }

    //调用合约
    result,err:=c.Client.TriggerConstantContract(
        address,
        c.ContractAddress,
        "balanceOf(address)",
        hex.EncodeToString(data),
    )
    iferr!=nil{
        returnnil,fmt.Errorf("调用合约失败:%v",err)
    }

    //解析返回数据
    varbalancebig.Int
    iferr:=contractABI.Unpack(&balance,"balanceOf",common.FromHex(result.GetConstantResult()[0]));err!=nil{
        returnnil,fmt.Errorf("解析余额失败:%v",err)
    }

    returnbalance,nil
}

//TRC20ABI是标准的TRC20合约ABI
constTRC20ABI=`[{"constant":true,"inputs":[{"name":"who","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"to","type":"address"},{"name":"value","type":"uint256"}],"name":"transfer","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"}]`

钱包API服务实现

为了提供Web界面和移动应用访问，我们需要实现一个RESTAPI服务：

packagemain

import(
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    "strconv"

    "github.com/gorilla/mux"
    "tronwallet/wallet"
)

typeServerstruct{
    walletwallet.Wallet
    clientwallet.TronClient
}

funcNewServer()(Server,error){
    //连接到Tron主网节点
    client,err:=wallet.NewTronClient("grpc.trongrid.io:50051")
    iferr!=nil{
        returnnil,fmt.Errorf("连接Tron节点失败:%v",err)
    }

    return&Server{client:client},nil
}

func(sServer)CreateWalletHandler(whttp.ResponseWriter,rhttp.Request){
    newWallet,err:=wallet.NewWallet()
    iferr!=nil{
        http.Error(w,err.Error(),http.StatusInternalServerError)
        return
    }

    s.wallet=newWallet

    response:=map[string]string{
        "address":newWallet.Address,
        "privateKey":newWallet.GetPrivateKey(),
    }

    w.Header().Set("Content-Type","application/json")
    json.NewEncoder(w).Encode(response)
}

func(sServer)ImportWalletHandler(whttp.ResponseWriter,rhttp.Request){
    vardatastruct{
        PrivateKeystring`json:"privateKey"`
    }

    iferr:=json.NewDecoder(r.Body).Decode(&data);err!=nil{
        http.Error(w,"无效的请求体",http.StatusBadRequest)
        return
    }

    importedWallet,err:=wallet.ImportFromPrivateKey(data.PrivateKey)
    iferr!=nil{
        http.Error(w,err.Error(),http.StatusBadRequest)
        return
    }

    s.wallet=importedWallet

    response:=map[string]string{
        "address":importedWallet.Address,
        "message":"钱包导入成功",
    }

    w.Header().Set("Content-Type","application/json")
    json.NewEncoder(w).Encode(response)
}

func(sServer)GetBalanceHandler(whttp.ResponseWriter,rhttp.Request){
    ifs.wallet==nil{
        http.Error(w,"钱包未初始化",http.StatusBadRequest)
        return
    }

    balance,err:=s.client.GetBalance(s.wallet.Address)
    iferr!=nil{
        http.Error(w,err.Error(),http.StatusInternalServerError)
        return
    }

    response:=map[string]string{
        "address":s.wallet.Address,
        "balance":balance.String(),
    }

    w.Header().Set("Content-Type","application/json")
    json.NewEncoder(w).Encode(response)
}

func(sServer)SendTRXHandler(whttp.ResponseWriter,rhttp.Request){
    ifs.wallet==nil{
        http.Error(w,"钱包未初始化",http.StatusBadRequest)
        return
    }

    vardatastruct{
        Tostring`json:"to"`
        Amountstring`json:"amount"`
    }

    iferr:=json.NewDecoder(r.Body).Decode(&data);err!=nil{
        http.Error(w,"无效的请求体",http.StatusBadRequest)
        return
    }

    amount,err:=strconv.ParseInt(data.Amount,10,64)
    iferr!=nil{
        http.Error(w,"无效的金额",http.StatusBadRequest)
        return
    }

    txID,err:=s.client.SendTRX(s.wallet,data.To,amount)
    iferr!=nil{
        http.Error(w,err.Error(),http.StatusInternalServerError)
        return
    }

    response:=map[string]string{
        "transactionId":txID,
        "message":"交易已发送",
    }

    w.Header().Set("Content-Type","application/json")
    json.NewEncoder(w).Encode(response)
}

funcmain(){
    server,err:=NewServer()
    iferr!=nil{
        log.Fatalf("服务器初始化失败:%v",err)
    }

    r:=mux.NewRouter()
    r.HandleFunc("/api/wallet/create",server.CreateWalletHandler).Methods("POST")
    r.HandleFunc("/api/wallet/import",server.ImportWalletHandler).Methods("POST")
    r.HandleFunc("/api/wallet/balance",server.GetBalanceHandler).Methods("GET")
    r.HandleFunc("/api/wallet/send",server.SendTRXHandler).Methods("POST")

    fmt.Println("Tron钱包服务运行在:8080")
    log.Fatal(http.ListenAndServe(":8080",r))
}

安全增强措施

为了确保钱包的安全性，我们需要实现以下安全措施：

packagesecurity

import(
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "encoding/hex"
    "errors"
    "io"
)

//EncryptPrivateKey使用AES加密私钥
funcEncryptPrivateKey(privateKey,passphrasestring)(string,error){
    key:=[]byte(passphrase)
    plaintext:=[]byte(privateKey)

    block,err:=aes.NewCipher(key)
    iferr!=nil{
        return"",err
    }

    ciphertext:=make([]byte,aes.BlockSize+len(plaintext))
    iv:=ciphertext[:aes.BlockSize]
    if_,err:=io.ReadFull(rand.Reader,iv);err!=nil{
        return"",err
    }

    stream:=cipher.NewCFBEncrypter(block,iv)
    stream.XORKeyStream(ciphertext[aes.BlockSize:],plaintext)

    returnhex.EncodeToString(ciphertext),nil
}

//DecryptPrivateKey解密私钥
funcDecryptPrivateKey(encryptedKey,passphrasestring)(string,error){
    key:=[]byte(passphrase)
    ciphertext,err:=hex.DecodeString(encryptedKey)
    iferr!=nil{
        return"",err
    }

    block,err:=aes.NewCipher(key)
    iferr!=nil{
        return"",err
    }

    iflen(ciphertext)<aes.BlockSize{
        return"",errors.New("密文太短")
    }

    iv:=ciphertext[:aes.BlockSize]
    ciphertext=ciphertext[aes.BlockSize:]

    stream:=cipher.NewCFBDecrypter(block,iv)
    stream.XORKeyStream(ciphertext,ciphertext)

    returnstring(ciphertext),nil
}

测试代码

为了确保我们的钱包功能正常工作，我们需要编写测试代码：

packagewallet_test

import(
    "testing"

    "github.com/stretchr/testify/assert"
    "tronwallet/wallet"
)

funcTestNewWallet(ttesting.T){
    w,err:=wallet.NewWallet()
    assert.NoError(t,err)
    assert.NotEmpty(t,w.Address)
    assert.NotEmpty(t,w.GetPrivateKey())
    assert.NotEmpty(t,w.GetPublicKey())
}

funcTestImportWallet(ttesting.T){
    //先创建一个新钱包
    w1,err:=wallet.NewWallet()
    assert.NoError(t,err)

    //从私钥导入钱包
    w2,err:=wallet.ImportFromPrivateKey(w1.GetPrivateKey())
    assert.NoError(t,err)
    assert.Equal(t,w1.Address,w2.Address)
    assert.Equal(t,w1.GetPrivateKey(),w2.GetPrivateKey())
}

funcTestValidateAddress(ttesting.T){
    w,err:=wallet.NewWallet()
    assert.NoError(t,err)

    valid:=wallet.ValidateAddress(w.Address)
    assert.True(t,valid)

    invalid:=wallet.ValidateAddress("invalid_address")
    assert.False(t,invalid)
}

funcTestTRXTransfer(ttesting.T){
    //注意：在实际测试中应该使用测试网
    client,err:=wallet.NewTronClient("grpc.shasta.trongrid.io:50051")//测试网节点
    iferr!=nil{
        t.Skip("无法连接到Tron测试网节点")
    }

    //创建两个钱包
    sender,err:=wallet.NewWallet()
    assert.NoError(t,err)

    receiver,err:=wallet.NewWallet