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

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

本文将介绍如何使用Go语言创建一个类似TronLink的钱包SDK，包含账户管理、TRX转账、智能合约交互等核心功能。这个实现完全原创，适合集成到各种后端服务中。

什么是TronLink钱包？

TronLink是波场(TRON)区块链上最受欢迎的钱包之一，提供用户友好的界面来管理TRX和TRC代币。我们的Go实现将提供类似的核心功能，但作为后端服务使用。

核心功能设计

1.账户生成与管理
2.TRX转账功能
3.智能合约交互
4.交易查询
5.事件监听

实现代码

1.基础配置和依赖

首先创建项目结构并安装必要的依赖：

mkdirtron-wallet-go
cdtron-wallet-go
gomodinitgithub.com/yourusername/tron-wallet-go

安装依赖：

gogetgithub.com/ethereum/go-ethereum
gogetgithub.com/shengdoushi/base58
gogetgithub.com/btcsuite/btcd/btcec

2.钱包核心结构

创建wallet.go文件：

packagetronwallet

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

    "github.com/btcsuite/btcd/btcec"
    "github.com/ethereum/go-ethereum/common"
    "github.com/shengdoushi/base58"
)

const(
    TronBytePrefix=0x41
    MainnetFullNode="https://api.trongrid.io"
    MainnetSolidity="https://api.trongrid.io"
    MainnetEvent="https://api.trongrid.io"
    ShastaFullNode="https://api.shasta.trongrid.io"
    ShastaSolidity="https://api.shasta.trongrid.io"
    ShastaEvent="https://api.shasta.trongrid.io"
    NileFullNode="https://nile.trongrid.io"
    NileSolidity="https://nile.trongrid.io"
    NileEvent="https://nile.trongrid.io"
)

typeWalletstruct{
    privateKeyecdsa.PrivateKey
    publicKeyecdsa.PublicKey
    addressstring
    networkConfigNetworkConfig
}

typeNetworkConfigstruct{
    FullNodeURLstring
    SolidityURLstring
    EventURLstring
}

funcNewNetworkConfig(networkstring)NetworkConfig{
    switchnetwork{
    case"mainnet":
        returnNetworkConfig{
            FullNodeURL:MainnetFullNode,
            SolidityURL:MainnetSolidity,
            EventURL:MainnetEvent,
        }
    case"shasta":
        returnNetworkConfig{
            FullNodeURL:ShastaFullNode,
            SolidityURL:ShastaSolidity,
            EventURL:ShastaEvent,
        }
    case"nile":
        returnNetworkConfig{
            FullNodeURL:NileFullNode,
            SolidityURL:NileSolidity,
            EventURL:NileEvent,
        }
    default:
        returnNetworkConfig{
            FullNodeURL:MainnetFullNode,
            SolidityURL:MainnetSolidity,
            EventURL:MainnetEvent,
        }
    }
}

//NewWalletcreatesanewwalletwithrandomprivatekey
funcNewWallet(networkstring)(Wallet,error){
    privateKey,err:=btcec.NewPrivateKey(btcec.S256())
    iferr!=nil{
        returnnil,err
    }

    return&Wallet{
        privateKey:privateKey.ToECDSA(),
        publicKey:privateKey.PubKey().ToECDSA(),
        networkConfig:NewNetworkConfig(network),
    },nil
}

//FromPrivateKeycreateswalletfromexistingprivatekey
funcFromPrivateKey(hexPrivateKeystring,networkstring)(Wallet,error){
    privateKeyBytes,err:=hex.DecodeString(hexPrivateKey)
    iferr!=nil{
        returnnil,err
    }

    iflen(privateKeyBytes)!=32{
        returnnil,errors.New("invalidprivatekeylength")
    }

    privateKey,_:=btcec.PrivKeyFromBytes(btcec.S256(),privateKeyBytes)
    return&Wallet{
        privateKey:privateKey.ToECDSA(),
        publicKey:privateKey.PubKey().ToECDSA(),
        networkConfig:NewNetworkConfig(network),
    },nil
}

