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

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

本文将详细介绍如何使用Go语言开发一个类似TronLink的钱包应用，包括密钥管理、交易签名和区块链交互等功能。我们将从基础概念讲起，逐步实现一个功能完整的钱包系统。

一、TronLink钱包概述

TronLink是波场(TRON)区块链上最受欢迎的钱包插件之一，它允许用户安全地存储TRX和TRC代币，并与去中心化应用(DApp)交互。我们的Go语言实现将包含以下核心功能：

1.密钥对生成和管理
2.地址派生
3.交易签名
4.与TRON网络交互
5.余额查询

二、开发环境准备

在开始之前，请确保已安装以下工具：

-Go1.16+
-Git
-一个代码编辑器(如VSCode)

创建项目目录
mkdirtron-wallet-go
cdtron-wallet-go
gomodinitgithub.com/yourusername/tron-wallet-go

三、核心代码实现

1.密钥管理模块

首先，我们实现密钥对的生成和管理功能：

//wallet/crypto.go
packagewallet

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

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

//KeyPair表示一个密钥对
typeKeyPairstruct{
    PrivateKeyecdsa.PrivateKey
    PublicKeyecdsa.PublicKey
}

//GenerateKeyPair生成新的ECDSA密钥对
funcGenerateKeyPair()(KeyPair,error){
    privateKey,err:=ecdsa.GenerateKey(secp256k1.S256(),rand.Reader)
    iferr!=nil{
        returnnil,fmt.Errorf("failedtogenerateprivatekey:%v",err)
    }

    return&KeyPair{
        PrivateKey:privateKey,
        PublicKey:&privateKey.PublicKey,
    },nil
}

//PrivateKeyHex返回16进制格式的私钥
func(kpKeyPair)PrivateKeyHex()string{
    returnhex.EncodeToString(crypto.FromECDSA(kp.PrivateKey))
}

//PublicKeyHex返回16进制格式的公钥
func(kpKeyPair)PublicKeyHex()string{
    returnhex.EncodeToString(crypto.FromECDSAPub(kp.PublicKey))
}

//Address从公钥生成TRON地址
func(kpKeyPair)Address()(string,error){
    pubBytes:=crypto.FromECDSAPub(kp.PublicKey)

    //TRON地址是公钥的Keccak-256哈希的最后20字节
    hash:=crypto.Keccak256(pubBytes[1:])[12:]

    //添加41前缀(Tron的主网地址前缀)
    address:=append([]byte{0x41},hash...)

    returnbase58Encode(address),nil
}

//base58Encode将字节数组编码为Base58字符串
funcbase58Encode(input[]byte)string{
    alphabet:="123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"

    varresult[]byte
    x:=new(big.Int).SetBytes(input)
    base:=big.NewInt(58)
    zero:=big.NewInt(0)
    mod:=new(big.Int)

    forx.Cmp(zero)!=0{
        x.DivMod(x,base,mod)
        result=append(result,alphabet[mod.Int64()])
    }

    //反转结果
    fori,j:=0,len(result)-1;i<j;i,j=i+1,j-1{
        result[i],result[j]=result[j],result[i]
    }

    //添加前导1
    for_,b:=rangeinput{
        ifb!=0{
            break
        }
        result=append([]byte{alphabet[0]},result...)
    }

    returnstring(result)
}

2.钱包结构体

接下来，我们定义钱包结构体和相关方法：

//wallet/wallet.go
packagewallet

import(
    "encoding/json"
    "errors"
    "fmt"
    "io/ioutil"
    "os"
    "path/filepath"
)

//Wallet表示一个TRON钱包
typeWalletstruct{
    KeyPairs[]KeyPair
    FilePathstring
}

//NewWallet创建新钱包
funcNewWallet()Wallet{
    return&Wallet{
        KeyPairs:make([]KeyPair,0),
    }
}

//AddKeyPair添加新的密钥对到钱包
func(wWallet)AddKeyPair(kpKeyPair){
    w.KeyPairs=append(w.KeyPairs,kp)
}

