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

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

本文将详细介绍如何使用Go语言构建一个类似TronLink的钱包应用，包含完整的源码实现和详细的技术说明。

什么是TronLink钱包？

TronLink是TRON区块链上最受欢迎的钱包之一，它允许用户安全地存储、发送和接收TRX及其他TRC代币，并与DApps交互。我们将使用Go语言实现其核心功能。

开发环境准备

在开始之前，请确保已安装以下工具：
-Go1.16+
-Git
-一个代码编辑器（如VSCode）

项目结构

tron-wallet/
├──cmd/
│└──main.go
├──internal/
│├──wallet/
││├──wallet.go
││├──transaction.go
││└──api.go
│└──config/
│└──config.go
├──pkg/
│└──utils/
│└──crypto.go
├──go.mod
└──go.sum

核心功能实现

1.钱包创建与管理

首先实现钱包的基本功能，包括创建、导入和导出钱包。

//internal/wallet/wallet.go
packagewallet

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/proto/core"
    "google.golang.org/protobuf/proto"
)

//Wallet表示一个TRON钱包
typeWalletstruct{
    privateKeyecdsa.PrivateKey
    publicKeyecdsa.PublicKey
    addressaddress.Address
}

//NewWallet创建一个新的TRON钱包
funcNewWallet()(Wallet,error){
    privateKey,err:=crypto.GenerateKey()
    iferr!=nil{
        returnnil,fmt.Errorf("failedtogenerateprivatekey:%v",err)
    }

    publicKey:=privateKey.Public()
    publicKeyECDSA,ok:=publicKey.(ecdsa.PublicKey)
    if!ok{
        returnnil,errors.New("failedtocastpublickeytoECDSA")
    }

    addr:=address.PubkeyToAddress(publicKeyECDSA)

    return&Wallet{
        privateKey:privateKey,
        publicKey:publicKeyECDSA,
        address:addr,
    },nil
}

//ImportFromPrivateKey从私钥导入钱包
funcImportFromPrivateKey(privateKeyHexstring)(Wallet,error){
    privateKeyBytes,err:=hex.DecodeString(privateKeyHex)
    iferr!=nil{
        returnnil,fmt.Errorf("invalidprivatekeyhex:%v",err)
    }

    privateKey,err:=crypto.ToECDSA(privateKeyBytes)
    iferr!=nil{
        returnnil,fmt.Errorf("failedtoconvertbytestoECDSAprivatekey:%v",err)
    }

    publicKey:=privateKey.Public()
    publicKeyECDSA,ok:=publicKey.(ecdsa.PublicKey)
    if!ok{
        returnnil,errors.New("failedtocastpublickeytoECDSA")
    }

    addr:=address.PubkeyToAddress(publicKeyECDSA)

    return&Wallet{
        privateKey:privateKey,
        publicKey:publicKeyECDSA,
        address:addr,
    },nil
}

//GetAddress获取钱包地址
func(wWallet)GetAddress()string{
    returnw.address.String()
}

//GetPrivateKey获取私钥(十六进制格式)
func(wWallet)GetPrivateKey()string{
    privateKeyBytes:=crypto.FromECDSA(w.privateKey)
    returnhex.EncodeToString(privateKeyBytes)
}

//GetPublicKey获取公钥(十六进制格式)
func(wWallet)GetPublicKey()string{
    publicKeyBytes:=crypto.FromECDSAPub(w.publicKey)
    returnhex.EncodeToString(publicKeyBytes)
}

2.交易功能实现

接下来实现TRX转账和TRC20代币转账功能。

//internal/wallet/transaction.go
packagewallet

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

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