//GetAddressreturnstheTronaddressinbase58format
func(wWallet)GetAddress()(string,error){
    ifw.address!=""{
        returnw.address,nil
    }

    publicKeyBytes:=FromECDSAPub(w.publicKey)
    //Takelast20bytesoftheKeccak256hashofthepublickey
    addressBytes:=Keccak256(publicKeyBytes[1:])[12:]

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

    //Doublehashforchecksum
    hash1:=Keccak256(addressWithPrefix)
    hash2:=Keccak256(hash1)
    checksum:=hash2[:4]

    //Concatenateaddresswithchecksum
    finalAddress:=append(addressWithPrefix,checksum...)

    //Base58encode
    w.address=base58.Encode(finalAddress,base58.BitcoinAlphabet)

    returnw.address,nil
}

//GetPrivateKeyreturnsthehexencodedprivatekey
func(wWallet)GetPrivateKey()string{
    privateKeyBytes:=FromECDSA(w.privateKey)
    returnhex.EncodeToString(privateKeyBytes)
}

//GetPublicKeyreturnsthehexencodedpublickey
func(wWallet)GetPublicKey()string{
    publicKeyBytes:=FromECDSAPub(w.publicKey)
    returnhex.EncodeToString(publicKeyBytes)
}

//Utilityfunctions(implementtheseorimportfromappropriatepackages)
funcFromECDSAPub(pubecdsa.PublicKey)[]byte{
    ifpub==nil||pub.X==nil||pub.Y==nil{
        returnnil
    }
    returnappend(pub.X.Bytes(),pub.Y.Bytes()...)
}

funcFromECDSA(privecdsa.PrivateKey)[]byte{
    ifpriv==nil{
        returnnil
    }
    returnpriv.D.Bytes()
}

funcKeccak256(data...[]byte)[]byte{
    d:=NewKeccakState()
    for_,b:=rangedata{
        d.Write(b)
    }
    returnd.Sum(nil)
}

//KeccakStateimplementationwouldgohere

3.交易功能实现

创建transaction.go文件：

packagetronwallet

import(
    "bytes"
    "encoding/hex"
    "encoding/json"
    "errors"
    "fmt"
    "io/ioutil"
    "net/http"
    "strconv"
    "strings"
    "time"
)

typeTransactionstruct{
    TxIDstring`json:"txID"`
    RawDatamap[string]interface{}`json:"raw_data"`
    RawDataHexstring`json:"raw_data_hex"`
    Signature[]string`json:"signature"`
    Visiblebool`json:"visible"`
}

typeTransactionResponsestruct{
    Resultbool`json:"result"`
    TxIDstring`json:"txid"`
    Messagestring`json:"message"`
}

typeAccountstruct{
    Addressstring`json:"address"`
    Balanceint64`json:"balance"`
}

func(wWallet)Transfer(toAddressstring,amountint64)(string,error){
    fromAddress,err:=w.GetAddress()
    iferr!=nil{
        return"",err
    }

    //Checkifrecipientaddressisvalid
    if!IsValidAddress(toAddress){
        return"",errors.New("invalidrecipientaddress")
    }

    //Createtransaction
    tx,err:=w.createTransaction(fromAddress,toAddress,amount)
    iferr!=nil{
        return"",err
    }

    //Signtransaction
    signedTx,err:=w.signTransaction(tx)
    iferr!=nil{
        return"",err
    }

    //Broadcasttransaction
    txID,err:=w.broadcastTransaction(signedTx)
    iferr!=nil{
        return"",err
    }

    returntxID,nil
}

func(wWallet)createTransaction(fromAddress,toAddressstring,amountint64)(Transaction,error){
    url:=fmt.Sprintf("%s/wallet/createtransaction",w.networkConfig.FullNodeURL)

    payload:=map[string]interface{}{
        "owner_address":fromAddress,
        "to_address":toAddress,
        "amount":amount,
        "visible":true,
    }

    jsonData,err:=json.Marshal(payload)
    iferr!=nil{
        returnnil,err
    }

    resp,err:=http.Post(url,"application/json",bytes.NewBuffer(jsonData))
    iferr!=nil{
        returnnil,err
    }
    deferresp.Body.Close()

    body,err:=ioutil.ReadAll(resp.Body)
    iferr!=nil{
        returnnil,err
    }

    ifresp.StatusCode!=http.StatusOK{
        returnnil,fmt.Errorf("APIerror:%s",string(body))
    }

    vartxTransaction
    err=json.Unmarshal(body,&tx)
    iferr!=nil{
        returnnil,err
    }

    return&tx,nil
}

