description: Tutorial on how to set up a simulated backend as your client to test your Ethereum application with Go.

Using a Simulated Client

You can use a simulated client for testing your transactions locally quickly and easily, ideal for unit tests. In order to get started we’re going to need an account with some initial ETH in it. To do that first generate an account private key.

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

Then create a NewKeyedTransactor from the accounts/abi/bind package passing the private key.

  1. auth := bind.NewKeyedTransactor(privateKey)

The next step is to create a genesis account and assign it an initial balance. We’ll be using the GenesisAccount type from the core package.

  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. }

Now we pass the genesis allocation struct and a configured block gas limit to the NewSimulatedBackend method from the accounts/abi/bind/backends package which will return a new simulated ethereum client.

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

You can use this client as you’d normally would. As an example, we’ll construct a new transaction and broadcast it.

  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. signedTx, err := types.SignTx(tx, types.HomesteadSigner{}, privateKey)
  18. if err != nil {
  19.   log.Fatal(err)
  20. }
  22. err = client.SendTransaction(context.Background(), signedTx)
  23. if err != nil {
  24.   log.Fatal(err)
  25. }
  27. fmt.Printf("tx sent: %s\n", signedTx.Hash().Hex()) // tx sent: 0xec3ceb05642c61d33fa6c951b54080d1953ac8227be81e7b5e4e2cfed69eeb51

By now you’re probably wondering when will the transaction actually get mined. Well in order to “mine” it, there’s one additional important thing you must do; call Commit on the client to commit a new mined block.

  1. client.Commit()

Now you can fetch the transaction receipt and see that it was processed.

  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

So remember that the simulated client allows you to manually mine blocks at your command using the simulated client’s Commit method.

-

Full code

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)
  54.     signedTx, err := types.SignTx(tx, types.HomesteadSigner{}, privateKey)
  55.     if err != nil {
  56.         log.Fatal(err)
  57.     }
  59.     err = client.SendTransaction(context.Background(), signedTx)
  60.     if err != nil {
  61.         log.Fatal(err)
  62.     }
  64.     fmt.Printf("tx sent: %s\n", signedTx.Hash().Hex()) // tx sent: 0xec3ceb05642c61d33fa6c951b54080d1953ac8227be81e7b5e4e2cfed69eeb51
  66.     client.Commit()
  68.     receipt, err := client.TransactionReceipt(context.Background(), signedTx.Hash())
  69.     if err != nil {
  70.         log.Fatal(err)
  71.     }
  72.     if receipt == nil {
  73.         log.Fatal("receipt is nil. Forgot to commit?")
  74.     }
  76.     fmt.Printf("status: %v\n", receipt.Status) // status: 1
  77. }