//SendTRX发送TRX交易
func(wWallet)SendTRX(toAddressstring,amountbig.Int,grpcEndpointstring)(string,error){
    //验证接收地址
    toAddr,err:=address.Base58ToAddress(toAddress)
    iferr!=nil{
        return"",fmt.Errorf("invalidrecipientaddress:%v",err)
    }

    //创建gRPC连接
    conn:=client.NewGrpcClient(grpcEndpoint)
    iferr:=conn.Start(grpc.WithInsecure());err!=nil{
        return"",fmt.Errorf("failedtoconnecttogrpcendpoint:%v",err)
    }
    deferconn.Stop()

    //获取账户信息
    account,err:=conn.GetAccount(w.GetAddress())
    iferr!=nil{
        return"",fmt.Errorf("failedtogetaccountinfo:%v",err)
    }

    //创建交易
    tx,err:=conn.Transfer(
        w.GetAddress(),
        toAddr.String(),
        amount.Int64(),
    )
    iferr!=nil{
        return"",fmt.Errorf("failedtocreatetransaction:%v",err)
    }

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

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

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

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

//SendTRC20发送TRC20代币交易
func(wWallet)SendTRC20(toAddress,contractAddressstring,amountbig.Int,grpcEndpointstring)(string,error){
    //验证接收地址
    toAddr,err:=address.Base58ToAddress(toAddress)
    iferr!=nil{
        return"",fmt.Errorf("invalidrecipientaddress:%v",err)
    }

    //验证合约地址
    contractAddr,err:=address.Base58ToAddress(contractAddress)
    iferr!=nil{
        return"",fmt.Errorf("invalidcontractaddress:%v",err)
    }

    //创建gRPC连接
    conn:=client.NewGrpcClient(grpcEndpoint)
    iferr:=conn.Start(grpc.WithInsecure());err!=nil{
        return"",fmt.Errorf("failedtoconnecttogrpcendpoint:%v",err)
    }
    deferconn.Stop()

    //创建TRC20转账交易
    transfer:=&core.TriggerSmartContract{
        OwnerAddress:common.HexToBytes(w.GetAddress()),
        ContractAddress:common.HexToBytes(contractAddr.Hex()),
        Data:common.Hex2Bytes(common.BuildTRC20TransferData(toAddr.Hex(),amount)),
    }

    //创建交易
    tx,err:=conn.TriggerContract(context.Background(),transfer)
    iferr!=nil{
        return"",fmt.Errorf("failedtocreateTRC20transaction:%v",err)
    }

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

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

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

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

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

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

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

3.API接口实现

为钱包提供RESTAPI接口。

//internal/wallet/api.go
packagewallet

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

    "github.com/gorilla/mux"
)

//WalletAPI提供钱包的HTTPAPI
typeWalletAPIstruct{
    walletWallet
    grpcURLstring
}

//NewWalletAPI创建新的WalletAPI实例
funcNewWalletAPI(grpcURLstring)WalletAPI{
    return&WalletAPI{
        grpcURL:grpcURL,
    }
}

//CreateWalletResponse创建钱包的响应结构
typeCreateWalletResponsestruct{
    Addressstring`json:"address"`
    PrivateKeystring`json:"private_key"`
    PublicKeystring`json:"public_key"`
}

//CreateWalletHandler处理创建钱包请求
func(apiWalletAPI)CreateWalletHandler(whttp.ResponseWriter,rhttp.Request){
    wallet,err:=NewWallet()
    iferr!=nil{
        http.Error(w,err.Error(),http.StatusInternalServerError)
        return
    }

    api.wallet=wallet

    response:=CreateWalletResponse{
        Address:wallet.GetAddress(),
        PrivateKey:wallet.GetPrivateKey(),
        PublicKey:wallet.GetPublicKey(),
    }

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

//ImportWalletRequest导入钱包的请求结构
typeImportWalletRequeststruct{
    PrivateKeystring`json:"private_key"`
}

//ImportWalletHandler处理导入钱包请求
func(apiWalletAPI)ImportWalletHandler(whttp.ResponseWriter,rhttp.Request){
    varreqImportWalletRequest
    iferr:=json.NewDecoder(r.Body).Decode(&req);err!=nil{
        http.Error(w,"invalidrequestbody",http.StatusBadRequest)
        return
    }

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

    api.wallet=wallet

    response:=CreateWalletResponse{
        Address:wallet.GetAddress(),
        PrivateKey:wallet.GetPrivateKey(),
        PublicKey:wallet.GetPublicKey(),
    }

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

//SendTRXRequest发送TRX的请求结构
typeSendTRXRequeststruct{
    Tostring`json:"to"`
    Amountstring`json:"amount"`
}

//SendTRXHandler处理发送TRX请求
func(apiWalletAPI)SendTRXHandler(whttp.ResponseWriter,rhttp.Request){
    ifapi.wallet==nil{
        http.Error(w,"walletnotinitialized",http.StatusBadRequest)
        return
    }

    varreqSendTRXRequest
    iferr:=json.NewDecoder(r.Body).Decode(&req);err!=nil{
        http.Error(w,"invalidrequestbody",http.StatusBadRequest)
        return
    }

    amount,ok:=new(big.Int).SetString(req.Amount,10)
    if!ok{
        http.Error(w,"invalidamount",http.StatusBadRequest)
        return
    }

    txID,err:=api.wallet.SendTRX(req.To,amount,api.grpcURL)
    iferr!=nil{
        http.Error(w,err.Error(),http.StatusInternalServerError)
        return
    }

    response:=map[string]string{
        "transaction_id":txID,
    }

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

//GetBalanceResponse获取余额的响应结构
typeGetBalanceResponsestruct{
    Addressstring`json:"address"`
    Balancestring`json:"balance"`
}

//GetBalanceHandler处理获取余额请求
func(apiWalletAPI)GetBalanceHandler(whttp.ResponseWriter,rhttp.Request){
    ifapi.wallet==nil{
        http.Error(w,"walletnotinitialized",http.StatusBadRequest)
        return
    }

    conn:=client.NewGrpcClient(api.grpcURL)
    iferr:=conn.Start(grpc.WithInsecure());err!=nil{
        http.Error(w,err.Error(),http.StatusInternalServerError)
        return
    }
    deferconn.Stop()

    account,err:=conn.GetAccount(api.wallet.GetAddress())
    iferr!=nil{
        http.Error(w,err.Error(),http.StatusInternalServerError)
        return
    }

    response:=GetBalanceResponse{
        Address:api.wallet.GetAddress(),
        Balance:strconv.FormatInt(account.Balance,10),
    }

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

//RegisterRoutes注册API路由
func(apiWalletAPI)RegisterRoutes(rmux.Router){
    r.HandleFunc("/wallet/create",api.CreateWalletHandler).Methods("POST")
    r.HandleFunc("/wallet/import",api.ImportWalletHandler).Methods("POST")
    r.HandleFunc("/wallet/balance",api.GetBalanceHandler).Methods("GET")
    r.HandleFunc("/wallet/send",api.SendTRXHandler).Methods("POST")
}

4.主程序入口

//cmd/main.go
packagemain

import(
    "log"
    "net/http"
    "os"

    "github.com/gorilla/mux"
    "github.com/yourusername/tron-wallet/internal/wallet"
)

funcmain(){
    //获取gRPC端点，默认为Tron主网
    grpcEndpoint:=os.Getenv("TRON_GRPC_ENDPOINT")
    ifgrpcEndpoint==""{
        grpcEndpoint="grpc.trongrid.io:50051"
    }

    //创建钱包API
    walletAPI:=wallet.NewWalletAPI(grpcEndpoint)

    //设置路由
    r:=mux.NewRouter()
    walletAPI.RegisterRoutes(r)

    //启动HTTP服务器
    port:=os.Getenv("PORT")
    ifport==""{
        port="8080"
    }

    log.Printf("Startingserveronport%s...",port)
    log.Fatal(http.ListenAndServe(":"+port,r))
}

如何使用这个钱包

1.创建新钱包

curl-XPOSThttp://localhost:8080/wallet/create

响应示例：

{
"address":"TNPeeaaFB7K9cmo4uQpcU32zGK8G1NYqeL",
"private_key":"a0c42a9c3ac6abf2ba6a9946ae83af18f51bf1c9fa7dacc4c92513cc4dd01594",
"public_key":"04b9e5d3e9e5a1f0f7a7b1d3c5e7f2a3b5c7d9e1f3a5b7c9d1e3f5a7b9c1d3e5f7a9b1c3d5e7f9a1b3c5d7e9f1a3b5c7d9e1f3a5b7c9d1e3f5a7b9c1d3e5f7a9b1c3d5"
}

2.导入现有钱包

curl-XPOSThttp://localhost:8080/wallet/import\
-H"Content-Type:application/json"\
-d'{"private_key":"a0c42a9c3ac6abf2ba6a9946ae83af18f51bf1c9fa7dacc4c92513cc4dd01594"}'

3.查询余额

curlhttp://localhost:8080/wallet/balance

4.发送TRX

curl-XPOSThttp://localhost:8080/wallet/send\
-H"Content-Type:application/json"\
-d'{"to":"TNPeeaaFB7K9cmo4uQpcU32zGK8G1NYqeL","amount":"1000000"}'

安全注意事项

1.私钥安全：私钥永远不应该通过网络传输或存储在服务器上。上述实现仅用于演示目的。
2.HTTPS：在生产环境中，务必使用HTTPS来保护API通信。
3.钱包加密：考虑实现钱包加密功能，使用密码保护私钥。

扩展功能

1.多签名支持：实现多签名交易功能
2.DApp浏览器：添加与TRONDApps交互的功能
3.交易历史：记录和查询交易历史
4.通知系统：实现交易通知功能

总结

本文详细介绍了如何使用Go语言构建一个类似TronLink的钱包应用，包括钱包创建、交易处理和API接口实现。这个实现可以作为开发更复杂TRON钱包应用的基础。

完整项目代码可以在GitHub上找到：[项目仓库链接]

希望这篇文章对你理解TRON钱包的工作原理和Go语言区块链开发有所帮助。如果你有任何问题或建议，请在评论区留言。