//GenerateNewKeyPair生成并添加新的密钥对
func(wWallet)GenerateNewKeyPair()(KeyPair,error){
    kp,err:=GenerateKeyPair()
    iferr!=nil{
        returnnil,err
    }
    w.AddKeyPair(kp)
    returnkp,nil
}

//SaveToFile将钱包保存到文件
func(wWallet)SaveToFile(passwordstring)error{
    ifw.FilePath==""{
        returnerrors.New("walletfilepathnotset")
    }

    data:=make([]map[string]string,len(w.KeyPairs))
    fori,kp:=rangew.KeyPairs{
        data[i]=map[string]string{
            "privateKey":kp.PrivateKeyHex(),
            "publicKey":kp.PublicKeyHex(),
        }
    }

    //简单加密-实际应用中应使用更安全的加密方式
    encrypted,err:=simpleEncrypt(data,password)
    iferr!=nil{
        returnfmt.Errorf("failedtoencryptwallet:%v",err)
    }

    //确保目录存在
    iferr:=os.MkdirAll(filepath.Dir(w.FilePath),0700);err!=nil{
        returnfmt.Errorf("failedtocreatewalletdirectory:%v",err)
    }

    iferr:=ioutil.WriteFile(w.FilePath,encrypted,0600);err!=nil{
        returnfmt.Errorf("failedtowritewalletfile:%v",err)
    }

    returnnil
}

//LoadFromFile从文件加载钱包
func(wWallet)LoadFromFile(passwordstring)error{
    ifw.FilePath==""{
        returnerrors.New("walletfilepathnotset")
    }

    data,err:=ioutil.ReadFile(w.FilePath)
    iferr!=nil{
        returnfmt.Errorf("failedtoreadwalletfile:%v",err)
    }

    decrypted,err:=simpleDecrypt(data,password)
    iferr!=nil{
        returnfmt.Errorf("failedtodecryptwallet:%v",err)
    }

    varkeyPairs[]map[string]string
    iferr:=json.Unmarshal(decrypted,&keyPairs);err!=nil{
        returnfmt.Errorf("failedtoparsewalletdata:%v",err)
    }

    w.KeyPairs=make([]KeyPair,0,len(keyPairs))
    for_,kpData:=rangekeyPairs{
        privateKey,err:=crypto.HexToECDSA(kpData["privateKey"])
        iferr!=nil{
            returnfmt.Errorf("failedtoparseprivatekey:%v",err)
        }

        w.AddKeyPair(&KeyPair{
            PrivateKey:privateKey,
            PublicKey:&privateKey.PublicKey,
        })
    }

    returnnil
}

//simpleEncrypt简单的加密函数-实际应用中应使用更安全的加密方式
funcsimpleEncrypt(datainterface{},passwordstring)([]byte,error){
    jsonData,err:=json.Marshal(data)
    iferr!=nil{
        returnnil,err
    }
    //这里应该使用更安全的加密算法
    returnjsonData,nil
}

//simpleDecrypt简单的解密函数
funcsimpleDecrypt(data[]byte,passwordstring)([]byte,error){
    //这里应该使用对应的解密算法
    returndata,nil
}

3.TRON网络交互

实现与TRON网络的交互功能：

//tron/client.go
packagetron

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

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

//TRON客户端配置
typeClientstruct{
    FullNodeURLstring
    SolidityNodeURLstring
    EventServerURLstring
    APIKeystring
}

//NewClient创建新的TRON客户端
funcNewClient(fullNode,solidityNode,eventServer,apiKeystring)Client{
    return&Client{
        FullNodeURL:fullNode,
        SolidityNodeURL:solidityNode,
        EventServerURL:eventServer,
        APIKey:apiKey,
    }
}

//GetAccount获取账户信息
func(cClient)GetAccount(addressstring)(map[string]interface{},error){
    url:=c.FullNodeURL+"/wallet/getaccount"
    payload:=map[string]string{"address":address}
    returnc.postRequest(url,payload)
}

