使用Go语言构建TronLink风格的钱包应用

使用Go语言构建TronLink风格的钱包应用

本文将详细介绍如何使用Go语言构建一个类似TronLink的钱包应用，包括密钥管理、交易签名和区块链交互等功能。所有代码均为原创实现。

1.TronLink钱包概述

TronLink是波场(TRON)区块链上最受欢迎的钱包之一，提供账户管理、TRX转账、智能合约交互等功能。我们将使用Go语言实现其核心功能。

2.项目结构

tron-wallet-go/
├──cmd/
│└──main.go命令行入口
├──pkg/
│├──wallet/钱包核心功能
││├──account.go账户管理
││├──crypto.go加密相关
││├──tron.goTRON交互
││└──types.go类型定义
│└──utils/工具函数
└──go.mod

3.核心代码实现

3.1账户管理(pkg/wallet/account.go)

packagewallet

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

    "github.com/ethereum/go-ethereum/crypto"
    "github.com/ethereum/go-ethereum/crypto/secp256k1"
)

//Account表示一个TRON账户
typeAccountstruct{
    PrivateKeyecdsa.PrivateKey
    PublicKeyecdsa.PublicKey
    Addressstring
}

//NewAccount创建新账户
funcNewAccount()(Account,error){
    privateKey,err:=crypto.GenerateKey()
    iferr!=nil{
        returnnil,fmt.Errorf("failedtogenerateprivatekey:%v",err)
    }

    returnFromPrivateKey(privateKey)
}

