使用Go语言实现TronLink钱包功能-完整指南

使用Go语言实现TronLink钱包功能-完整指南

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

1.准备工作

首先，我们需要安装必要的Go依赖包：

gogetgithub.com/fbsobreira/gotron-sdk

2.钱包核心代码实现

2.1钱包结构定义

packagetronwallet

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

    "github.com/fbsobreira/gotron-sdk/pkg/address"
    "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/grpc"
)

//TronWallet代表一个Tron钱包
typeTronWalletstruct{
    privateKeyecdsa.PrivateKey
    publicKeyecdsa.PublicKey
    addressaddress.Address
    conngrpc.ClientConn
    clientapi.WalletClient
}

//NewTronWallet创建一个新的Tron钱包
funcNewTronWallet(privateKeyHexstring,nodeURLstring)(TronWallet,error){
    privateKey,err:=keys.FromPrivateKeyHex(privateKeyHex)
    iferr!=nil{
        returnnil,fmt.Errorf("invalidprivatekey:%v",err)
    }

    publicKey:=&privateKey.PublicKey
    addr:=address.PubkeyToAddress(publicKey)

    conn,err:=grpc.Dial(nodeURL,grpc.WithInsecure())
    iferr!=nil{
        returnnil,fmt.Errorf("failedtoconnecttonode:%v",err)
    }

    client:=api.NewWalletClient(conn)

    return&TronWallet{
        privateKey:privateKey,
        publicKey:publicKey,
        address:addr,
        conn:conn,
        client:client,
    },nil
}

//Close关闭钱包连接
func(wTronWallet)Close()error{
    returnw.conn.Close()
}

2.2账户相关功能

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

//GetPrivateKey获取私钥(十六进制格式)
func(wTronWallet)GetPrivateKey()string{
    returnhex.EncodeToString(keys.PrivateKeyToBytes(w.privateKey))
}

//GetPublicKey获取公钥(十六进制格式)
func(wTronWallet)GetPublicKey()string{
    returnhex.EncodeToString(keys.PublicKeyToBytes(w.publicKey))
}

//GetAccountBalance获取账户余额(TRX)
func(wTronWallet)GetAccountBalance()(big.Float,error){
    account,err:=w.client.GetAccount(w.client.GetAccountContext(),&core.Account{
        Address:w.address.Bytes(),
    })
    iferr!=nil{
        returnnil,fmt.Errorf("failedtogetaccount:%v",err)
    }

    balance:=new(big.Float).SetInt(new(big.Int).SetUint64(account.Balance))
    balance.Quo(balance,big.NewFloat(1e6))//转换为TRX单位

    returnbalance,nil
}

//GetAccountResources获取账户资源信息
func(wTronWallet)GetAccountResources()(api.AccountResourceMessage,error){
    returnw.client.GetAccountResource(w.client.GetAccountResourceContext(),&core.Account{
        Address:w.address.Bytes(),
    })
}

2.3转账功能

//SendTRX发送TRX到指定地址
func(wTronWallet)SendTRX(toAddressstring,amountbig.Float)(string,error){
    //验证接收地址
    toAddr,err:=address.Base58ToAddress(toAddress)
    iferr!=nil{
        return"",fmt.Errorf("invalidtoaddress:%v",err)
    }

    //转换为sun单位(1TRX=1,000,000sun)
    amountSun:=new(big.Int)
    amount.Mul(amount,big.NewFloat(1e6)).Int(amountSun)

    //创建转账交易
    transfer:=&core.TransferContract{
        OwnerAddress:w.address.Bytes(),
        ToAddress:toAddr.Bytes(),
        Amount:amountSun.Int64(),
    }

    //广播交易
    tx,err:=w.client.CreateTransaction(w.client.CreateTransactionContext(),transfer)
    iferr!=nil{
        return"",fmt.Errorf("failedtocreatetransaction:%v",err)
    }

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

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

    if!result.Result{
        return"",fmt.Errorf("transactionfailed:%s",result.Message)
    }

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

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

    signature,err:=keys.SignTransaction(w.privateKey,rawData)
    iferr!=nil{
        returnnil,fmt.Errorf("failedtosigntransaction:%v",err)
    }

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

3.使用示例

下面是如何使用这个钱包的示例代码：

packagemain

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

    "github.com/yourusername/tronwallet"
)

