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

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

本文将详细介绍如何使用Go语言构建一个类似TronLink的钱包应用，包含完整的源码实现和详细的技术解析。文章内容原创，适合SEO优化。

什么是TronLink钱包？

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

准备工作

在开始编码前，需要安装以下工具：
-Go1.16+
-TronGRPCAPI节点（可使用官方节点）
-必要的Go库：github.com/ethereum/go-ethereum,github.com/shengdoushi/base58等

核心功能实现

1.钱包创建与管理

packagemain

import(
    "crypto/ecdsa"
    "crypto/elliptic"
    "crypto/rand"
    "encoding/hex"
    "fmt"
    "log"

    "github.com/ethereum/go-ethereum/crypto"
    "github.com/shengdoushi/base58"
)

//TRONAddress表示TRON钱包地址
typeTRONAddressstruct{
    PrivateKeyecdsa.PrivateKey
    PublicKeyecdsa.PublicKey
    Addressstring
}

//GenerateTRONAddress生成新的TRON钱包地址
funcGenerateTRONAddress()(TRONAddress,error){
    privateKey,err:=ecdsa.GenerateKey(elliptic.P256(),rand.Reader)
    iferr!=nil{
        returnnil,fmt.Errorf("生成私钥失败:%v",err)
    }

    publicKey:=&privateKey.PublicKey

    //获取未压缩的公钥
    publicKeyBytes:=elliptic.Marshal(elliptic.P256(),publicKey.X,publicKey.Y)

    //计算Keccak-256哈希（TRON使用前20字节）
    hash:=crypto.Keccak256(publicKeyBytes[1:])
    addressBytes:=hash[len(hash)-20:]

    //添加地址前缀0x41(TRON主网)
    addressWithPrefix:=append([]byte{0x41},addressBytes...)

    //计算双SHA256哈希
    hash1:=crypto.Keccak256(addressWithPrefix)
    hash2:=crypto.Keccak256(hash1)

    //取前4字节作为校验和
    checksum:=hash2[:4]

    //组合地址和校验和
    fullAddress:=append(addressWithPrefix,checksum...)

    //Base58编码
    address:=base58.Encode(fullAddress,base58.BitcoinAlphabet)

    return&TRONAddress{
        PrivateKey:privateKey,
        PublicKey:publicKey,
        Address:address,
    },nil
}

//PrivateKeyToTRONAddress从私钥生成TRON地址
funcPrivateKeyToTRONAddress(privateKeyHexstring)(TRONAddress,error){
    privateKeyBytes,err:=hex.DecodeString(privateKeyHex)
    iferr!=nil{
        returnnil,fmt.Errorf("解码私钥失败:%v",err)
    }

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

    publicKey:=&privateKey.PublicKey
    publicKeyBytes:=elliptic.Marshal(elliptic.P256(),publicKey.X,publicKey.Y)

    hash:=crypto.Keccak256(publicKeyBytes[1:])
    addressBytes:=hash[len(hash)-20:]

    addressWithPrefix:=append([]byte{0x41},addressBytes...)

    hash1:=crypto.Keccak256(addressWithPrefix)
    hash2:=crypto.Keccak256(hash1)
    checksum:=hash2[:4]

    fullAddress:=append(addressWithPrefix,checksum...)
    address:=base58.Encode(fullAddress,base58.BitcoinAlphabet)

    return&TRONAddress{
        PrivateKey:privateKey,
        PublicKey:publicKey,
        Address:address,
    },nil
}

funcmain(){
    //示例：生成新钱包
    wallet,err:=GenerateTRONAddress()
    iferr!=nil{
        log.Fatalf("生成钱包失败:%v",err)
    }

    privateKeyBytes:=crypto.FromECDSA(wallet.PrivateKey)
    fmt.Printf("新钱包地址:%s\n",wallet.Address)
    fmt.Printf("私钥(HEX):%s\n",hex.EncodeToString(privateKeyBytes))

    //示例：从私钥恢复钱包
    privateKeyHex:=hex.EncodeToString(privateKeyBytes)
    recoveredWallet,err:=PrivateKeyToTRONAddress(privateKeyHex)
    iferr!=nil{
        log.Fatalf("从私钥恢复钱包失败:%v",err)
    }
    fmt.Printf("恢复的钱包地址:%s\n",recoveredWallet.Address)
}

2.TRX转账功能

packagemain

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

    "github.com/ethereum/go-ethereum/common"
    "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"
)