//GetBalance获取账户余额
func(cClient)GetBalance(addressstring)(int64,error){
    account,err:=c.GetAccount(address)
    iferr!=nil{
        return0,err
    }

    ifbalance,ok:=account["balance"];ok{
        returnstrconv.ParseInt(balance.(string),10,64)
    }

    return0,nil
}

//CreateTransaction创建TRX转账交易
func(cClient)CreateTransaction(from,tostring,amountint64)(map[string]interface{},error){
    url:=c.FullNodeURL+"/wallet/createtransaction"
    payload:=map[string]interface{}{
        "owner_address":from,
        "to_address":to,
        "amount":amount,
    }
    returnc.postRequest(url,payload)
}

//SignTransaction签名交易
func(cClient)SignTransaction(txmap[string]interface{},privateKeystring)(map[string]interface{},error){
    rawData,ok:=tx["raw_data"].(map[string]interface{})
    if!ok{
        returnnil,fmt.Errorf("invalidtransactiondata")
    }

    rawDataBytes,err:=json.Marshal(rawData)
    iferr!=nil{
        returnnil,fmt.Errorf("failedtomarshalrawdata:%v",err)
    }

    hash:=crypto.Keccak256(rawDataBytes)
    privKey,err:=crypto.HexToECDSA(privateKey)
    iferr!=nil{
        returnnil,fmt.Errorf("invalidprivatekey:%v",err)
    }

    signature,err:=crypto.Sign(hash,privKey)
    iferr!=nil{
        returnnil,fmt.Errorf("failedtosigntransaction:%v",err)
    }

    tx["signature"]=[]string{hex.EncodeToString(signature)}
    returntx,nil
}

//BroadcastTransaction广播交易
func(cClient)BroadcastTransaction(txmap[string]interface{})(map[string]interface{},error){
    url:=c.FullNodeURL+"/wallet/broadcasttransaction"
    returnc.postRequest(url,tx)
}

