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

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

本文将详细介绍如何使用Go语言实现类似TronLink钱包的核心功能，包括创建账户、查询余额、转账交易等TRON区块链操作。

什么是TronLink钱包？

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

准备工作

在开始之前，请确保已安装以下工具：
-Go1.18+环境
-TRON官方GoSDK(go-tron)

gogetgithub.com/fbsobreira/gotron-sdk

核心代码实现

1.钱包账户管理

packagemain

import(
    "crypto/ecdsa"
    "fmt"
    "log"

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

//Wallet代表一个Tron钱包
typeWalletstruct{
    PrivateKeyecdsa.PrivateKey
    Addressaddress.Address
}

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

    publicKey:=privateKey.Public()
    publicKeyECDSA,ok:=publicKey.(ecdsa.PublicKey)
    if!ok{
        returnnil,fmt.Errorf("无法获取公钥")
    }

    addr:=address.PubkeyToAddress(publicKeyECDSA)

    return&Wallet{
        PrivateKey:privateKey,
        Address:addr,
    },nil
}

//ImportWallet从私钥导入钱包
funcImportWallet(privateKeyHexstring)(Wallet,error){
    privateKey,err:=crypto.HexToECDSA(privateKeyHex)
    iferr!=nil{
        returnnil,fmt.Errorf("无效的私钥:%v",err)
    }

    publicKey:=privateKey.Public()
    publicKeyECDSA,ok:=publicKey.(ecdsa.PublicKey)
    if!ok{
        returnnil,fmt.Errorf("无法获取公钥")
    }

    addr:=address.PubkeyToAddress(publicKeyECDSA)

    return&Wallet{
        PrivateKey:privateKey,
        Address:addr,
    },nil
}

funcmain(){
    //创建新钱包
    wallet,err:=NewWallet()
    iferr!=nil{
        log.Fatalf("创建钱包失败:%v",err)
    }

    fmt.Printf("新钱包地址:%s\n",wallet.Address.Hex())
    fmt.Printf("私钥:%s\n",common.Bytes2Hex(crypto.FromECDSA(wallet.PrivateKey)))
}

2.查询余额和交易历史

packagemain

import(
    "context"
    "fmt"
    "log"
    "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,err
    }
    return&TronClient{conn},nil
}

//GetBalance查询账户余额
func(cTronClient)GetBalance(addrstring)(int64,error){
    account,err:=c.GetAccount(addr)
    iferr!=nil{
        return0,err
    }
    returnaccount.Balance,nil
}

//GetTransactions获取交易历史
func(cTronClient)GetTransactions(addrstring,limitint32)([]core.Transaction,error){
    ctx,cancel:=context.WithTimeout(context.Background(),10time.Second)
    defercancel()

    req:=&api.AccountPaginated{
        Account:&api.Account{
            Address:address.HexToAddress(addr).Bytes(),
        },
        Limit:limit,
    }

    txs,err:=c.Client.GetTransactionListByAccount(ctx,req)
    iferr!=nil{
        returnnil,err
    }

    returntxs.Transaction,nil
}

funcmain(){
    //连接到TRON主网节点
    client,err:=NewTronClient("grpc.trongrid.io:50051")
    iferr!=nil{
        log.Fatalf("连接TRON节点失败:%v",err)
    }

    //查询余额
    balance,err:=client.GetBalance("TNPeeaaFB7K9cmo4uQpcU32zGK8G1NYqeL")
    iferr!=nil{
        log.Fatalf("查询余额失败:%v",err)
    }
    fmt.Printf("账户余额:%dSUN(%.6fTRX)\n",balance,float64(balance)/1e6)

    //查询最近5笔交易
    txs,err:=client.GetTransactions("TNPeeaaFB7K9cmo4uQpcU32zGK8G1NYqeL",5)
    iferr!=nil{
        log.Fatalf("查询交易历史失败:%v",err)
    }
    fmt.Println("\n最近交易:")
    for_,tx:=rangetxs{
        fmt.Printf("TxID:%x\n",tx.GetTxid())
    }
}

3.发送TRX交易

packagemain

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

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

