使用Go语言实现TronLink钱包功能

使用Go语言实现TronLink钱包功能

本文将详细介绍如何使用Go语言实现类似TronLink钱包的核心功能，包括创建账户、查询余额、转账等操作。我们将使用Tron官方提供的GoSDK来简化开发过程。

什么是TronLink钱包？

TronLink是波场(TRON)区块链上最受欢迎的钱包之一，它允许用户安全地存储、发送和接收TRX及其他TRC代币，并与DApp进行交互。本文将展示如何用Go语言实现其核心功能。

准备工作

安装必要的Go库

首先，我们需要安装Tron官方提供的GoSDK：

goget-ugithub.com/fbsobreira/gotron-sdk

连接Tron节点

我们需要连接到一个Tron节点来执行操作。可以使用官方提供的公共节点或自己搭建的节点。

核心代码实现

1.创建新账户

packagemain

import(
    "fmt"
    "log"

    "github.com/fbsobreira/gotron-sdk/pkg/address"
    "github.com/fbsobreira/gotron-sdk/pkg/common"
    "github.com/fbsobreira/gotron-sdk/pkg/keys"
)

//GenerateNewAccount生成新的Tron账户
funcGenerateNewAccount()(string,string,error){
    //生成新的密钥对
    privateKey,err:=keys.GeneratePrivateKey()
    iferr!=nil{
        return"","",fmt.Errorf("生成私钥失败:%v",err)
    }

    //从私钥获取公钥
    publicKey:=privateKey.PublicKey()

    //生成Tron地址
    addr:=address.PubkeyToAddress(publicKey)

    //将私钥转换为十六进制字符串
    privateKeyHex:=common.Bytes2Hex(privateKey[:])

    //返回地址和私钥
    returnaddr.String(),privateKeyHex,nil
}

funcmain(){
    address,privateKey,err:=GenerateNewAccount()
    iferr!=nil{
        log.Fatalf("创建账户失败:%v",err)
    }

    fmt.Printf("新账户创建成功!\n")
    fmt.Printf("地址:%s\n",address)
    fmt.Printf("私钥:%s\n",privateKey)
}

2.查询账户余额

packagemain