funcmain(){
    //替换为你的私钥和节点URL
    privateKey:="你的私钥(十六进制)"
    nodeURL:="grpc.trongrid.io:50051"//Tron官方节点

    //创建钱包
    wallet,err:=tronwallet.NewTronWallet(privateKey,nodeURL)
    iferr!=nil{
        log.Fatalf("Failedtocreatewallet:%v",err)
    }
    deferwallet.Close()

    //获取钱包信息
    fmt.Printf("Address:%s\n",wallet.GetAddress())
    fmt.Printf("PublicKey:%s\n",wallet.GetPublicKey())

    //查询余额
    balance,err:=wallet.GetAccountBalance()
    iferr!=nil{
        log.Fatalf("Failedtogetbalance:%v",err)
    }
    fmt.Printf("Balance:%sTRX\n",balance.String())

    //转账示例(取消注释以实际执行)
    /
    toAddress:="接收地址"
    amount:=big.NewFloat(1.0)//1TRX
    txID,err:=wallet.SendTRX(toAddress,amount)
    iferr!=nil{
        log.Fatalf("FailedtosendTRX:%v",err)
    }
    fmt.Printf("Transactionsent!TXID:%s\n",txID)
    /
}

4.安全注意事项

1.私钥保护：私钥是访问钱包资金的关键，永远不要将私钥硬编码在代码中或提交到版本控制系统。

2.环境变量：建议使用环境变量来存储私钥：

privateKey:=os.Getenv("TRON_PRIVATE_KEY")

3.HTTPS连接：在生产环境中，应该使用安全的gRPC连接而非grpc.WithInsecure()。

4.错误处理：确保正确处理所有可能的错误，避免资金损失。

5.扩展功能

5.1TRC20代币转账

//SendTRC20发送TRC20代币
func(wTronWallet)SendTRC20(contractAddress,toAddressstring,amountbig.Int)(string,error){
    //验证合约地址
    contractAddr,err:=address.Base58ToAddress(contractAddress)
    iferr!=nil{
        return"",fmt.Errorf("invalidcontractaddress:%v",err)
    }

    //验证接收地址
    toAddr,err:=address.Base58ToAddress(toAddress)
    iferr!=nil{
        return"",fmt.Errorf("invalidtoaddress:%v",err)
    }

    //创建TRC20转账数据
    data,err:=buildTRC20TransferData(toAddr,amount)
    iferr!=nil{
        return"",fmt.Errorf("failedtobuildTRC20data:%v",err)
    }

    //创建触发智能合约交易
    trigger:=&core.TriggerSmartContract{
        OwnerAddress:w.address.Bytes(),
        ContractAddress:contractAddr.Bytes(),
        Data:data,
    }

    //广播交易
    tx,err:=w.client.TriggerConstantContract(w.client.TriggerConstantContractContext(),trigger)
    iferr!=nil{
        return"",fmt.Errorf("failedtocreateTRC20transaction:%v",err)
    }

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

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

    if!result.Result{
        return"",fmt.Errorf("transactionfailed:%s",result.Message)
    }

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

//buildTRC20TransferData构建TRC20转账数据
funcbuildTRC20TransferData(toAddraddress.Address,amountbig.Int)([]byte,error){
    //TRC20transfer函数签名
    methodID:=[]byte{0xa9,0x05,0x9c,0xbb}

    //填充接收地址(32字节)
    toAddressPadded:=common.LeftPadBytes(toAddr.Bytes(),32)

    //填充金额(32字节)
    amountPadded:=common.LeftPadBytes(amount.Bytes(),32)

    //组合数据
    data:=append(methodID,toAddressPadded...)
    data=append(data,amountPadded...)

    returndata,nil
}

5.2交易历史查询

//GetTransactionHistory获取交易历史
func(wTronWallet)GetTransactionHistory(limitint32)([]api.TransactionExtention,error){
    request:=&api.AccountPaginated{
        Account:&core.Account{
            Address:w.address.Bytes(),
        },
        Limit:limit,
    }

    transactions,err:=w.client.GetTransactionListByAccount(w.client.GetTransactionListByAccountContext(),request)
    iferr!=nil{
        returnnil,fmt.Errorf("failedtogettransactionhistory:%v",err)
    }

    returntransactions.Transaction,nil
}

6.总结

本文详细介绍了如何使用Go语言实现TronLink钱包的核心功能，包括：

1.创建和管理Tron账户
2.查询账户余额和资源
3.发送TRX和TRC20代币
4.查询交易历史

这个实现可以作为构建更复杂Tron应用程序的基础，例如交易所、支付网关或去中心化应用的后端服务。

完整代码已托管在GitHub上，你可以根据自己的需求进行扩展和修改。记得在生产环境中使用时，要特别注意安全性和错误处理。

希望这篇文章对你有所帮助！如果你有任何问题或建议，欢迎在评论区留言。