//FromPrivateKey从私钥创建账户
funcFromPrivateKey(privateKeyecdsa.PrivateKey)(Account,error){
    publicKey:=&privateKey.PublicKey
    address,err:=publicKeyToAddress(publicKey)
    iferr!=nil{
        returnnil,err
    }

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

//FromPrivateKeyHex从十六进制私钥字符串创建账户
funcFromPrivateKeyHex(privateKeyHexstring)(Account,error){
    privateKeyBytes,err:=hex.DecodeString(privateKeyHex)
    iferr!=nil{
        returnnil,fmt.Errorf("invalidprivatekeyhex:%v",err)
    }

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

    returnFromPrivateKey(privateKey)
}

//publicKeyToAddress将公钥转换为TRON地址
funcpublicKeyToAddress(publicKeyecdsa.PublicKey)(string,error){
    ifpublicKey==nil||publicKey.X==nil||publicKey.Y==nil{
        return"",errors.New("invalidpublickey")
    }

    //TRON地址是公钥的Keccak-256哈希的最后20字节，前面加上0x41
    pubBytes:=crypto.FromECDSAPub(publicKey)
    hash:=crypto.Keccak256(pubBytes[1:])//去掉04前缀
    addressBytes:=hash[len(hash)-20:]

    //TRON地址以0x41开头
    tronAddress:=append([]byte{0x41},addressBytes...)

    returnhex.EncodeToString(tronAddress),nil
}

3.2加密相关(pkg/wallet/crypto.go)

packagewallet

import(
    "crypto/ecdsa"
    "encoding/hex"
    "fmt"

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

//SignMessage对消息进行签名
func(aAccount)SignMessage(message[]byte)(string,error){
    ifa.PrivateKey==nil{
        return"",fmt.Errorf("accounthasnoprivatekey")
    }

    //计算消息的Keccak256哈希
    hash:=crypto.Keccak256(message)

    //签名
    signature,err:=crypto.Sign(hash,a.PrivateKey)
    iferr!=nil{
        return"",fmt.Errorf("failedtosignmessage:%v",err)
    }

    returnhex.EncodeToString(signature),nil
}

//VerifySignature验证签名
funcVerifySignature(publicKeyecdsa.PublicKey,message[]byte,signaturestring)(bool,error){
    sigBytes,err:=hex.DecodeString(signature)
    iferr!=nil{
        returnfalse,fmt.Errorf("invalidsignaturehex:%v",err)
    }

    hash:=crypto.Keccak256(message)

    //从签名中恢复公钥
    recoveredPub,err:=crypto.SigToPub(hash,sigBytes)
    iferr!=nil{
        returnfalse,fmt.Errorf("failedtorecoverpublickey:%v",err)
    }

    //比较恢复的公钥和提供的公钥
    returncrypto.PubkeyToAddress(recoveredPub)==crypto.PubkeyToAddress(publicKey),nil
}

3.3TRON交互(pkg/wallet/tron.go)

packagewallet

import(
    "bytes"
    "encoding/hex"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "time"

    "github.com/ethereum/go-ethereum/common"
)

const(
    tronGridAPI="https://api.trongrid.io"
)

//TronClientTRON网络客户端
typeTronClientstruct{
    APIURLstring
    Clienthttp.Client
}

//NewTronClient创建新的TRON客户端
funcNewTronClient()TronClient{
    return&TronClient{
        APIURL:tronGridAPI,
        Client:&http.Client{Timeout:30time.Second},
    }
}

//GetAccountInfo获取账户信息
func(tcTronClient)GetAccountInfo(addressstring)(map[string]interface{},error){
    url:=fmt.Sprintf("%s/v1/accounts/%s",tc.APIURL,address)
    resp,err:=tc.Client.Get(url)
    iferr!=nil{
        returnnil,fmt.Errorf("failedtogetaccountinfo:%v",err)
    }
    deferresp.Body.Close()

    body,err:=ioutil.ReadAll(resp.Body)
    iferr!=nil{
        returnnil,fmt.Errorf("failedtoreadresponse:%v",err)
    }

    varresultmap[string]interface{}
    iferr:=json.Unmarshal(body,&result);err!=nil{
        returnnil,fmt.Errorf("failedtoparseresponse:%v",err)
    }

    returnresult,nil
}

//SendTRX发送TRX交易
func(tcTronClient)SendTRX(fromAccount,toAddressstring,amountint64)(string,error){
    //构建交易数据
    txData:=map[string]interface{}{
        "owner_address":from.Address,
        "to_address":toAddress,
        "amount":amount,
    }

    jsonData,err:=json.Marshal(txData)
    iferr!=nil{
        return"",fmt.Errorf("failedtomarshaltransactiondata:%v",err)
    }

    //创建未签名交易
    url:=fmt.Sprintf("%s/wallet/createtransaction",tc.APIURL)
    resp,err:=tc.Client.Post(url,"application/json",bytes.NewBuffer(jsonData))
    iferr!=nil{
        return"",fmt.Errorf("failedtocreatetransaction:%v",err)
    }
    deferresp.Body.Close()

    body,err:=ioutil.ReadAll(resp.Body)
    iferr!=nil{
        return"",fmt.Errorf("failedtoreadresponse:%v",err)
    }

    vartxResultmap[string]interface{}
    iferr:=json.Unmarshal(body,&txResult);err!=nil{
        return"",fmt.Errorf("failedtoparsetransactionresponse:%v",err)
    }

    //签名交易
    txID:=txResult["txID"].(string)
    txRawData:=txResult["raw_data"].(map[string]interface{})
    txRawDataBytes,err:=json.Marshal(txRawData)
    iferr!=nil{
        return"",fmt.Errorf("failedtomarshalrawdata:%v",err)
    }

    hash:=crypto.Keccak256(txRawDataBytes)
    signature,err:=crypto.Sign(hash,from.PrivateKey)
    iferr!=nil{
        return"",fmt.Errorf("failedtosigntransaction:%v",err)
    }

    //广播交易
    broadcastData:=map[string]interface{}{
        "txID":txID,
        "raw_data":txRawData,
        "signature":[]string{hex.EncodeToString(signature)},
    }

    broadcastJson,err:=json.Marshal(broadcastData)
    iferr!=nil{
        return"",fmt.Errorf("failedtomarshalbroadcastdata:%v",err)
    }

    broadcastUrl:=fmt.Sprintf("%s/wallet/broadcasttransaction",tc.APIURL)
    broadcastResp,err:=tc.Client.Post(broadcastUrl,"application/json",bytes.NewBuffer(broadcastJson))
    iferr!=nil{
        return"",fmt.Errorf("failedtobroadcasttransaction:%v",err)
    }
    deferbroadcastResp.Body.Close()

    broadcastBody,err:=ioutil.ReadAll(broadcastResp.Body)
    iferr!=nil{
        return"",fmt.Errorf("failedtoreadbroadcastresponse:%v",err)
    }

    varbroadcastResultmap[string]interface{}
    iferr:=json.Unmarshal(broadcastBody,&broadcastResult);err!=nil{
        return"",fmt.Errorf("failedtoparsebroadcastresponse:%v",err)
    }

    if!broadcastResult["result"].(bool){
        return"",fmt.Errorf("transactionfailed:%v",broadcastResult["message"])
    }

    returntxID,nil
}

3.4命令行界面(cmd/main.go)

packagemain

import(
    "fmt"
    "log"
    "os"

    "github.com/urfave/cli/v2"
    "tron-wallet-go/pkg/wallet"
)

funcmain(){
    app:=&cli.App{
        Name:"tron-wallet",
        Usage:"ATRONwalletimplementationinGo",
        Commands:[]cli.Command{
            {
                Name:"new",
                Usage:"CreateanewTRONaccount",
                Action:createAccount,
            },
            {
                Name:"import",
                Usage:"Importanexistingaccountfromprivatekey",
                Flags:[]cli.Flag{
                    &cli.StringFlag{
                        Name:"key",
                        Usage:"Privatekeyinhexformat",
                        Required:true,
                    },
                },
                Action:importAccount,
            },
            {
                Name:"balance",
                Usage:"Checkaccountbalance",
                Flags:[]cli.Flag{
                    &cli.StringFlag{
                        Name:"address",
                        Usage:"TRONaddresstocheck",
                        Required:true,
                    },
                },
                Action:checkBalance,
            },
            {
                Name:"send",
                Usage:"SendTRXtoanotheraddress",
                Flags:[]cli.Flag{
                    &cli.StringFlag{
                        Name:"from",
                        Usage:"Senderprivatekeyinhexformat",
                        Required:true,
                    },
                    &cli.StringFlag{
                        Name:"to",
                        Usage:"RecipientTRONaddress",
                        Required:true,
                    },
                    &cli.Int64Flag{
                        Name:"amount",
                        Usage:"AmountofTRXtosend(inSUN)",
                        Required:true,
                    },
                },
                Action:sendTRX,
            },
        },
    }

    iferr:=app.Run(os.Args);err!=nil{
        log.Fatal(err)
    }
}

funccreateAccount(ccli.Context)error{
    account,err:=wallet.NewAccount()
    iferr!=nil{
        returnfmt.Errorf("failedtocreateaccount:%v",err)
    }

    privateKey:=hex.EncodeToString(crypto.FromECDSA(account.PrivateKey))

    fmt.Println("NewTRONaccountcreated:")
    fmt.Printf("Address:%s\n",account.Address)
    fmt.Printf("PrivateKey:%s\n",privateKey)
    fmt.Printf("PublicKey:%s\n",hex.EncodeToString(crypto.FromECDSAPub(account.PublicKey)))

    returnnil
}

funcimportAccount(ccli.Context)error{
    privateKeyHex:=c.String("key")
    account,err:=wallet.FromPrivateKeyHex(privateKeyHex)
    iferr!=nil{
        returnfmt.Errorf("failedtoimportaccount:%v",err)
    }

    fmt.Println("TRONaccountimported:")
    fmt.Printf("Address:%s\n",account.Address)
    fmt.Printf("PublicKey:%s\n",hex.EncodeToString(crypto.FromECDSAPub(account.PublicKey)))

    returnnil
}

funccheckBalance(ccli.Context)error{
    address:=c.String("address")
    client:=wallet.NewTronClient()

    info,err:=client.GetAccountInfo(address)
    iferr!=nil{
        returnfmt.Errorf("failedtogetaccountinfo:%v",err)
    }

    iflen(info["data"].([]interface{}))==0{
        fmt.Printf("Account%shasnobalanceordoesnotexist\n",address)
        returnnil
    }

    accountData:=info["data"].([]interface{})[0].(map[string]interface{})
    balance:=accountData["balance"].(float64)

    fmt.Printf("Account%shas%.6fTRX\n",address,balance/1000000)
    returnnil
}

funcsendTRX(ccli.Context)error{
    privateKeyHex:=c.String("from")
    toAddress:=c.String("to")
    amount:=c.Int64("amount")

    account,err:=wallet.FromPrivateKeyHex(privateKeyHex)
    iferr!=nil{
        returnfmt.Errorf("failedtoloadsenderaccount:%v",err)
    }

    client:=wallet.NewTronClient()
    txID,err:=client.SendTRX(account,toAddress,amount)
    iferr!=nil{
        returnfmt.Errorf("failedtosendTRX:%v",err)
    }

    fmt.Printf("Transactionsentsuccessfully!\nTxID:%s\n",txID)
    returnnil
}

4.如何使用

4.1安装依赖

gomodinittron-wallet-go
gogetgithub.com/ethereum/go-ethereum
gogetgithub.com/urfave/cli/v2

4.2构建和运行

gobuild-otron-wallet./cmd/main.go

4.3命令示例

1.创建新账户:

./tron-walletnew

2.导入已有账户:

./tron-walletimport--key<your-private-key-hex>

3.查询余额:

./tron-walletbalance--address<tron-address>

4.发送TRX:

./tron-walletsend--from<sender-private-key>--to<recipient-address>--amount<amount-in-sun>

5.安全注意事项

1.私钥安全:永远不要在不安全的环境中存储或传输私钥
2.生产环境:本代码示例适用于学习和测试，生产环境需要更严格的安全措施
3.错误处理:实际应用中需要更完善的错误处理和日志记录

6.总结

本文详细介绍了如何使用Go语言构建一个类似TronLink的钱包应用，包括账户管理、交易签名和区块链交互等核心功能。通过这个项目，你可以学习到:

1.区块链账户的生成和管理
2.加密货币交易的基本原理
3.与TRON区块链的交互方式
4.Go语言在区块链开发中的应用

你可以在此基础上扩展更多功能，如智能合约交互、多币种支持等，构建更完整的钱包应用。