Add True Eth2 Deposit Contract, Bytecode, ABI (#9637)

* solidity contract, abi, and deposit util

* gaz

* gaz

* drain contract remove

* build

* fix up deploy

* add readme

* fix e2e

* revert

* revert flag

* fix

* revert test flag

* fix broken test

Co-authored-by: prylabs-bulldozer[bot] <58059840+prylabs-bulldozer[bot]@users.noreply.github.com>

contracts/deposit/BUILD.bazel

@@ -0,0 +1,56 @@
+load("@prysm//tools/go:def.bzl", "go_library", "go_test")
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "contract.go",
+        "deposit.go",
+        "logs.go",
+        "mock.go",
+    ],
+    importpath = "github.com/prysmaticlabs/prysm/contracts/deposit",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//beacon-chain/core/helpers:go_default_library",
+        "//config/features:go_default_library",
+        "//config/params:go_default_library",
+        "//crypto/bls:go_default_library",
+        "//crypto/hash:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+        "@com_github_ethereum_go_ethereum//:go_default_library",
+        "@com_github_ethereum_go_ethereum//accounts/abi:go_default_library",
+        "@com_github_ethereum_go_ethereum//accounts/abi/bind:go_default_library",
+        "@com_github_ethereum_go_ethereum//accounts/abi/bind/backends:go_default_library",
+        "@com_github_ethereum_go_ethereum//common:go_default_library",
+        "@com_github_ethereum_go_ethereum//core:go_default_library",
+        "@com_github_ethereum_go_ethereum//core/types:go_default_library",
+        "@com_github_ethereum_go_ethereum//crypto:go_default_library",
+        "@com_github_ethereum_go_ethereum//event:go_default_library",
+        "@com_github_pkg_errors//:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    size = "medium",
+    srcs = [
+        "contract_test.go",
+        "deposit_test.go",
+        "deposit_tree_test.go",
+    ],
+    deps = [
+        ":go_default_library",
+        "//beacon-chain/core/helpers:go_default_library",
+        "//config/params:go_default_library",
+        "//container/trie:go_default_library",
+        "//crypto/bls:go_default_library",
+        "//proto/prysm/v1alpha1:go_default_library",
+        "//runtime/interop:go_default_library",
+        "//shared/testutil:go_default_library",
+        "//shared/testutil/assert:go_default_library",
+        "//shared/testutil/require:go_default_library",
+        "@com_github_ethereum_go_ethereum//:go_default_library",
+        "@com_github_ethereum_go_ethereum//accounts/abi/bind:go_default_library",
+        "@com_github_ethereum_go_ethereum//common:go_default_library",
+    ],
+)

contracts/deposit/README.md

