description: Tutorial on how to deploy a smart contract with Go.

Deploying a Smart Contract

If you haven’t already, check out the section on smart contract compilation since this lesson requires knowledge on compiling a solidity smart contract to a Go contract file.

Assuming you’ve imported the newly created Go package file generated from abigen, and set the ethclient, loaded your private key, the next step is to create a keyed transactor. First import the accounts/abi/bind package from go-ethereum and then invoke NewKeyedTransactor passing in the private key. Afterwards set the usual properties such as the nonce, gas price, gas limit, and ETH value.

  1. auth := bind.NewKeyedTransactor(privateKey)
  2. auth.Nonce = big.NewInt(int64(nonce))
  3. auth.Value = big.NewInt(0)     // in wei
  4. auth.GasLimit = uint64(300000) // in units
  5. auth.GasPrice = gasPrice

If you recall in the previous section, we created a very simpile Store contract that sets and stores key/value pairs. The generated Go contract file provides a deploy method. The deploy method name always starts with the word Deploy followed by the contract name, in this case it’s Store.

The deploy function takes in the keyed transactor, the ethclient, and any input arguments that the smart contract constructor might takes in. We’ve set our smart contract to take in a string argument for the version. This function will return the Ethereum address of the newly deployed contract, the transaction object, the contract instance so that we can start interacting with, and the error if any.

  1. input := "1.0"
  2. address, tx, instance, err := store.DeployStore(auth, client, input)
  3. if err != nil {
  4.   log.Fatal(err)
  5. }
  7. fmt.Println(address.Hex())   // 0x147B8eb97fD247D06C4006D269c90C1908Fb5D54
  8. fmt.Println(tx.Hash().Hex()) // 0xdae8ba5444eefdc99f4d45cd0c4f24056cba6a02cefbf78066ef9f4188ff7dc0
  10. _ = instance // will be using the instance in the next section

Yes it’s that simply. You can take the transaction hash and see the deployment status on Etherscan: https://rinkeby.etherscan.io/tx/0xdae8ba5444eefdc99f4d45cd0c4f24056cba6a02cefbf78066ef9f4188ff7dc0

Full code

Commands

  1. solc --abi Store.sol
  2. solc --bin Store.sol
  3. abigen --bin=Store_sol_Store.bin --abi=Store_sol_Store.abi --pkg=store --out=Store.go

Store.sol

  1. pragma solidity ^0.4.24;
  3. contract Store {
  4.   event ItemSet(bytes32 key, bytes32 value);
  6.   string public version;
  7.   mapping (bytes32 => bytes32) public items;
  9.   constructor(string _version) public {
  10.     version = _version;
  11.   }
  13.   function setItem(bytes32 key, bytes32 value) external {
  14.     items[key] = value;
  15.     emit ItemSet(key, value);
  16.   }
  17. }

contract_deploy.go

  1. package main
  3. import (
  4.     "context"
  5.     "crypto/ecdsa"
  6.     "fmt"
  7.     "log"
  8.     "math/big"
  10.     "github.com/ethereum/go-ethereum/accounts/abi/bind"
  11.     "github.com/ethereum/go-ethereum/crypto"
  12.     "github.com/ethereum/go-ethereum/ethclient"
  14.     store "./contracts" // for demo
  15. )
  17. func main() {
  18.     client, err := ethclient.Dial("https://rinkeby.infura.io")
  19.     if err != nil {
  20.         log.Fatal(err)
  21.     }
  23.     privateKey, err := crypto.HexToECDSA("fad9c8855b740a0b7ed4c221dbad0f33a83a49cad6b3fe8d5817ac83d38b6a19")
  24.     if err != nil {
  25.         log.Fatal(err)
  26.     }
  28.     publicKey := privateKey.Public()
  29.     publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey)
  30.     if !ok {
  31.         log.Fatal("cannot assert type: publicKey is not of type *ecdsa.PublicKey")
  32.     }
  34.     fromAddress := crypto.PubkeyToAddress(*publicKeyECDSA)
  35.     nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
  36.     if err != nil {
  37.         log.Fatal(err)
  38.     }
  40.     gasPrice, err := client.SuggestGasPrice(context.Background())
  41.     if err != nil {
  42.         log.Fatal(err)
  43.     }
  45.     auth := bind.NewKeyedTransactor(privateKey)
  46.     auth.Nonce = big.NewInt(int64(nonce))
  47.     auth.Value = big.NewInt(0)     // in wei
  48.     auth.GasLimit = uint64(300000) // in units
  49.     auth.GasPrice = gasPrice
  51.     input := "1.0"
  52.     address, tx, instance, err := store.DeployStore(auth, client, input)
  53.     if err != nil {
  54.         log.Fatal(err)
  55.     }
  57.     fmt.Println(address.Hex())   // 0x147B8eb97fD247D06C4006D269c90C1908Fb5D54
  58.     fmt.Println(tx.Hash().Hex()) // 0xdae8ba5444eefdc99f4d45cd0c4f24056cba6a02cefbf78066ef9f4188ff7dc0
  60.     _ = instance
  61. }

solc version used for these examples

  1. $ solc --version
  2. 0.4.24+commit.e67f0147.Emscripten.clang