import(
    "context"
    "fmt"
    "log"

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

//GetAccountBalance查询账户余额
funcGetAccountBalance(grpcClientclient.GrpcClient,addressstring)(int64,error){
    //将地址转换为Account类型
    account,err:=grpcClient.GetAccount(address)
    iferr!=nil{
        return0,fmt.Errorf("获取账户信息失败:%v",err)
    }

    //返回余额(单位为sun，1TRX=1,000,000sun)
    returnaccount.Balance,nil
}

funcmain(){
    //连接到Tron节点
    grpcClient:=client.NewGrpcClient("grpc.trongrid.io:50051")
    iferr:=grpcClient.Start();err!=nil{
        log.Fatalf("连接节点失败:%v",err)
    }
    defergrpcClient.Stop()

    //要查询的地址
    address:="TNPeeaaFB7K9cmo4uQpcU32zGK8G1NYqeL"

    balance,err:=GetAccountBalance(grpcClient,address)
    iferr!=nil{
        log.Fatalf("查询余额失败:%v",err)
    }

    //将sun转换为TRX
    trxBalance:=float64(balance)/1_000_000.0
    fmt.Printf("地址%s的余额为:%.6fTRX\n",address,trxBalance)
}

3.发送TRX转账

packagemain

import(
    "context"
    "fmt"
    "log"
    "time"

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

//SendTRX发送TRX转账
funcSendTRX(grpcClientclient.GrpcClient,fromPrivateKeystring,toAddressstring,amountint64)(string,error){
    //解析私钥
    privateKey,err:=keys.FromHexPrivateKey(fromPrivateKey)
    iferr!=nil{
        return"",fmt.Errorf("解析私钥失败:%v",err)
    }

    //获取发送方地址
    fromAddress:=address.PubkeyToAddress(privateKey.PublicKey())

    //创建转账交易
    transfer:=&core.TransferContract{
        OwnerAddress:fromAddress.Bytes(),
        ToAddress:address.HexToAddress(toAddress).Bytes(),
        Amount:amount,
    }

    //创建交易
    tx,err:=grpcClient.Client.CreateTransaction(context.Background(),transfer)
    iferr!=nil{
        return"",fmt.Errorf("创建交易失败:%v",err)
    }

    //签名交易
    signature,err:=privateKey.Sign(tx.GetRawData().Bytes())
    iferr!=nil{
        return"",fmt.Errorf("签名交易失败:%v",err)
    }

    tx.Signature=append(tx.Signature,signature)

    //广播交易
    result,err:=grpcClient.Client.BroadcastTransaction(context.Background(),tx)
    iferr!=nil{
        return"",fmt.Errorf("广播交易失败:%v",err)
    }

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

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

funcmain(){
    //连接到Tron节点
    grpcClient:=client.NewGrpcClient("grpc.trongrid.io:50051")
    iferr:=grpcClient.Start();err!=nil{
        log.Fatalf("连接节点失败:%v",err)
    }
    defergrpcClient.Stop()

    //发送方私钥(测试用，实际应用中应从安全存储获取)
    privateKey:="你的私钥"
    //接收方地址
    toAddress:="接收方地址"
    //转账金额(单位:sun)
    amount:=int64(1_000_000)//1TRX

    txID,err:=SendTRX(grpcClient,privateKey,toAddress,amount)
    iferr!=nil{
        log.Fatalf("转账失败:%v",err)
    }

    fmt.Printf("转账成功!交易ID:%s\n",txID)
}

4.查询交易状态

packagemain

import(
    "context"
    "fmt"
    "log"
    "time"

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

//GetTransactionInfo查询交易信息
funcGetTransactionInfo(grpcClientclient.GrpcClient,txIDstring)(core.TransactionInfo,error){
    //将交易ID转换为字节
    txBytes,err:=common.FromHex(txID)
    iferr!=nil{
        returnnil,fmt.Errorf("解析交易ID失败:%v",err)
    }

    //查询交易信息
    txInfo,err:=grpcClient.GetTransactionInfoByID(context.Background(),txBytes)
    iferr!=nil{
        returnnil,fmt.Errorf("查询交易信息失败:%v",err)
    }

    returntxInfo,nil
}

funcmain(){
    //连接到Tron节点
    grpcClient:=client.NewGrpcClient("grpc.trongrid.io:50051")
    iferr:=grpcClient.Start();err!=nil{
        log.Fatalf("连接节点失败:%v",err)
    }
    defergrpcClient.Stop()

    //要查询的交易ID
    txID:="交易ID"

    //有时交易需要几秒钟才能被确认
    time.Sleep(5time.Second)

    txInfo,err:=GetTransactionInfo(grpcClient,txID)
    iferr!=nil{
        log.Fatalf("查询交易失败:%v",err)
    }

    fmt.Printf("交易状态:%v\n",txInfo.Result)
    fmt.Printf("区块高度:%d\n",txInfo.BlockNumber)
    fmt.Printf("交易时间:%d\n",txInfo.BlockTimeStamp)
    fmt.Printf("手续费:%dsun\n",txInfo.Fee)
}

完整钱包实现

下面是一个更完整的Tron钱包实现，包含了上述所有功能：

packagemain

import(
    "bufio"
    "context"
    "fmt"
    "log"
    "os"
    "strconv"
    "strings"
    "time"

    "github.com/fbsobreira/gotron-sdk/pkg/address"
    "github.com/fbsobreira/gotron-sdk/pkg/client"
    "github.com/fbsobreira/gotron-sdk/pkg/common"
    "github.com/fbsobreira/gotron-sdk/pkg/keys"
    "github.com/fbsobreira/gotron-sdk/pkg/proto/core"
)

typeTronWalletstruct{
    grpcClientclient.GrpcClient
    privateKeystring
    addressstring
}

//NewTronWallet创建新的Tron钱包实例
funcNewTronWallet(nodeURLstring)TronWallet{
    grpcClient:=client.NewGrpcClient(nodeURL)
    iferr:=grpcClient.Start();err!=nil{
        log.Fatalf("连接节点失败:%v",err)
    }

    return&TronWallet{
        grpcClient:grpcClient,
    }
}

//GenerateNewAccount生成新账户
func(wTronWallet)GenerateNewAccount()(string,string,error){
    privateKey,err:=keys.GeneratePrivateKey()
    iferr!=nil{
        return"","",fmt.Errorf("生成私钥失败:%v",err)
    }

    publicKey:=privateKey.PublicKey()
    addr:=address.PubkeyToAddress(publicKey)
    privateKeyHex:=common.Bytes2Hex(privateKey[:])

    returnaddr.String(),privateKeyHex,nil
}

//ImportAccount导入已有账户
func(wTronWallet)ImportAccount(privateKeyHexstring)error{
    privateKey,err:=keys.FromHexPrivateKey(privateKeyHex)
    iferr!=nil{
        returnfmt.Errorf("解析私钥失败:%v",err)
    }

    w.privateKey=privateKeyHex
    w.address=address.PubkeyToAddress(privateKey.PublicKey()).String()
    returnnil
}

//GetBalance查询余额
func(wTronWallet)GetBalance(addressstring)(float64,error){
    account,err:=w.grpcClient.GetAccount(address)
    iferr!=nil{
        return0,fmt.Errorf("获取账户信息失败:%v",err)
    }

    returnfloat64(account.Balance)/1_000_000.0,nil
}

//SendTRX发送TRX
func(wTronWallet)SendTRX(toAddressstring,amountfloat64)(string,error){
    ifw.privateKey==""{
        return"",fmt.Errorf("请先导入账户")
    }

    privateKey,err:=keys.FromHexPrivateKey(w.privateKey)
    iferr!=nil{
        return"",fmt.Errorf("解析私钥失败:%v",err)
    }

    amountSun:=int64(amount1_000_000)
    transfer:=&core.TransferContract{
        OwnerAddress:address.HexToAddress(w.address).Bytes(),
        ToAddress:address.HexToAddress(toAddress).Bytes(),
        Amount:amountSun,
    }

    tx,err:=w.grpcClient.Client.CreateTransaction(context.Background(),transfer)
    iferr!=nil{
        return"",fmt.Errorf("创建交易失败:%v",err)
    }

    signature,err:=privateKey.Sign(tx.GetRawData().Bytes())
    iferr!=nil{
        return"",fmt.Errorf("签名交易失败:%v",err)
    }

    tx.Signature=append(tx.Signature,signature)

    result,err:=w.grpcClient.Client.BroadcastTransaction(context.Background(),tx)
    iferr!=nil{
        return"",fmt.Errorf("广播交易失败:%v",err)
    }

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

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

//GetTransactionInfo查询交易信息
func(wTronWallet)GetTransactionInfo(txIDstring)(core.TransactionInfo,error){
    txBytes,err:=common.FromHex(txID)
    iferr!=nil{
        returnnil,fmt.Errorf("解析交易ID失败:%v",err)
    }

    returnw.grpcClient.GetTransactionInfoByID(context.Background(),txBytes)
}

//Close关闭连接
func(wTronWallet)Close(){
    w.grpcClient.Stop()
}

funcmain(){
    //初始化钱包
    wallet:=NewTronWallet("grpc.trongrid.io:50051")
    deferwallet.Close()

    reader:=bufio.NewReader(os.Stdin)

    for{
        fmt.Println("\nTron钱包命令行界面")
        fmt.Println("1.创建新账户")
        fmt.Println("2.导入账户")
        fmt.Println("3.查询余额")
        fmt.Println("4.发送TRX")
        fmt.Println("5.查询交易")
        fmt.Println("0.退出")
        fmt.Print("请选择操作:")

        input,_:=reader.ReadString('\n')
        choice:=strings.TrimSpace(input)

        switchchoice{
        case"1":
            address,privateKey,err:=wallet.GenerateNewAccount()
            iferr!=nil{
                fmt.Printf("创建账户失败:%v\n",err)
                continue
            }
            fmt.Printf("\n新账户创建成功!\n地址:%s\n私钥:%s\n",address,privateKey)

        case"2":
            fmt.Print("请输入私钥:")
            privateKey,_:=reader.ReadString('\n')
            privateKey=strings.TrimSpace(privateKey)

            iferr:=wallet.ImportAccount(privateKey);err!=nil{
                fmt.Printf("导入账户失败:%v\n",err)
                continue
            }
            fmt.Printf("账户导入成功!地址:%s\n",wallet.address)

        case"3":
            varaddressstring
            ifwallet.address!=""{
                fmt.Printf("使用当前账户地址%s(按Enter继续)或输入其他地址:",wallet.address)
                input,_:=reader.ReadString('\n')
                input=strings.TrimSpace(input)
                ifinput!=""{
                    address=input
                }else{
                    address=wallet.address
                }
            }else{
                fmt.Print("请输入要查询的地址:")
                input,_:=reader.ReadString('\n')
                address=strings.TrimSpace(input)
            }

            balance,err:=wallet.GetBalance(address)
            iferr!=nil{
                fmt.Printf("查询余额失败:%v\n",err)
                continue
            }
            fmt.Printf("地址%s的余额为:%.6fTRX\n",address,balance)

        case"4":
            ifwallet.address==""{
                fmt.Println("请先导入账户")
                continue
            }

            fmt.Print("请输入接收方地址:")
            toAddress,_:=reader.ReadString('\n')
            toAddress=strings.TrimSpace(toAddress)

            fmt.Print("请输入转账金额(TRX):")
            amountStr,_:=reader.ReadString('\n')
            amountStr=strings.TrimSpace(amountStr)
            amount,err:=strconv.ParseFloat(amountStr,64)
            iferr!=nil{
                fmt.Printf("无效的金额:%v\n",err)
                continue
            }

            txID,err:=wallet.SendTRX(toAddress,amount)
            iferr!=nil{
                fmt.Printf("转账失败:%v\n",err)
                continue
            }
            fmt.Printf("转账成功!交易ID:%s\n",txID)

        case"5":
            fmt.Print("请输入交易ID:")
            txID,_:=reader.ReadString('\n')
            txID=strings.TrimSpace(txID)

            //等待交易确认
            time.Sleep(5time.Second)

            txInfo,err:=wallet.GetTransactionInfo(txID)
            iferr!=nil{
                fmt.Printf("查询交易失败:%v\n",err)
                continue
            }

            fmt.Printf("\n交易信息:\n")
            fmt.Printf("状态:%v\n",txInfo.Result)
            fmt.Printf("区块高度:%d\n",txInfo.BlockNumber)
            fmt.Printf("时间:%s\n",time.Unix(txInfo.BlockTimeStamp/1000,0))
            fmt.Printf("手续费:%.6fTRX\n",float64(txInfo.Fee)/1_000_000.0)

        case"0":
            fmt.Println("退出钱包")
            return

        default:
            fmt.Println("无效的选择，请重新输入")
        }
    }
}

SEO优化建议

1.关键词优化：在文章中使用"TronLink钱包"、"Go语言区块链开发"、"TRX转账"等关键词。

2.结构化内容：使用清晰的标题和子标题，如本文所示。

3.代码注释：详细注释代码，便于搜索引擎理解内容。

4.长尾关键词：包含"如何使用Go创建Tron钱包"、"Tron区块链开发教程"等长尾词。

5.内部链接：如果有网站，可以链接到相关的区块链开发文章。

安全注意事项

1.私钥必须安全存储，切勿硬编码在代码中或提交到版本控制系统。

2.生产环境中应使用硬件钱包或多重签名等更安全的方案。

3.交易前应仔细检查地址和金额。

4.考虑使用环境变量或加密存储来管理敏感信息。