@@ -0,0 +1,3 @@
+# Validator Deposit Contract Local Copy
+
+This package contains a copy of the official Ethereum [Validator Deposit Contract](https://github.com/ethereum/consensus-specs/tree/e4a9c5fa29def20c4264cd860868f131d6f40e72/solidity_deposit_contract) along with its ABI, bytecode, and Go bindings generated by go-ethereum's [abigen](https://github.com/ethereum/go-ethereum/tree/master/cmd/abigen) `version 1.10.4-stable`. It contains useful test harnesses for setting up and deploying a validator deposit contract using Go bindings, which are used across tests in Prysm.

contracts/deposit/abi.json

@@ -0,0 +1 @@
+[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes","name":"pubkey","type":"bytes"},{"indexed":false,"internalType":"bytes","name":"withdrawal_credentials","type":"bytes"},{"indexed":false,"internalType":"bytes","name":"amount","type":"bytes"},{"indexed":false,"internalType":"bytes","name":"signature","type":"bytes"},{"indexed":false,"internalType":"bytes","name":"index","type":"bytes"}],"name":"DepositEvent","type":"event"},{"inputs":[{"internalType":"bytes","name":"pubkey","type":"bytes"},{"internalType":"bytes","name":"withdrawal_credentials","type":"bytes"},{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"bytes32","name":"deposit_data_root","type":"bytes32"}],"name":"deposit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"get_deposit_count","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"get_deposit_root","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"}]

contracts/deposit/contract.go

@@ -0,0 +1,423 @@
+// Code generated - DO NOT EDIT.
+// This file is a generated binding and any manual changes will be lost.
+package deposit
+
+import (
+	"math/big"
+	"strings"
+
+	ethereum "github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/event"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var (
+	_ = big.NewInt
+	_ = strings.NewReader
+	_ = ethereum.NotFound
+	_ = bind.Bind
+	_ = common.Big1
+	_ = types.BloomLookup
+	_ = event.NewSubscription
+)
+
+// DepositContractABI is the input ABI used to generate the binding from.
+const DepositContractABI = "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"pubkey\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"withdrawal_credentials\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"amount\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"index\",\"type\":\"bytes\"}],\"name\":\"DepositEvent\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"pubkey\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"withdrawal_credentials\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"signature\",\"type\":\"bytes\"},{\"internalType\":\"bytes32\",\"name\":\"deposit_data_root\",\"type\":\"bytes32\"}],\"name\":\"deposit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"get_deposit_count\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"get_deposit_root\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"pure\",\"type\":\"function\"}]"
+
+// DepositContract is an auto generated Go binding around an Ethereum contract.
+type DepositContract struct {
+	DepositContractCaller     // Read-only binding to the contract
+	DepositContractTransactor // Write-only binding to the contract
+	DepositContractFilterer   // Log filterer for contract events
+}
+
+// DepositContractCaller is an auto generated read-only Go binding around an Ethereum contract.
+type DepositContractCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// DepositContractTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type DepositContractTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// DepositContractFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type DepositContractFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// DepositContractSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type DepositContractSession struct {
+	Contract     *DepositContract  // Generic contract binding to set the session for
+	CallOpts     bind.CallOpts     // Call options to use throughout this session
+	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
+}
+
+// DepositContractCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type DepositContractCallerSession struct {
+	Contract *DepositContractCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts          // Call options to use throughout this session
+}
+
+// DepositContractTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type DepositContractTransactorSession struct {
+	Contract     *DepositContractTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts          // Transaction auth options to use throughout this session
+}
+
+// DepositContractRaw is an auto generated low-level Go binding around an Ethereum contract.
+type DepositContractRaw struct {
+	Contract *DepositContract // Generic contract binding to access the raw methods on
+}
+
+// DepositContractCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type DepositContractCallerRaw struct {
+	Contract *DepositContractCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// DepositContractTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type DepositContractTransactorRaw struct {
+	Contract *DepositContractTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewDepositContract creates a new instance of DepositContract, bound to a specific deployed contract.
+func NewDepositContract(address common.Address, backend bind.ContractBackend) (*DepositContract, error) {
+	contract, err := bindDepositContract(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &DepositContract{DepositContractCaller: DepositContractCaller{contract: contract}, DepositContractTransactor: DepositContractTransactor{contract: contract}, DepositContractFilterer: DepositContractFilterer{contract: contract}}, nil
+}
+
+// NewDepositContractCaller creates a new read-only instance of DepositContract, bound to a specific deployed contract.
+func NewDepositContractCaller(address common.Address, caller bind.ContractCaller) (*DepositContractCaller, error) {
+	contract, err := bindDepositContract(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &DepositContractCaller{contract: contract}, nil
+}
+
+// NewDepositContractTransactor creates a new write-only instance of DepositContract, bound to a specific deployed contract.
+func NewDepositContractTransactor(address common.Address, transactor bind.ContractTransactor) (*DepositContractTransactor, error) {
+	contract, err := bindDepositContract(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &DepositContractTransactor{contract: contract}, nil
+}
+
+// NewDepositContractFilterer creates a new log filterer instance of DepositContract, bound to a specific deployed contract.
+func NewDepositContractFilterer(address common.Address, filterer bind.ContractFilterer) (*DepositContractFilterer, error) {
+	contract, err := bindDepositContract(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &DepositContractFilterer{contract: contract}, nil
+}
+
+// bindDepositContract binds a generic wrapper to an already deployed contract.
+func bindDepositContract(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := abi.JSON(strings.NewReader(DepositContractABI))
+	if err != nil {
+		return nil, err
+	}
+	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
+}
+
+// Call invokes the (constant) contract method with params as input values and
+// sets the output to result. The result type might be a single field for simple
+// returns, a slice of interfaces for anonymous returns and a struct for named
+// returns.
+func (_DepositContract *DepositContractRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _DepositContract.Contract.DepositContractCaller.contract.Call(opts, result, method, params...)
+}
+
+// Transfer initiates a plain transaction to move funds to the contract, calling
+// its default method if one is available.
+func (_DepositContract *DepositContractRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _DepositContract.Contract.DepositContractTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_DepositContract *DepositContractRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _DepositContract.Contract.DepositContractTransactor.contract.Transact(opts, method, params...)
+}
+
+// Call invokes the (constant) contract method with params as input values and
+// sets the output to result. The result type might be a single field for simple
+// returns, a slice of interfaces for anonymous returns and a struct for named
+// returns.
+func (_DepositContract *DepositContractCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _DepositContract.Contract.contract.Call(opts, result, method, params...)
+}
+
+// Transfer initiates a plain transaction to move funds to the contract, calling
+// its default method if one is available.
+func (_DepositContract *DepositContractTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _DepositContract.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_DepositContract *DepositContractTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _DepositContract.Contract.contract.Transact(opts, method, params...)
+}
+
+// GetDepositCount is a free data retrieval call binding the contract method 0x621fd130.
+//
+// Solidity: function get_deposit_count() view returns(bytes)
+func (_DepositContract *DepositContractCaller) GetDepositCount(opts *bind.CallOpts) ([]byte, error) {
+	var out []interface{}
+	err := _DepositContract.contract.Call(opts, &out, "get_deposit_count")
+
+	if err != nil {
+		return *new([]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([]byte)).(*[]byte)
+
+	return out0, err
+
+}
+
+// GetDepositCount is a free data retrieval call binding the contract method 0x621fd130.
+//
+// Solidity: function get_deposit_count() view returns(bytes)
+func (_DepositContract *DepositContractSession) GetDepositCount() ([]byte, error) {
+	return _DepositContract.Contract.GetDepositCount(&_DepositContract.CallOpts)
+}
+
+// GetDepositCount is a free data retrieval call binding the contract method 0x621fd130.
+//
+// Solidity: function get_deposit_count() view returns(bytes)
+func (_DepositContract *DepositContractCallerSession) GetDepositCount() ([]byte, error) {
+	return _DepositContract.Contract.GetDepositCount(&_DepositContract.CallOpts)
+}
+
+// GetDepositRoot is a free data retrieval call binding the contract method 0xc5f2892f.
+//
+// Solidity: function get_deposit_root() view returns(bytes32)
+func (_DepositContract *DepositContractCaller) GetDepositRoot(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _DepositContract.contract.Call(opts, &out, "get_deposit_root")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// GetDepositRoot is a free data retrieval call binding the contract method 0xc5f2892f.
+//
+// Solidity: function get_deposit_root() view returns(bytes32)
+func (_DepositContract *DepositContractSession) GetDepositRoot() ([32]byte, error) {
+	return _DepositContract.Contract.GetDepositRoot(&_DepositContract.CallOpts)
+}
+
+// GetDepositRoot is a free data retrieval call binding the contract method 0xc5f2892f.
+//
+// Solidity: function get_deposit_root() view returns(bytes32)
+func (_DepositContract *DepositContractCallerSession) GetDepositRoot() ([32]byte, error) {
+	return _DepositContract.Contract.GetDepositRoot(&_DepositContract.CallOpts)
+}
+
+// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
+//
+// Solidity: function supportsInterface(bytes4 interfaceId) pure returns(bool)
+func (_DepositContract *DepositContractCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) {
+	var out []interface{}
+	err := _DepositContract.contract.Call(opts, &out, "supportsInterface", interfaceId)
+
+	if err != nil {
+		return *new(bool), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(bool)).(*bool)
+
+	return out0, err
+
+}
+
+// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
+//
+// Solidity: function supportsInterface(bytes4 interfaceId) pure returns(bool)
+func (_DepositContract *DepositContractSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
+	return _DepositContract.Contract.SupportsInterface(&_DepositContract.CallOpts, interfaceId)
+}
+
+// SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7.
+//
+// Solidity: function supportsInterface(bytes4 interfaceId) pure returns(bool)
+func (_DepositContract *DepositContractCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) {
+	return _DepositContract.Contract.SupportsInterface(&_DepositContract.CallOpts, interfaceId)
+}
+
+// Deposit is a paid mutator transaction binding the contract method 0x22895118.
+//
+// Solidity: function deposit(bytes pubkey, bytes withdrawal_credentials, bytes signature, bytes32 deposit_data_root) payable returns()
+func (_DepositContract *DepositContractTransactor) Deposit(opts *bind.TransactOpts, pubkey []byte, withdrawal_credentials []byte, signature []byte, deposit_data_root [32]byte) (*types.Transaction, error) {
+	return _DepositContract.contract.Transact(opts, "deposit", pubkey, withdrawal_credentials, signature, deposit_data_root)
+}
+
+// Deposit is a paid mutator transaction binding the contract method 0x22895118.
+//
+// Solidity: function deposit(bytes pubkey, bytes withdrawal_credentials, bytes signature, bytes32 deposit_data_root) payable returns()
+func (_DepositContract *DepositContractSession) Deposit(pubkey []byte, withdrawal_credentials []byte, signature []byte, deposit_data_root [32]byte) (*types.Transaction, error) {
+	return _DepositContract.Contract.Deposit(&_DepositContract.TransactOpts, pubkey, withdrawal_credentials, signature, deposit_data_root)
+}
+
+// Deposit is a paid mutator transaction binding the contract method 0x22895118.
+//
+// Solidity: function deposit(bytes pubkey, bytes withdrawal_credentials, bytes signature, bytes32 deposit_data_root) payable returns()
+func (_DepositContract *DepositContractTransactorSession) Deposit(pubkey []byte, withdrawal_credentials []byte, signature []byte, deposit_data_root [32]byte) (*types.Transaction, error) {
+	return _DepositContract.Contract.Deposit(&_DepositContract.TransactOpts, pubkey, withdrawal_credentials, signature, deposit_data_root)
+}
+
+// DepositContractDepositEventIterator is returned from FilterDepositEvent and is used to iterate over the raw logs and unpacked data for DepositEvent events raised by the DepositContract contract.
+type DepositContractDepositEventIterator struct {
+	Event *DepositContractDepositEvent // Event containing the contract specifics and raw log
+
+	contract *bind.BoundContract // Generic contract to use for unpacking event data
+	event    string              // Event name to use for unpacking event data
+
+	logs chan types.Log        // Log channel receiving the found contract events
+	sub  ethereum.Subscription // Subscription for errors, completion and termination
+	done bool                  // Whether the subscription completed delivering logs
+	fail error                 // Occurred error to stop iteration
+}
+
+// Next advances the iterator to the subsequent event, returning whether there
+// are any more events found. In case of a retrieval or parsing error, false is
+// returned and Error() can be queried for the exact failure.
+func (it *DepositContractDepositEventIterator) Next() bool {
+	// If the iterator failed, stop iterating
+	if it.fail != nil {
+		return false
+	}
+	// If the iterator completed, deliver directly whatever's available
+	if it.done {
+		select {
+		case log := <-it.logs:
+			it.Event = new(DepositContractDepositEvent)
+			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+				it.fail = err
+				return false
+			}
+			it.Event.Raw = log
+			return true
+
+		default:
+			return false
+		}
+	}
+	// Iterator still in progress, wait for either a data or an error event
+	select {
+	case log := <-it.logs:
+		it.Event = new(DepositContractDepositEvent)
+		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+			it.fail = err
+			return false
+		}
+		it.Event.Raw = log
+		return true
+
+	case err := <-it.sub.Err():
+		it.done = true
+		it.fail = err
+		return it.Next()
+	}
+}
+
+// Error returns any retrieval or parsing error occurred during filtering.
+func (it *DepositContractDepositEventIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *DepositContractDepositEventIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// DepositContractDepositEvent represents a DepositEvent event raised by the DepositContract contract.
+type DepositContractDepositEvent struct {
+	Pubkey                []byte
+	WithdrawalCredentials []byte
+	Amount                []byte
+	Signature             []byte
+	Index                 []byte
+	Raw                   types.Log // Blockchain specific contextual infos
+}
+
+// FilterDepositEvent is a free log retrieval operation binding the contract event 0x649bbc62d0e31342afea4e5cd82d4049e7e1ee912fc0889aa790803be39038c5.
+//
+// Solidity: event DepositEvent(bytes pubkey, bytes withdrawal_credentials, bytes amount, bytes signature, bytes index)
+func (_DepositContract *DepositContractFilterer) FilterDepositEvent(opts *bind.FilterOpts) (*DepositContractDepositEventIterator, error) {
+
+	logs, sub, err := _DepositContract.contract.FilterLogs(opts, "DepositEvent")
+	if err != nil {
+		return nil, err
+	}
+	return &DepositContractDepositEventIterator{contract: _DepositContract.contract, event: "DepositEvent", logs: logs, sub: sub}, nil
+}
+
+// WatchDepositEvent is a free log subscription operation binding the contract event 0x649bbc62d0e31342afea4e5cd82d4049e7e1ee912fc0889aa790803be39038c5.
+//
+// Solidity: event DepositEvent(bytes pubkey, bytes withdrawal_credentials, bytes amount, bytes signature, bytes index)
+func (_DepositContract *DepositContractFilterer) WatchDepositEvent(opts *bind.WatchOpts, sink chan<- *DepositContractDepositEvent) (event.Subscription, error) {
+
+	logs, sub, err := _DepositContract.contract.WatchLogs(opts, "DepositEvent")
+	if err != nil {
+		return nil, err
+	}
+	return event.NewSubscription(func(quit <-chan struct{}) error {
+		defer sub.Unsubscribe()
+		for {
+			select {
+			case log := <-logs:
+				// New log arrived, parse the event and forward to the user
+				event := new(DepositContractDepositEvent)
+				if err := _DepositContract.contract.UnpackLog(event, "DepositEvent", log); err != nil {
+					return err
+				}
+				event.Raw = log
+
+				select {
+				case sink <- event:
+				case err := <-sub.Err():
+					return err
+				case <-quit:
+					return nil
+				}
+			case err := <-sub.Err():
+				return err
+			case <-quit:
+				return nil
+			}
+		}
+	}), nil
+}
+
+// ParseDepositEvent is a log parse operation binding the contract event 0x649bbc62d0e31342afea4e5cd82d4049e7e1ee912fc0889aa790803be39038c5.
+//
+// Solidity: event DepositEvent(bytes pubkey, bytes withdrawal_credentials, bytes amount, bytes signature, bytes index)
+func (_DepositContract *DepositContractFilterer) ParseDepositEvent(log types.Log) (*DepositContractDepositEvent, error) {
+	event := new(DepositContractDepositEvent)
+	if err := _DepositContract.contract.UnpackLog(event, "DepositEvent", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}

contracts/deposit/contract_test.go

@@ -0,0 +1,83 @@
+package deposit_test
+
+import (
+	"context"
+	"encoding/binary"
+	"testing"
+
+	"github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/common"
+	depositcontract "github.com/prysmaticlabs/prysm/contracts/deposit"
+	"github.com/prysmaticlabs/prysm/runtime/interop"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+)
+
+func TestSetupRegistrationContract_OK(t *testing.T) {
+	_, err := depositcontract.Setup()
+	assert.NoError(t, err, "Can not deploy validator registration contract")
+}
+
+// negative test case, deposit with less than 1 ETH which is less than the top off amount.
+func TestRegister_Below1ETH(t *testing.T) {
+	testAccount, err := depositcontract.Setup()
+	require.NoError(t, err)
+
+	// Generate deposit data
+	privKeys, pubKeys, err := interop.DeterministicallyGenerateKeys(0 /*startIndex*/, 1)
+	require.NoError(t, err)
+	depositDataItems, depositDataRoots, err := interop.DepositDataFromKeys(privKeys, pubKeys)
+	require.NoError(t, err)
+
+	var depositDataRoot [32]byte
+	copy(depositDataRoot[:], depositDataRoots[0])
+	testAccount.TxOpts.Value = depositcontract.LessThan1Eth()
+	_, err = testAccount.Contract.Deposit(testAccount.TxOpts, pubKeys[0].Marshal(), depositDataItems[0].WithdrawalCredentials, depositDataItems[0].Signature, depositDataRoot)
+	assert.ErrorContains(t, "execution reverted", err, "Validator registration should have failed with insufficient deposit")
+}
+
+// normal test case, test depositing 32 ETH and verify HashChainValue event is correctly emitted.
+func TestValidatorRegister_OK(t *testing.T) {
+	testAccount, err := depositcontract.Setup()
+	require.NoError(t, err)
+	testAccount.TxOpts.Value = depositcontract.Amount32Eth()
+
+	// Generate deposit data
+	privKeys, pubKeys, err := interop.DeterministicallyGenerateKeys(0 /*startIndex*/, 1)
+	require.NoError(t, err)
+	depositDataItems, depositDataRoots, err := interop.DepositDataFromKeys(privKeys, pubKeys)
+	require.NoError(t, err)
+
+	var depositDataRoot [32]byte
+	copy(depositDataRoot[:], depositDataRoots[0])
+	_, err = testAccount.Contract.Deposit(testAccount.TxOpts, pubKeys[0].Marshal(), depositDataItems[0].WithdrawalCredentials, depositDataItems[0].Signature, depositDataRoot)
+	testAccount.Backend.Commit()
+	require.NoError(t, err, "Validator registration failed")
+	_, err = testAccount.Contract.Deposit(testAccount.TxOpts, pubKeys[0].Marshal(), depositDataItems[0].WithdrawalCredentials, depositDataItems[0].Signature, depositDataRoot)
+	testAccount.Backend.Commit()
+	assert.NoError(t, err, "Validator registration failed")
+	_, err = testAccount.Contract.Deposit(testAccount.TxOpts, pubKeys[0].Marshal(), depositDataItems[0].WithdrawalCredentials, depositDataItems[0].Signature, depositDataRoot)
+	testAccount.Backend.Commit()
+	assert.NoError(t, err, "Validator registration failed")
+
+	query := ethereum.FilterQuery{
+		Addresses: []common.Address{
+			testAccount.ContractAddr,
+		},
+	}
+
+	logs, err := testAccount.Backend.FilterLogs(context.Background(), query)
+	assert.NoError(t, err, "Unable to get logs of deposit contract")
+
+	merkleTreeIndex := make([]uint64, 5)
+
+	for i, log := range logs {
+		_, _, _, _, idx, err := depositcontract.UnpackDepositLogData(log.Data)
+		require.NoError(t, err, "Unable to unpack log data")
+		merkleTreeIndex[i] = binary.LittleEndian.Uint64(idx)
+	}
+
+	assert.Equal(t, uint64(0), merkleTreeIndex[0], "Deposit event total desposit count miss matched")
+	assert.Equal(t, uint64(1), merkleTreeIndex[1], "Deposit event total desposit count miss matched")
+	assert.Equal(t, uint64(2), merkleTreeIndex[2], "Deposit event total desposit count miss matched")
+}

contracts/deposit/deposit.go

@@ -0,0 +1,115 @@
+// Package depositutil contains useful functions for dealing
+// with Ethereum deposit inputs.
+package deposit
+
+import (
+	"github.com/pkg/errors"
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/config/features"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/crypto/bls"
+	"github.com/prysmaticlabs/prysm/crypto/hash"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+)
+
+// DepositInput for a given key. This input data can be used to when making a
+// validator deposit. The input data includes a proof of possession field
+// signed by the deposit key.
+//
+// Spec details about general deposit workflow:
+//   To submit a deposit:
+//
+//   - Pack the validator's initialization parameters into deposit_data, a Deposit_Data SSZ object.
+//   - Let amount be the amount in Gwei to be deposited by the validator where MIN_DEPOSIT_AMOUNT <= amount <= MAX_EFFECTIVE_BALANCE.
+//   - Set deposit_data.amount = amount.
+//   - Let signature be the result of bls_sign of the signing_root(deposit_data) with domain=compute_domain(DOMAIN_DEPOSIT). (Deposits are valid regardless of fork version, compute_domain will default to zeroes there).
+//   - Send a transaction on the Ethereum 1.0 chain to DEPOSIT_CONTRACT_ADDRESS executing `deposit(pubkey: bytes[48], withdrawal_credentials: bytes[32], signature: bytes[96])` along with a deposit of amount Gwei.
+//
+// See: https://github.com/ethereum/consensus-specs/blob/master/specs/validator/0_beacon-chain-validator.md#submit-deposit
+func DepositInput(depositKey, withdrawalKey bls.SecretKey, amountInGwei uint64) (*ethpb.Deposit_Data, [32]byte, error) {
+	depositMessage := &ethpb.DepositMessage{
+		PublicKey:             depositKey.PublicKey().Marshal(),
+		WithdrawalCredentials: WithdrawalCredentialsHash(withdrawalKey),
+		Amount:                amountInGwei,
+	}
+
+	sr, err := depositMessage.HashTreeRoot()
+	if err != nil {
+		return nil, [32]byte{}, err
+	}
+
+	domain, err := helpers.ComputeDomain(
+		params.BeaconConfig().DomainDeposit,
+		nil, /*forkVersion*/
+		nil, /*genesisValidatorsRoot*/
+	)
+	if err != nil {
+		return nil, [32]byte{}, err
+	}
+	root, err := (&ethpb.SigningData{ObjectRoot: sr[:], Domain: domain}).HashTreeRoot()
+	if err != nil {
+		return nil, [32]byte{}, err
+	}
+	di := &ethpb.Deposit_Data{
+		PublicKey:             depositMessage.PublicKey,
+		WithdrawalCredentials: depositMessage.WithdrawalCredentials,
+		Amount:                depositMessage.Amount,
+		Signature:             depositKey.Sign(root[:]).Marshal(),
+	}
+
+	dr, err := di.HashTreeRoot()
+	if err != nil {
+		return nil, [32]byte{}, err
+	}
+
+	return di, dr, nil
+}
+
+// WithdrawalCredentialsHash forms a 32 byte hash of the withdrawal public
+// address.
+//
+// The specification is as follows:
+//   withdrawal_credentials[:1] == BLS_WITHDRAWAL_PREFIX_BYTE
+//   withdrawal_credentials[1:] == hash(withdrawal_pubkey)[1:]
+// where withdrawal_credentials is of type bytes32.
+func WithdrawalCredentialsHash(withdrawalKey bls.SecretKey) []byte {
+	h := hash.Hash(withdrawalKey.PublicKey().Marshal())
+	return append([]byte{params.BeaconConfig().BLSWithdrawalPrefixByte}, h[1:]...)[:32]
+}
+
+// VerifyDepositSignature verifies the correctness of Eth1 deposit BLS signature
+func VerifyDepositSignature(dd *ethpb.Deposit_Data, domain []byte) error {
+	if features.Get().SkipBLSVerify {
+		return nil
+	}
+	ddCopy := ethpb.CopyDepositData(dd)
+	publicKey, err := bls.PublicKeyFromBytes(ddCopy.PublicKey)
+	if err != nil {
+		return errors.Wrap(err, "could not convert bytes to public key")
+	}
+	sig, err := bls.SignatureFromBytes(ddCopy.Signature)
+	if err != nil {
+		return errors.Wrap(err, "could not convert bytes to signature")
+	}
+	di := &ethpb.DepositMessage{
+		PublicKey:             ddCopy.PublicKey,
+		WithdrawalCredentials: ddCopy.WithdrawalCredentials,
+		Amount:                ddCopy.Amount,
+	}
+	root, err := di.HashTreeRoot()
+	if err != nil {
+		return errors.Wrap(err, "could not get signing root")
+	}
+	signingData := &ethpb.SigningData{
+		ObjectRoot: root[:],
+		Domain:     domain,
+	}
+	ctrRoot, err := signingData.HashTreeRoot()
+	if err != nil {
+		return errors.Wrap(err, "could not get container root")
+	}
+	if !sig.Verify(publicKey, ctrRoot[:]) {
+		return helpers.ErrSigFailedToVerify
+	}
+	return nil
+}

contracts/deposit/deposit_contract.sol

@@ -0,0 +1,178 @@
+// ┏━━━┓━┏┓━┏┓━━┏━━━┓━━┏━━━┓━━━━┏━━━┓━━━━━━━━━━━━━━━━━━━┏┓━━━━━┏━━━┓━━━━━━━━━┏┓━━━━━━━━━━━━━━┏┓━
+// ┃┏━━┛┏┛┗┓┃┃━━┃┏━┓┃━━┃┏━┓┃━━━━┗┓┏┓┃━━━━━━━━━━━━━━━━━━┏┛┗┓━━━━┃┏━┓┃━━━━━━━━┏┛┗┓━━━━━━━━━━━━┏┛┗┓
+// ┃┗━━┓┗┓┏┛┃┗━┓┗┛┏┛┃━━┃┃━┃┃━━━━━┃┃┃┃┏━━┓┏━━┓┏━━┓┏━━┓┏┓┗┓┏┛━━━━┃┃━┗┛┏━━┓┏━┓━┗┓┏┛┏━┓┏━━┓━┏━━┓┗┓┏┛
+// ┃┏━━┛━┃┃━┃┏┓┃┏━┛┏┛━━┃┃━┃┃━━━━━┃┃┃┃┃┏┓┃┃┏┓┃┃┏┓┃┃━━┫┣┫━┃┃━━━━━┃┃━┏┓┃┏┓┃┃┏┓┓━┃┃━┃┏┛┗━┓┃━┃┏━┛━┃┃━
+// ┃┗━━┓━┃┗┓┃┃┃┃┃┃┗━┓┏┓┃┗━┛┃━━━━┏┛┗┛┃┃┃━┫┃┗┛┃┃┗┛┃┣━━┃┃┃━┃┗┓━━━━┃┗━┛┃┃┗┛┃┃┃┃┃━┃┗┓┃┃━┃┗┛┗┓┃┗━┓━┃┗┓
+// ┗━━━┛━┗━┛┗┛┗┛┗━━━┛┗┛┗━━━┛━━━━┗━━━┛┗━━┛┃┏━┛┗━━┛┗━━┛┗┛━┗━┛━━━━┗━━━┛┗━━┛┗┛┗┛━┗━┛┗┛━┗━━━┛┗━━┛━┗━┛
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┃┃━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┗┛━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+// SPDX-License-Identifier: CC0-1.0
+
+pragma solidity 0.6.11;
+
+// This interface is designed to be compatible with the Vyper version.
+/// @notice This is the Ethereum 2.0 deposit contract interface.
+/// For more information see the Phase 0 specification under https://github.com/ethereum/eth2.0-specs
+interface IDepositContract {
+    /// @notice A processed deposit event.
+    event DepositEvent(
+        bytes pubkey,
+        bytes withdrawal_credentials,
+        bytes amount,
+        bytes signature,
+        bytes index
+    );
+
+    /// @notice Submit a Phase 0 DepositData object.
+    /// @param pubkey A BLS12-381 public key.
+    /// @param withdrawal_credentials Commitment to a public key for withdrawals.
+    /// @param signature A BLS12-381 signature.
+    /// @param deposit_data_root The SHA-256 hash of the SSZ-encoded DepositData object.
+    /// Used as a protection against malformed input.
+    function deposit(
+        bytes calldata pubkey,
+        bytes calldata withdrawal_credentials,
+        bytes calldata signature,
+        bytes32 deposit_data_root
+    ) external payable;
+
+    /// @notice Query the current deposit root hash.
+    /// @return The deposit root hash.
+    function get_deposit_root() external view returns (bytes32);
+
+    /// @notice Query the current deposit count.
+    /// @return The deposit count encoded as a little endian 64-bit number.
+    function get_deposit_count() external view returns (bytes memory);
+}
+
+// Based on official specification in https://eips.ethereum.org/EIPS/eip-165
+interface ERC165 {
+    /// @notice Query if a contract implements an interface
+    /// @param interfaceId The interface identifier, as specified in ERC-165
+    /// @dev Interface identification is specified in ERC-165. This function
+    ///  uses less than 30,000 gas.
+    /// @return `true` if the contract implements `interfaceId` and
+    ///  `interfaceId` is not 0xffffffff, `false` otherwise
+    function supportsInterface(bytes4 interfaceId) external pure returns (bool);
+}
+
+// This is a rewrite of the Vyper Eth2.0 deposit contract in Solidity.
+// It tries to stay as close as possible to the original source code.
+/// @notice This is the Ethereum 2.0 deposit contract interface.
+/// For more information see the Phase 0 specification under https://github.com/ethereum/eth2.0-specs
+contract DepositContract is IDepositContract, ERC165 {
+    uint constant DEPOSIT_CONTRACT_TREE_DEPTH = 32;
+    // NOTE: this also ensures `deposit_count` will fit into 64-bits
+    uint constant MAX_DEPOSIT_COUNT = 2**DEPOSIT_CONTRACT_TREE_DEPTH - 1;
+
+    bytes32[DEPOSIT_CONTRACT_TREE_DEPTH] branch;
+    uint256 deposit_count;
+
+    bytes32[DEPOSIT_CONTRACT_TREE_DEPTH] zero_hashes;
+
+    constructor() public {
+        // Compute hashes in empty sparse Merkle tree
+        for (uint height = 0; height < DEPOSIT_CONTRACT_TREE_DEPTH - 1; height++)
+            zero_hashes[height + 1] = sha256(abi.encodePacked(zero_hashes[height], zero_hashes[height]));
+    }
+
+    function get_deposit_root() override external view returns (bytes32) {
+        bytes32 node;
+        uint size = deposit_count;
+        for (uint height = 0; height < DEPOSIT_CONTRACT_TREE_DEPTH; height++) {
+            if ((size & 1) == 1)
+                node = sha256(abi.encodePacked(branch[height], node));
+            else
+                node = sha256(abi.encodePacked(node, zero_hashes[height]));
+            size /= 2;
+        }
+        return sha256(abi.encodePacked(
+                node,
+                to_little_endian_64(uint64(deposit_count)),
+                bytes24(0)
+            ));
+    }
+
+    function get_deposit_count() override external view returns (bytes memory) {
+        return to_little_endian_64(uint64(deposit_count));
+    }
+
+    function deposit(
+        bytes calldata pubkey,
+        bytes calldata withdrawal_credentials,
+        bytes calldata signature,
+        bytes32 deposit_data_root
+    ) override external payable {
+        // Extended ABI length checks since dynamic types are used.
+        require(pubkey.length == 48, "DepositContract: invalid pubkey length");
+        require(withdrawal_credentials.length == 32, "DepositContract: invalid withdrawal_credentials length");
+        require(signature.length == 96, "DepositContract: invalid signature length");
+
+        // Check deposit amount
+        require(msg.value >= 1 ether, "DepositContract: deposit value too low");
+        require(msg.value % 1 gwei == 0, "DepositContract: deposit value not multiple of gwei");
+        uint deposit_amount = msg.value / 1 gwei;
+        require(deposit_amount <= type(uint64).max, "DepositContract: deposit value too high");
+
+        // Emit `DepositEvent` log
+        bytes memory amount = to_little_endian_64(uint64(deposit_amount));
+        emit DepositEvent(
+            pubkey,
+            withdrawal_credentials,
+            amount,
+            signature,
+            to_little_endian_64(uint64(deposit_count))
+        );
+
+        // Compute deposit data root (`DepositData` hash tree root)
+        bytes32 pubkey_root = sha256(abi.encodePacked(pubkey, bytes16(0)));
+        bytes32 signature_root = sha256(abi.encodePacked(
+                sha256(abi.encodePacked(signature[:64])),
+                sha256(abi.encodePacked(signature[64:], bytes32(0)))
+            ));
+        bytes32 node = sha256(abi.encodePacked(
+                sha256(abi.encodePacked(pubkey_root, withdrawal_credentials)),
+                sha256(abi.encodePacked(amount, bytes24(0), signature_root))
+            ));
+
+        // Verify computed and expected deposit data roots match
+        require(node == deposit_data_root, "DepositContract: reconstructed DepositData does not match supplied deposit_data_root");
+
+        // Avoid overflowing the Merkle tree (and prevent edge case in computing `branch`)
+        require(deposit_count < MAX_DEPOSIT_COUNT, "DepositContract: merkle tree full");
+
+        // Add deposit data root to Merkle tree (update a single `branch` node)
+        deposit_count += 1;
+        uint size = deposit_count;
+        for (uint height = 0; height < DEPOSIT_CONTRACT_TREE_DEPTH; height++) {
+            if ((size & 1) == 1) {
+                branch[height] = node;
+                return;
+            }
+            node = sha256(abi.encodePacked(branch[height], node));
+            size /= 2;
+        }
+        // As the loop should always end prematurely with the `return` statement,
+        // this code should be unreachable. We assert `false` just to be safe.
+        assert(false);
+    }
+
+    function supportsInterface(bytes4 interfaceId) override external pure returns (bool) {
+        return interfaceId == type(ERC165).interfaceId || interfaceId == type(IDepositContract).interfaceId;
+    }
+
+    function to_little_endian_64(uint64 value) internal pure returns (bytes memory ret) {
+        ret = new bytes(8);
+        bytes8 bytesValue = bytes8(value);
+        // Byteswapping during copying to bytes.
+        ret[0] = bytesValue[7];
+        ret[1] = bytesValue[6];
+        ret[2] = bytesValue[5];
+        ret[3] = bytesValue[4];
+        ret[4] = bytesValue[3];
+        ret[5] = bytesValue[2];
+        ret[6] = bytesValue[1];
+        ret[7] = bytesValue[0];
+    }
+}

contracts/deposit/deposit_test.go

@@ -0,0 +1,75 @@
+package deposit_test
+
+import (
+	"testing"
+
+	"github.com/prysmaticlabs/prysm/beacon-chain/core/helpers"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/contracts/deposit"
+	"github.com/prysmaticlabs/prysm/crypto/bls"
+	ethpb "github.com/prysmaticlabs/prysm/proto/prysm/v1alpha1"
+	"github.com/prysmaticlabs/prysm/shared/testutil"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+)
+
+func TestDepositInput_GeneratesPb(t *testing.T) {
+	k1, err := bls.RandKey()
+	require.NoError(t, err)
+	k2, err := bls.RandKey()
+	require.NoError(t, err)
+
+	result, _, err := deposit.DepositInput(k1, k2, 0)
+	require.NoError(t, err)
+	assert.DeepEqual(t, k1.PublicKey().Marshal(), result.PublicKey)
+
+	sig, err := bls.SignatureFromBytes(result.Signature)
+	require.NoError(t, err)
+	testData := &ethpb.DepositMessage{
+		PublicKey:             result.PublicKey,
+		WithdrawalCredentials: result.WithdrawalCredentials,
+		Amount:                result.Amount,
+	}
+	sr, err := testData.HashTreeRoot()
+	require.NoError(t, err)
+	domain, err := helpers.ComputeDomain(
+		params.BeaconConfig().DomainDeposit,
+		nil, /*forkVersion*/
+		nil, /*genesisValidatorsRoot*/
+	)
+	require.NoError(t, err)
+	root, err := (&ethpb.SigningData{ObjectRoot: sr[:], Domain: domain}).HashTreeRoot()
+	require.NoError(t, err)
+	assert.Equal(t, true, sig.Verify(k1.PublicKey(), root[:]))
+}
+
+func TestVerifyDepositSignature_ValidSig(t *testing.T) {
+	deposits, _, err := testutil.DeterministicDepositsAndKeys(1)
+	require.NoError(t, err)
+	dep := deposits[0]
+	domain, err := helpers.ComputeDomain(
+		params.BeaconConfig().DomainDeposit,
+		params.BeaconConfig().GenesisForkVersion,
+		params.BeaconConfig().ZeroHash[:],
+	)
+	require.NoError(t, err)
+	err = deposit.VerifyDepositSignature(dep.Data, domain)
+	require.NoError(t, err)
+}
+
+func TestVerifyDepositSignature_InvalidSig(t *testing.T) {
+	deposits, _, err := testutil.DeterministicDepositsAndKeys(1)
+	require.NoError(t, err)
+	dep := deposits[0]
+	domain, err := helpers.ComputeDomain(
+		params.BeaconConfig().DomainDeposit,
+		params.BeaconConfig().GenesisForkVersion,
+		params.BeaconConfig().ZeroHash[:],
+	)
+	require.NoError(t, err)
+	dep.Data.Signature = dep.Data.Signature[1:]
+	err = deposit.VerifyDepositSignature(dep.Data, domain)
+	if err == nil {
+		t.Fatal("Deposit Verification succeeds with a invalid signature")
+	}
+}

contracts/deposit/deposit_tree_test.go

@@ -0,0 +1,94 @@
+package deposit_test
+
+import (
+	"strconv"
+	"testing"
+
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/prysmaticlabs/prysm/config/params"
+	"github.com/prysmaticlabs/prysm/container/trie"
+	depositcontract "github.com/prysmaticlabs/prysm/contracts/deposit"
+	"github.com/prysmaticlabs/prysm/runtime/interop"
+	"github.com/prysmaticlabs/prysm/shared/testutil/assert"
+	"github.com/prysmaticlabs/prysm/shared/testutil/require"
+)
+
+func TestDepositTrieRoot_OK(t *testing.T) {
+	testAcc, err := depositcontract.Setup()
+	require.NoError(t, err)
+
+	localTrie, err := trie.NewTrie(params.BeaconConfig().DepositContractTreeDepth)
+	require.NoError(t, err)
+
+	depRoot, err := testAcc.Contract.GetDepositRoot(&bind.CallOpts{})
+	require.NoError(t, err)
+
+	assert.Equal(t, depRoot, localTrie.HashTreeRoot(), "Local deposit trie root and contract deposit trie root are not equal")
+
+	privKeys, pubKeys, err := interop.DeterministicallyGenerateKeys(0 /*startIndex*/, 101)
+	require.NoError(t, err)
+	depositDataItems, depositDataRoots, err := interop.DepositDataFromKeys(privKeys, pubKeys)
+	require.NoError(t, err)
+
+	testAcc.TxOpts.Value = depositcontract.Amount32Eth()
+
+	for i := 0; i < 100; i++ {
+		data := depositDataItems[i]
+		dataRoot := [32]byte{}
+		copy(dataRoot[:], depositDataRoots[i])
+
+		_, err := testAcc.Contract.Deposit(testAcc.TxOpts, data.PublicKey, data.WithdrawalCredentials, data.Signature, dataRoot)
+		require.NoError(t, err, "Could not deposit to deposit contract")
+
+		testAcc.Backend.Commit()
+		item, err := data.HashTreeRoot()
+		require.NoError(t, err)
+
+		localTrie.Insert(item[:], i)
+		depRoot, err = testAcc.Contract.GetDepositRoot(&bind.CallOpts{})
+		require.NoError(t, err)
+		assert.Equal(t, depRoot, localTrie.HashTreeRoot(), "Local deposit trie root and contract deposit trie root are not equal for index %d", i)
+	}
+}
+
+func TestDepositTrieRoot_Fail(t *testing.T) {
+	testAcc, err := depositcontract.Setup()
+	require.NoError(t, err)
+
+	localTrie, err := trie.NewTrie(params.BeaconConfig().DepositContractTreeDepth)
+	require.NoError(t, err)
+
+	depRoot, err := testAcc.Contract.GetDepositRoot(&bind.CallOpts{})
+	require.NoError(t, err)
+
+	assert.Equal(t, depRoot, localTrie.HashTreeRoot(), "Local deposit trie root and contract deposit trie root are not equal")
+
+	privKeys, pubKeys, err := interop.DeterministicallyGenerateKeys(0 /*startIndex*/, 101)
+	require.NoError(t, err)
+	depositDataItems, depositDataRoots, err := interop.DepositDataFromKeys(privKeys, pubKeys)
+	require.NoError(t, err)
+	testAcc.TxOpts.Value = depositcontract.Amount32Eth()
+
+	for i := 0; i < 100; i++ {
+		data := depositDataItems[i]
+		dataRoot := [32]byte{}
+		copy(dataRoot[:], depositDataRoots[i])
+
+		_, err := testAcc.Contract.Deposit(testAcc.TxOpts, data.PublicKey, data.WithdrawalCredentials, data.Signature, dataRoot)
+		require.NoError(t, err, "Could not deposit to deposit contract")
+
+		// Change an element in the data when storing locally
+		copy(data.PublicKey, strconv.Itoa(i+10))
+
+		testAcc.Backend.Commit()
+		item, err := data.HashTreeRoot()
+		require.NoError(t, err)
+
+		localTrie.Insert(item[:], i)
+
+		depRoot, err = testAcc.Contract.GetDepositRoot(&bind.CallOpts{})
+		require.NoError(t, err)
+
+		assert.NotEqual(t, depRoot, localTrie.HashTreeRoot(), "Local deposit trie root and contract deposit trie root are equal for index %d", i)
+	}
+}

contracts/deposit/logs.go

@@ -0,0 +1,24 @@
+package deposit
+
+import (
+	"bytes"
+
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/pkg/errors"
+)
+
+// UnpackDepositLogData unpacks the data from a deposit log using the ABI decoder.
+func UnpackDepositLogData(data []byte) (pubkey, withdrawalCredentials, amount, signature, index []byte, err error) {
+	reader := bytes.NewReader([]byte(DepositContractABI))
+	contractAbi, err := abi.JSON(reader)
+	if err != nil {
+		return nil, nil, nil, nil, nil, errors.Wrap(err, "unable to generate contract abi")
+	}
+
+	unpackedLogs, err := contractAbi.Unpack("DepositEvent", data)
+	if err != nil {
+		return nil, nil, nil, nil, nil, errors.Wrap(err, "unable to unpack logs")
+	}
+
+	return unpackedLogs[0].([]byte), unpackedLogs[1].([]byte), unpackedLogs[2].([]byte), unpackedLogs[3].([]byte), unpackedLogs[4].([]byte), nil
+}