//SendTRX发送TRX交易
funcSendTRX(fromPrivateKey,toAddressstring,amountint64)(string,error){
    //连接到TRON节点
    conn:=client.NewGrpcClient("grpc.trongrid.io:50051")
    iferr:=conn.Start(grpc.WithInsecure());err!=nil{
        return"",fmt.Errorf("连接TRON节点失败:%v",err)
    }
    deferconn.Stop()

    //从私钥获取钱包
    wallet,err:=PrivateKeyToTRONAddress(fromPrivateKey)
    iferr!=nil{
        return"",fmt.Errorf("获取钱包失败:%v",err)
    }

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

    //签名交易
    privateKeyBytes:=crypto.FromECDSA(wallet.PrivateKey)
    signedTx,err:=conn.SignTransaction(tx.Transaction,privateKeyBytes)
    iferr!=nil{
        return"",fmt.Errorf("签名交易失败:%v",err)
    }

    //广播交易
    result,err:=conn.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
}

//GetTRXBalance获取TRX余额
funcGetTRXBalance(addressstring)(int64,error){
    conn:=client.NewGrpcClient("grpc.trongrid.io:50051")
    iferr:=conn.Start(grpc.WithInsecure());err!=nil{
        return0,fmt.Errorf("连接TRON节点失败:%v",err)
    }
    deferconn.Stop()

    acc,err:=conn.GetAccount(address)
    iferr!=nil{
        return0,fmt.Errorf("获取账户信息失败:%v",err)
    }

    returnacc.Balance,nil
}

funcmain(){
    //示例：发送TRX
    fromPrivateKey:="你的私钥HEX"
    toAddress:="接收地址"
    amount:=int64(1000000)//1TRX=1000000sun

    txID,err:=SendTRX(fromPrivateKey,toAddress,amount)
    iferr!=nil{
        log.Fatalf("发送TRX失败:%v",err)
    }
    fmt.Printf("交易已发送，TXID:%s\n",txID)

    //示例：查询余额
    balance,err:=GetTRXBalance(toAddress)
    iferr!=nil{
        log.Fatalf("查询余额失败:%v",err)
    }
    fmt.Printf("余额:%dsun(%.6fTRX)\n",balance,float64(balance)/1000000)
}

3.TRC20代币操作

packagemain

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

    "github.com/ethereum/go-ethereum/accounts/abi"
    "github.com/ethereum/go-ethereum/common"
    "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"
)

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

//TRC20Transfer发送TRC20代币
funcTRC20Transfer(contractTRC20Contract,fromPrivateKey,toAddressstring,amountbig.Int)(string,error){
    //连接到TRON节点
    conn:=client.NewGrpcClient("grpc.trongrid.io:50051")
    iferr:=conn.Start(grpc.WithInsecure());err!=nil{
        return"",fmt.Errorf("连接TRON节点失败:%v",err)
    }
    deferconn.Stop()

    //从私钥获取钱包
    wallet,err:=PrivateKeyToTRONAddress(fromPrivateKey)
    iferr!=nil{
        return"",fmt.Errorf("获取钱包失败:%v",err)
    }

    //解析ABI
    parsedABI,err:=abi.JSON(strings.NewReader(contract.ABI))
    iferr!=nil{
        return"",fmt.Errorf("解析ABI失败:%v",err)
    }

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

    //创建合约调用交易
    tx,err:=conn.TRC20Call(wallet.Address,contract.ContractAddress,"transfer(address,uint256)",data)
    iferr!=nil{
        return"",fmt.Errorf("创建合约调用交易失败:%v",err)
    }

    //签名交易
    privateKeyBytes:=crypto.FromECDSA(wallet.PrivateKey)
    signedTx,err:=conn.SignTransaction(tx.Transaction,privateKeyBytes)
    iferr!=nil{
        return"",fmt.Errorf("签名交易失败:%v",err)
    }

    //广播交易
    result,err:=conn.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
}

//GetTRC20Balance获取TRC20代币余额
funcGetTRC20Balance(contractTRC20Contract,addressstring)(big.Int,error){
    conn:=client.NewGrpcClient("grpc.trongrid.io:50051")
    iferr:=conn.Start(grpc.WithInsecure());err!=nil{
        returnnil,fmt.Errorf("连接TRON节点失败:%v",err)
    }
    deferconn.Stop()

    //解析ABI
    parsedABI,err:=abi.JSON(strings.NewReader(contract.ABI))
    iferr!=nil{
        returnnil,fmt.Errorf("解析ABI失败:%v",err)
    }

    //构造balanceOf函数调用数据
    data,err:=parsedABI.Pack("balanceOf",common.HexToAddress(address))
    iferr!=nil{
        returnnil,fmt.Errorf("构造调用数据失败:%v",err)
    }

    //调用合约
    result,err:=conn.TRC20CallResult(contract.ContractAddress,"balanceOf(address)",data)
    iferr!=nil{
        returnnil,fmt.Errorf("调用合约失败:%v",err)
    }

    //解析返回数据
    varbalancebig.Int
    iferr:=parsedABI.UnpackIntoInterface(&balance,"balanceOf",result);err!=nil{
        returnnil,fmt.Errorf("解析余额失败:%v",err)
    }

    returnbalance,nil
}