//SendTRX发送TRX交易
func(cTronClient)SendTRX(fromPrivateKey,toAddressstring,amountint64)(string,error){
    //获取私钥
    privateKey,err:=crypto.HexToECDSA(fromPrivateKey)
    iferr!=nil{
        return"",fmt.Errorf("无效的私钥:%v",err)
    }

    //获取发送方地址
    publicKey:=privateKey.Public()
    publicKeyECDSA,ok:=publicKey.(ecdsa.PublicKey)
    if!ok{
        return"",fmt.Errorf("无法获取公钥")
    }
    fromAddress:=address.PubkeyToAddress(publicKeyECDSA)

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

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

    //广播交易
    ctx,cancel:=context.WithTimeout(context.Background(),10time.Second)
    defercancel()

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

    if!result.Result{
        return"",fmt.Errorf("交易失败:%s",result.Message)
    }

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

funcmain(){
    //连接到TRON测试网节点
    client,err:=NewTronClient("grpc.shasta.trongrid.io:50051")
    iferr!=nil{
        log.Fatalf("连接TRON节点失败:%v",err)
    }

    //发送1TRX(1,000,000SUN)
    txID,err:=client.SendTRX(
        "你的私钥",
        "接收地址",
        1000000,//1TRX=1,000,000SUN
    )
    iferr!=nil{
        log.Fatalf("发送交易失败:%v",err)
    }

    fmt.Printf("交易已发送!TxID:%s\n",txID)
    fmt.Printf("查看交易:https://shasta.tronscan.org//transaction/%s\n",txID)
}

高级功能实现

1.TRC20代币操作

packagemain

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

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

//TRC20Contract封装TRC20合约操作
typeTRC20Contractstruct{
    ContractAddressstring
    ClientTronClient
}

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

//BalanceOf查询TRC20代币余额
func(cTRC20Contract)BalanceOf(addrstring)(big.Int,error){
    //构造ABI数据
    abiData,err:=abi.JSON(strings.NewReader(TRC20_ABI))
    iferr!=nil{
        returnnil,err
    }

    data,err:=abiData.Pack("balanceOf",common.HexToAddress(addr))
    iferr!=nil{
        returnnil,err
    }

    //调用合约
    ctx,cancel:=context.WithTimeout(context.Background(),10time.Second)
    defercancel()

    result,err:=c.Client.Client.TriggerConstantContract(
        ctx,
        &core.TriggerSmartContract{
            OwnerAddress:common.HexToAddress(addr).Bytes(),
            ContractAddress:common.HexToAddress(c.ContractAddress).Bytes(),
            Data:data,
        },
    )
    iferr!=nil{
        returnnil,err
    }

    //解析结果
    varbalancebig.Int
    iferr:=abiData.Unpack(&balance,"balanceOf",result.GetConstantResult()[0]);err!=nil{
        returnnil,err
    }

    returnbalance,nil
}

//TransferTRC20代币转账
func(cTRC20Contract)Transfer(fromPrivateKey,toAddressstring,amountbig.Int)(string,error){
    //获取私钥
    privateKey,err:=crypto.HexToECDSA(fromPrivateKey)
    iferr!=nil{
        return"",fmt.Errorf("无效的私钥:%v",err)
    }

    //获取发送方地址
    publicKey:=privateKey.Public()
    publicKeyECDSA,ok:=publicKey.(ecdsa.PublicKey)
    if!ok{
        return"",fmt.Errorf("无法获取公钥")
    }
    fromAddress:=address.PubkeyToAddress(publicKeyECDSA)

    //构造ABI数据
    abiData,err:=abi.JSON(strings.NewReader(TRC20_ABI))
    iferr!=nil{
        return"",err
    }

    data,err:=abiData.Pack("transfer",common.HexToAddress(toAddress),amount)
    iferr!=nil{
        return"",err
    }

    //创建合约调用交易
    tx,err:=c.Client.Client.TriggerContract(
        context.Background(),
        &core.TriggerSmartContract{
            OwnerAddress:fromAddress.Bytes(),
            ContractAddress:common.HexToAddress(c.ContractAddress).Bytes(),
            Data:data,
        },
    )
    iferr!=nil{
        return"",err
    }

    //签名交易
    signedTx,err:=crypto.Sign(tx.Transaction.GetRawData().Hash(),privateKey)
    iferr!=nil{
        return"",fmt.Errorf("签名失败:%v",err)
    }
    tx.Transaction.Signature=append(tx.Transaction.Signature,signedTx)

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

    if!result.Result{
        return"",fmt.Errorf("交易失败:%s",result.Message)
    }

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

constTRC20_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":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"}]`

funcmain(){
    //连接到TRON主网节点
    client,err:=NewTronClient("grpc.trongrid.io:50051")
    iferr!=nil{
        log.Fatalf("连接TRON节点失败:%v",err)
    }

    //USDTTRC20合约地址
    usdtContract:=NewTRC20Contract("TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",client)

    //查询USDT余额
    balance,err:=usdtContract.BalanceOf("你的地址")
    iferr!=nil{
        log.Fatalf("查询USDT余额失败:%v",err)
    }
    fmt.Printf("USDT余额:%s\n",balance.String())

    //发送USDT(100USDT=100000000，因为USDT有6位小数)
    amount:=big.NewInt(100000000)
    txID,err:=usdtContract.Transfer("你的私钥","接收地址",amount)
    iferr!=nil{
        log.Fatalf("发送USDT失败:%v",err)
    }

    fmt.Printf("USDT交易已发送!TxID:%s\n",txID)
}

2.智能合约交互

packagemain

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

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

//SmartContract封装智能合约交互
typeSmartContractstruct{
    ContractAddressstring
    ABIstring
    ClientTronClient
}

//NewSmartContract创建新的智能合约实例
funcNewSmartContract(contractAddress,abistring,clientTronClient)SmartContract{
    return&SmartContract{
        ContractAddress:contractAddress,
        ABI:abi,
        Client:client,
    }
}

//Call调用智能合约只读方法
func(cSmartContract)Call(methodstring,args...interface{})([]interface{},error){
    //解析ABI
    contractABI,err:=abi.JSON(strings.NewReader(c.ABI))
    iferr!=nil{
        returnnil,fmt.Errorf("解析ABI失败:%v",err)
    }

    //打包调用数据
    data,err:=contractABI.Pack(method,args...)
    iferr!=nil{
        returnnil,fmt.Errorf("打包调用数据失败:%v",err)
    }

    //调用合约
    ctx,cancel:=context.WithTimeout(context.Background(),10time.Second)
    defercancel()

    result,err:=c.Client.Client.TriggerConstantContract(
        ctx,
        &core.TriggerSmartContract{
            ContractAddress:common.HexToAddress(c.ContractAddress).Bytes(),
            Data:data,
        },
    )
    iferr!=nil{
        returnnil,fmt.Errorf("调用合约失败:%v",err)
    }

    //解析结果
    outputs,err:=contractABI.Unpack(method,result.GetConstantResult()[0])
    iferr!=nil{
        returnnil,fmt.Errorf("解析结果失败:%v",err)
    }

    returnoutputs,nil
}

//Execute执行智能合约写入方法
func(cSmartContract)Execute(fromPrivateKey,methodstring,args...interface{})(string,error){
    //获取私钥
    privateKey,err:=crypto.HexToECDSA(fromPrivateKey)
    iferr!=nil{
        return"",fmt.Errorf("无效的私钥:%v",err)
    }

    //获取发送方地址
    publicKey:=privateKey.Public()
    publicKeyECDSA,ok:=publicKey.(ecdsa.PublicKey)
    if!ok{
        return"",fmt.Errorf("无法获取公钥")
    }
    fromAddress:=address.PubkeyToAddress(publicKeyECDSA)

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

    //打包调用数据
    data,err:=contractABI.Pack(method,args...)
    iferr!=nil{
        return"",fmt.Errorf("打包调用数据失败:%v",err)
    }

    //创建合约调用交易
    tx,err:=c.Client.Client.TriggerContract(
        context.Background(),
        &core.TriggerSmartContract{
            OwnerAddress:fromAddress.Bytes(),
            ContractAddress:common.HexToAddress(c.ContractAddress).Bytes(),
            Data:data,
        },
    )
    iferr!=nil{
        return"",fmt.Errorf("创建交易失败:%v",err)
    }

    //签名交易
    signedTx,err:=crypto.Sign