概述: 用Go搭建模拟客户端作为测试以太坊应用程序的客户端的教程。

使用模拟客户端

您可以使用模拟客户端来快速轻松地在本地测试您的交易，非常适合单元测试。为了开始，我们需要一个带有初始ETH的账户。为此，首先生成一个账户私钥。

  1. privateKey, err := crypto.GenerateKey()
  2. if err != nil {
  3.   log.Fatal(err)
  4. }

接着从accounts/abi/bind包创建一个NewKeyedTransactor，并为其传递私钥。

  1. auth := bind.NewKeyedTransactor(privateKey)

下一步是创建一个创世账户并为其分配初始余额。我们将使用core包的GenesisAccount类型。

  1. balance := new(big.Int)
  2. balance.SetString("10000000000000000000", 10) // 10 eth in wei
  4. address := auth.From
  5. genesisAlloc := map[common.Address]core.GenesisAccount{
  6.   address: {
  7.     Balance: balance,
  8.   },
  9. }

现在我们将创世分配结构体和配置好的汽油上限传给account/abi/bind/backends包的NewSimulatedBackend方法，该方法将返回一个新的模拟以太坊客户端。

  1. blockGasLimit := uint64(4712388)
  2. client := backends.NewSimulatedBackend(genesisAlloc, blockGasLimit)

您可以像往常一样使用此客户端。作为一个示例，我们将构造一个新的交易并进行广播。

  1. fromAddress := auth.From
  2. nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
  3. if err != nil {
  4.   log.Fatal(err)
  5. }
  7. value := big.NewInt(1000000000000000000) // in wei (1 eth)
  8. gasLimit := uint64(21000)                // in units
  9. gasPrice, err := client.SuggestGasPrice(context.Background())
  10. if err != nil {
  11.   log.Fatal(err)
  12. }
  14. toAddress := common.HexToAddress("0x4592d8f8d7b001e72cb26a73e4fa1806a51ac79d")
  15. var data []byte
  16. tx := types.NewTransaction(nonce, toAddress, value, gasLimit, gasPrice, data)
  17. chainID := big.NewInt(1)
  18. signedTx, err := types.SignTx(tx, types.NewEIP155Signer(chainID), privateKey)
  19. if err != nil {
  20.   log.Fatal(err)
  21. }
  23. err = client.SendTransaction(context.Background(), signedTx)
  24. if err != nil {
  25.   log.Fatal(err)
  26. }
  28. fmt.Printf("tx sent: %s\n", signedTx.Hash().Hex()) // tx sent: 0xec3ceb05642c61d33fa6c951b54080d1953ac8227be81e7b5e4e2cfed69eeb51

到现在为止，您可能想知道交易何时才会被开采。为了“开采”它，您还必须做一件额外的事情，在客户端调用Commit提交新开采的区块。

  1. client.Commit()

现在您可以获取交易收据并看见其已被处理。

  1. receipt, err := client.TransactionReceipt(context.Background(), signedTx.Hash())
  2. if err != nil {
  3.   log.Fatal(err)
  4. }
  5. if receipt == nil {
  6.   log.Fatal("receipt is nil. Forgot to commit?")
  7. }
  9. fmt.Printf("status: %v\n", receipt.Status) // status: 1

因此，请记住：模拟客户端允许您使用模拟客户端的Commit方法手动开采区块。

完整代码

client_simulated.go

  1. package main
  3. import (
  4.     "context"
  5.     "fmt"
  6.     "log"
  7.     "math/big"
  9.     "github.com/ethereum/go-ethereum/accounts/abi/bind"
  10.     "github.com/ethereum/go-ethereum/accounts/abi/bind/backends"
  11.     "github.com/ethereum/go-ethereum/common"
  12.     "github.com/ethereum/go-ethereum/core"
  13.     "github.com/ethereum/go-ethereum/core/types"
  14.     "github.com/ethereum/go-ethereum/crypto"
  15. )
  17. func main() {
  18.     privateKey, err := crypto.GenerateKey()
  19.     if err != nil {
  20.         log.Fatal(err)
  21.     }
  23.     auth := bind.NewKeyedTransactor(privateKey)
  25.     balance := new(big.Int)
  26.     balance.SetString("10000000000000000000", 10) // 10 eth in wei
  28.     address := auth.From
  29.     genesisAlloc := map[common.Address]core.GenesisAccount{
  30.         address: {
  31.             Balance: balance,
  32.         },
  33.     }
  35.     blockGasLimit := uint64(4712388)
  36.     client := backends.NewSimulatedBackend(genesisAlloc, blockGasLimit)
  38.     fromAddress := auth.From
  39.     nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
  40.     if err != nil {
  41.         log.Fatal(err)
  42.     }
  44.     value := big.NewInt(1000000000000000000) // in wei (1 eth)
  45.     gasLimit := uint64(21000)                // in units
  46.     gasPrice, err := client.SuggestGasPrice(context.Background())
  47.     if err != nil {
  48.         log.Fatal(err)
  49.     }
  51.     toAddress := common.HexToAddress("0x4592d8f8d7b001e72cb26a73e4fa1806a51ac79d")
  52.     var data []byte
  53.     tx := types.NewTransaction(nonce, toAddress, value, gasLimit, gasPrice, data)
  55.     chainID := big.NewInt(1)
  56.     signedTx, err := types.SignTx(tx, types.NewEIP155Signer(chainID), privateKey)
  57.     if err != nil {
  58.         log.Fatal(err)
  59.     }
  61.     err = client.SendTransaction(context.Background(), signedTx)
  62.     if err != nil {
  63.         log.Fatal(err)
  64.     }
  66.     fmt.Printf("tx sent: %s\n", signedTx.Hash().Hex()) // tx sent: 0xec3ceb05642c61d33fa6c951b54080d1953ac8227be81e7b5e4e2cfed69eeb51
  68.     client.Commit()
  70.     receipt, err := client.TransactionReceipt(context.Background(), signedTx.Hash())
  71.     if err != nil {
  72.         log.Fatal(err)
  73.     }
  74.     if receipt == nil {
  75.         log.Fatal("receipt is nil. Forgot to commit?")
  76.     }
  78.     fmt.Printf("status: %v\n", receipt.Status) // status: 1
  79. }