func(wWallet)signTransaction(txTransaction)(Transaction,error){
    rawDataBytes,err:=hex.DecodeString(tx.RawDataHex)
    iferr!=nil{
        returnnil,err
    }

    hash:=Keccak256(rawDataBytes)
    signature,err:=btcec.SignCompact(btcec.S256(),(btcec.PrivateKey)(w.privateKey),hash,false)
    iferr!=nil{
        returnnil,err
    }

    //Tronrequiresthesignatureinaspecificformat
    sigBytes:=make([]byte,65)
    copy(sigBytes,signature)
    sigBytes[64]+=27//AddrecoveryID

    tx.Signature=[]string{hex.EncodeToString(sigBytes)}
    returntx,nil
}

func(wWallet)broadcastTransaction(txTransaction)(string,error){
    url:=fmt.Sprintf("%s/wallet/broadcasttransaction",w.networkConfig.FullNodeURL)

    jsonData,err:=json.Marshal(tx)
    iferr!=nil{
        return"",err
    }

    resp,err:=http.Post(url,"application/json",bytes.NewBuffer(jsonData))
    iferr!=nil{
        return"",err
    }
    deferresp.Body.Close()

    body,err:=ioutil.ReadAll(resp.Body)
    iferr!=nil{
        return"",err
    }

    ifresp.StatusCode!=http.StatusOK{
        return"",fmt.Errorf("APIerror:%s",string(body))
    }

    vartxRespTransactionResponse
    err=json.Unmarshal(body,&txResp)
    iferr!=nil{
        return"",err
    }

    if!txResp.Result{
        return"",errors.New(txResp.Message)
    }

    returntxResp.TxID,nil
}

func(wWallet)GetBalance(addressstring)(int64,error){
    url:=fmt.Sprintf("%s/wallet/getaccount",w.networkConfig.FullNodeURL)

    payload:=map[string]interface{}{
        "address":address,
        "visible":true,
    }

    jsonData,err:=json.Marshal(payload)
    iferr!=nil{
        return0,err
    }

    resp,err:=http.Post(url,"application/json",bytes.NewBuffer(jsonData))
    iferr!=nil{
        return0,err
    }
    deferresp.Body.Close()

    body,err:=ioutil.ReadAll(resp.Body)
    iferr!=nil{
        return0,err
    }

    ifresp.StatusCode!=http.StatusOK{
        return0,fmt.Errorf("APIerror:%s",string(body))
    }

    varaccountAccount
    err=json.Unmarshal(body,&account)
    iferr!=nil{
        return0,err
    }

    returnaccount.Balance,nil
}

funcIsValidAddress(addressstring)bool{
    iflen(address)!=34{
        returnfalse
    }

    decoded,err:=base58.Decode(address,base58.BitcoinAlphabet)
    iferr!=nil||len(decoded)!=25{
        returnfalse
    }

    //Verifychecksum
    hash1:=Keccak256(decoded[:21])
    hash2:=Keccak256(hash1)
    if!bytes.Equal(decoded[21:25],hash2[:4]){
        returnfalse
    }

    returntrue
}

4.智能合约交互

创建contract.go文件：

packagetronwallet

import(
    "encoding/hex"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
    "strings"
)

typeContractstruct{
    ContractAddressstring`json:"contract_address"`
    FunctionSelectorstring`json:"function_selector"`
    Parameterstring`json:"parameter"`
}

typeTriggerSmartContractResponsestruct{
    Resultstruct{
        Resultbool`json:"result"`
    }`json:"result"`
    TransactionTransaction`json:"transaction"`
}