funcmain(){
    //USDTTRC20合约示例
    usdtContract:=TRC20Contract{
        ContractAddress:"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",//USDTTRC20合约地址
        ABI:`[{"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":[],"payable":false,"stateMutability":"nonpayable","type":"function"}]`,
        Decimals:6,
    }

    //示例：查询USDT余额
    address:="你的TRON地址"
    balance,err:=GetTRC20Balance(usdtContract,address)
    iferr!=nil{
        log.Fatalf("查询USDT余额失败:%v",err)
    }
    fmt.Printf("USDT余额:%s(%.6fUSDT)\n",balance.String(),float64(balance.Int64())/1000000)

    //示例：发送USDT
    fromPrivateKey:="你的私钥HEX"
    toAddress:="接收地址"
    amount:=big.NewInt(1000000)//1USDT

    txID,err:=TRC20Transfer(usdtContract,fromPrivateKey,toAddress,amount)
    iferr!=nil{
        log.Fatalf("发送USDT失败:%v",err)
    }
    fmt.Printf("USDT交易已发送，TXID:%s\n",txID)
}

完整TronLink钱包实现

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

packagemain

import(
    "bufio"
    "crypto/ecdsa"
    "crypto/elliptic"
    "crypto/rand"
    "encoding/hex"
    "fmt"
    "log"
    "math/big"
    "os"
    "strconv"
    "strings"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/crypto"
    "github.com/fbsobreira/gotron-sdk/pkg/client"
    "github.com/fbsobreira/gotron-sdk/pkg/proto/api"
    "github.com/shengdoushi/base58"
)

//TRONWallet表示TRON钱包
typeTRONWalletstruct{
    PrivateKeyecdsa.PrivateKey
    Addressstring
    Connclient.GrpcClient
}

//NewTRONWallet创建新的TRON钱包
funcNewTRONWallet()(TRONWallet,error){
    privateKey,err:=ecdsa.GenerateKey(elliptic.P256(),rand.Reader)
    iferr!=nil{
        returnnil,fmt.Errorf("生成私钥失败:%v",err)
    }

    address,err:=privateKeyToAddress(privateKey)
    iferr!=nil{
        returnnil,fmt.Errorf("生成地址失败:%v",err)
    }

    conn:=client.NewGrpcClient("grpc.trongrid.io:50051")
    iferr:=conn.Start();err!=nil{
        returnnil,fmt.Errorf("连接TRON节点失败:%v",err)
    }

    return&TRONWallet{
        PrivateKey:privateKey,
        Address:address,
        Conn:conn,
    },nil
}

//ImportTRONWallet从私钥导入TRON钱包
funcImportTRONWallet(privateKeyHexstring)(TRONWallet,error){
    privateKeyBytes,err:=hex.DecodeString(privateKeyHex)
    iferr!=nil{
        returnnil,fmt.Errorf("解码私钥失败:%v",err)
    }

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

    address,err:=privateKeyToAddress(privateKey)
    iferr!=nil{
        returnnil,fmt.Errorf("生成地址失败:%v",err)
    }

    conn:=client.NewGrpcClient("grpc.trongrid.io:50051")
    iferr:=conn.Start();err!=nil{
        returnnil,fmt.Errorf("连接TRON节点失败:%v",err)
    }

    return&TRONWallet{
        PrivateKey:privateKey,
        Address:address,
        Conn:conn,
    },nil
}

//privateKeyToAddress从私钥生成TRON地址
funcprivateKeyToAddress(privateKeyecdsa.PrivateKey)(string,error){
    publicKey:=&privateKey.PublicKey
    publicKeyBytes:=elliptic.Marshal(elliptic.P256(),publicKey.X,publicKey.Y)

    hash:=crypto.Keccak256(publicKeyBytes[1:])
    addressBytes:=hash[len(hash)-20:]

    addressWithPrefix:=append([]byte{0x41},addressBytes...)

    hash1:=crypto.Keccak256(addressWithPrefix)
    hash2:=crypto.Keccak256(hash1)
    checksum:=hash2[:4]

    fullAddress:=append(addressWithPrefix,checksum...)
    address:=base58.Encode(fullAddress,base58.BitcoinAlphabet)

    returnaddress,nil
}

//GetTRXBalance获取TRX余额
func(wTRONWallet)GetTRXBalance()(int64,error){
    acc,err:=w.Conn.GetAccount(w.Address)
    iferr!=nil{
        return0,fmt.Errorf("获取账户信息失败:%v",err)
    }
    returnacc.Balance,nil
}

//SendTRX发送TRX