//postRequest发送POST请求到TRON节点
func(cClient)postRequest(urlstring,payloadinterface{})(map[string]interface{},error){
    jsonData,err:=json.Marshal(payload)
    iferr!=nil{
        returnnil,fmt.Errorf("failedtomarshalpayload:%v",err)
    }

    req,err:=http.NewRequest("POST",url,bytes.NewBuffer(jsonData))
    iferr!=nil{
        returnnil,fmt.Errorf("failedtocreaterequest:%v",err)
    }

    req.Header.Set("Content-Type","application/json")
    ifc.APIKey!=""{
        req.Header.Set("TRON-PRO-API-KEY",c.APIKey)
    }

    client:=&http.Client{}
    resp,err:=client.Do(req)
    iferr!=nil{
        returnnil,fmt.Errorf("requestfailed:%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)
    }

    ifresp.StatusCode!=http.StatusOK{
        returnnil,fmt.Errorf("APIerror:%v",result)
    }

    returnresult,nil
}

4.命令行界面

实现一个简单的命令行界面来与钱包交互：

//cmd/main.go
packagemain

import(
    "bufio"
    "fmt"
    "log"
    "os"
    "path/filepath"
    "strconv"
    "strings"

    "github.com/yourusername/tron-wallet-go/tron"
    "github.com/yourusername/tron-wallet-go/wallet"
)

funcmain(){
    fmt.Println("TRONWalletCLI-AGoimplementationofTronLink")

    //初始化TRON客户端
    client:=tron.NewClient(
        "https://api.trongrid.io",
        "https://api.trongrid.io",
        "https://api.trongrid.io",
        "",//在这里添加你的TRONAPI密钥
    )

    //创建或加载钱包
    walletPath:=filepath.Join(os.Getenv("HOME"),".tronwallet","wallet.dat")
    w:=wallet.NewWallet()
    w.FilePath=walletPath

    if_,err:=os.Stat(walletPath);err==nil{
        fmt.Print("Walletfilefound.Enterpasswordtoload:")
        password:=readInput()
        iferr:=w.LoadFromFile(password);err!=nil{
            log.Fatalf("Failedtoloadwallet:%v",err)
        }
        fmt.Println("Walletloadedsuccessfully")
    }else{
        fmt.Println("Nowalletfound.Creatingnewwallet...")
        fmt.Print("Setapasswordforyournewwallet:")
        password:=readInput()

        //生成第一个密钥对
        kp,err:=w.GenerateNewKeyPair()
        iferr!=nil{
            log.Fatalf("Failedtogeneratekeypair:%v",err)
        }

        address,err:=kp.Address()
        iferr!=nil{
            log.Fatalf("Failedtogenerateaddress:%v",err)
        }

        fmt.Printf("Newwalletcreatedwithaddress:%s\n",address)
        fmt.Println("Pleasebackupyourprivatekeysafely!")
        fmt.Printf("PrivateKey:%s\n",kp.PrivateKeyHex())

        iferr:=w.SaveToFile(password);err!=nil{
            log.Fatalf("Failedtosavewallet:%v",err)
        }
    }

    //主循环
    for{
        fmt.Println("\nMenu:")
        fmt.Println("1.Showaddresses")
        fmt.Println("2.Createnewaddress")
        fmt.Println("3.Checkbalance")
        fmt.Println("4.SendTRX")
        fmt.Println("5.Exit")
        fmt.Print("Chooseanoption:")

        choice:=readInput()
        switchchoice{
        case"1":
            showAddresses(w)
        case"2":
            createNewAddress(w)
        case"3":
            checkBalance(w,client)
        case"4":
            sendTRX(w,client)
        case"5":
            fmt.Println("Goodbye!")
            return
        default:
            fmt.Println("Invalidchoice")
        }
    }
}

funcshowAddresses(wwallet.Wallet){
    fmt.Println("\nYouraddresses:")
    fori,kp:=rangew.KeyPairs{
        address,err:=kp.Address()
        iferr!=nil{
            fmt.Printf("%d.Errorgettingaddress:%v\n",i+1,err)
            continue
        }
        fmt.Printf("%d.%s\n",i+1,address)
    }
}

funccreateNewAddress(wwallet.Wallet){
    kp,err:=w.GenerateNewKeyPair()
    iferr!=nil{
        fmt.Printf("Failedtogeneratenewaddress:%v\n",err)
        return
    }

    address,err:=kp.Address()
    iferr!=nil{
        fmt.Printf("Failedtogenerateaddress:%v\n",err)
        return
    }

    fmt.Printf("\nNewaddresscreated:%s\n",address)
    fmt.Printf("PrivateKey:%s\n",kp.PrivateKeyHex())
    fmt.Println("Pleasebackupyourprivatekeysafely!")

    fmt.Print("Enterwalletpasswordtosavechanges:")
    password:=readInput()
    iferr:=w.SaveToFile(password);err!=nil{
        fmt.Printf("Failedtosavewallet:%v\n",err)
        return
    }
    fmt.Println("Walletsavedsuccessfully")
}

funccheckBalance(wwallet.Wallet,clienttron.Client){
    showAddresses(w)
    fmt.Print("Selectaddressnumbertocheckbalance:")
    choice:=readInput()
    index,err:=strconv.Atoi(choice)
    iferr!=nil||index<1||index>len(w.KeyPairs){
        fmt.Println("Invalidselection")
        return
    }

    kp:=w.KeyPairs[index-1]
    address,err:=kp.Address()
    iferr!=nil{
        fmt.Printf("Failedtogetaddress:%v\n",err)
        return
    }

    balance,err:=client.GetBalance(address)
    iferr!=nil{
        fmt.Printf("Failedtogetbalance:%v\n",err)
        return
    }

    fmt.Printf("Balancefor%s:%dTRX\n",address,balance)
}

funcsendTRX(wwallet.Wallet,clienttron.Client){
    showAddresses(w)
    fmt.Print("Selectsenderaddressnumber:")
    choice:=readInput()
    index,err:=strconv.Atoi(choice)
    iferr!=nil||index<1||index>len(w.KeyPairs){
        fmt.Println("Invalidselection")
        return
    }

    kp:=w.KeyPairs[index-1]
    fromAddress,err:=kp.Address()
    iferr!=nil{
        fmt.Printf("Failed