func(wWallet)TriggerSmartContract(contractAddress,functionSelector,parameterstring)(string,error){
    fromAddress,err:=w.GetAddress()
    iferr!=nil{
        return"",err
    }

    url:=fmt.Sprintf("%s/wallet/triggersmartcontract",w.networkConfig.FullNodeURL)

    payload:=map[string]interface{}{
        "contract_address":contractAddress,
        "function_selector":functionSelector,
        "parameter":parameter,
        "owner_address":fromAddress,
        "fee_limit":100000000,
        "call_value":0,
        "visible":true,
    }

    jsonData,err:=json.Marshal(payload)
    iferr!=nil{
        return"",err
    }

    resp,err:=http.Post(url,"application/json",bytes.NewBuffer(jsonData))
    iferr!=nil{
        return"",err
    }
    deferresp.Body.Close()

    body,err:=ioutil.ReadAll(resp.Body)
    iferr!=nil{
        return"",err
    }

    ifresp.StatusCode!=http.StatusOK{
        return"",fmt.Errorf("APIerror:%s",string(body))
    }

    varresponseTriggerSmartContractResponse
    err=json.Unmarshal(body,&response)
    iferr!=nil{
        return"",err
    }

    if!response.Result.Result{
        return"",errors.New("contractexecutionfailed")
    }

    //Signthetransaction
    signedTx,err:=w.signTransaction(&response.Transaction)
    iferr!=nil{
        return"",err
    }

    //Broadcastthetransaction
    txID,err:=w.broadcastTransaction(signedTx)
    iferr!=nil{
        return"",err
    }

    returntxID,nil
}

//ForTRC20tokentransfers
func(wWallet)TransferToken(contractAddress,toAddressstring,amountbig.Int)(string,error){
    //Functionselectorfortransfer(address,uint256)
    functionSelector:="transfer(address,uint256)"

    //Parameterencoding:
    //1.Address(toAddress)paddedto32bytes
    //2.Amount(amount)paddedto32bytes

    //ConverttoAddresstohexandremovetheprefix
    hexAddress:=strings.TrimPrefix(toAddress,"T")
    decoded,err:=base58.Decode(hexAddress,base58.BitcoinAlphabet)
    iferr!=nil{
        return"",err
    }

    //Theactualaddressisthefirst21bytes(includingthe0x41prefix)
    addressBytes:=decoded[:21]

    //Padto32bytes
    addressParam:=make([]byte,32)
    copy(addressParam[12:],addressBytes)

    //Convertamountto32bytes
    amountBytes:=amount.Bytes()
    amountParam:=make([]byte,32)
    copy(amountParam[32-len(amountBytes):],amountBytes)

    //Combineparameters
    parameter:=hex.EncodeToString(addressParam)+hex.EncodeToString(amountParam)

    returnw.TriggerSmartContract(contractAddress,functionSelector,parameter)
}

5.使用示例

创建main.go文件展示如何使用这个钱包SDK：

packagemain

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

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

funcmain(){
    //CreateanewwalletonShastatestnet
    wallet,err:=tronwallet.NewWallet("shasta")
    iferr!=nil{
        log.Fatal(err)
    }

    //Getwalletaddress
    address,err:=wallet.GetAddress()
    iferr!=nil{
        log.Fatal(err)
    }

    fmt.Printf("Newwalletcreated:\n")
    fmt.Printf("Address:%s\n",address)
    fmt.Printf("PrivateKey:%s\n",wallet.GetPrivateKey())
    fmt.Printf("PublicKey:%s\n",wallet.GetPublicKey())

    //Checkbalance
    balance,err:=wallet.GetBalance(address)
    iferr!=nil{
        log.Fatal(err)
    }

    fmt.Printf("Balance:%dSUN(1TRX=1,000,000SUN)\n",balance)

    //ExampleofTRXtransfer(uncommentwhenyouhavefunds)
    /
    toAddress:="TXYZ...(recipientaddress)"
    amount:=int64(1000000)//1TRXinSUN
    txID,err:=wallet.Transfer(toAddress,amount)
    iferr!=nil{
        log.Fatal(err)
    }
    fmt.Printf("Transactionsent!TXID:%s\n",txID)
    /

    //ExampleofTRC20tokentransfer
    /
    contractAddress:="TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t"//USDTonShasta
    toAddress:="TXYZ...(recipientaddress)"
    amount:=big.NewInt(1000000)//1USDT(6decimals)
    txID,err:=wallet.TransferToken(contractAddress,toAddress